Visual Testing Of Angular Components With Storybook & Chromatic

In a previous article, From paper sketch to a running application - Adobe XD, Storybook & Angular in action, I described the basics of writing Storybook stories and Angular components. In this follow-up, you will learn to enhance the Storybook workflow through visual testing to achieve fast feedback and development iterations. Not only does visual testing improve the overall quality and stability of your web-based software. The stakeholders also get to see something early, which means that changes are still possible in the developing process.

In this article:

Konstantin Denerz is architect and consultant at Thinktecture and focuses on Angular and User Experience improvement.

Use Case

Let’s say we have a mono repository with a core library and some core components that should be used in different Angular applications. One of those components is a button component with a badge notification. In the main branch of our repository, it looks like the screen below.

The source code for the sample used in this article is available in this GitHub repo:

In one of our feature branches, we created new components and changed some CSS variables. Let’s get this bug in the application: the badge notification with the number 42 is now located behind our button, because the z-index is wrong:

It’s just a small visual issue that is hard to find by unit or integration tests. In the best case, the bug will be found and fixed before the rollout. Most likely, it won’t be discovered before.

Manual vs. Automatic Tests of Angular Components

Indeed you can find such a bug by having many human test users. This manual testing requires resources and test plans before each release, though.

Another way is the use of automatic tests. Most developers are already familiar with unit tests, responsible for testing internal low-level logic without dependencies. In our case, we want to write integration tests to test the interaction of several components, like button and badge. Of course, we could set up a test that checks several CSS styles, e.g. to test badge’s z-index and buttons, but these tests would be very long, unreadable, and complicated. Instead, we will write visual tests based on image snapshots.

Visual Regression Tests

Visual tests create an image snapshot of a component in a specific state. In our use case, I made the first image snapshot of the button with the badge and merged it into the main branch before the error has crept in. We call these snapshots baseline.

Each build process in the new feature branches should

  • run the visual tests,
  • create new image snapshots, and
  • compare them against the baseline.

One (commercial) framework that supports this approach is Chromatic.

Visual Regression Tests with Storybook and Chromatic

Chromatic is a platform that offers the following features:

  • The publishing of statically built Storybook web applications (as a collection of components) in the cloud
  • Image snapshot creation (visual test)
  • Review and change request feature


Add the required Storybook tooling into your repo path if not already installed:

					npx sb init


Install the Chromatic CLI:

					npm install --save-dev chromatic


The CLI builds and publishes your Storybook project. We need a project-token for authentication with Chromatic before the CLI can publish the local version on the Chromatic site to see the visual changes. Therefore you have to visit and create a new project based on a project from your linked account (e.g. GitHub, GitLab, Bitbucket), or scratch.

Publish & Run

Now you should see a screen like this:

To create the baseline snapshots, we should check out the main branch and build and publish the Storybook project with the following command:

					npx chromatic --project-token=PROJECT_TOKEN

The project token in the command above is available on the initial screen or Chromatic’s manage page. The screen below shows the output of the command.

Visual Changes

The next step is to create, for example, a new component in the feature/chip-component branch. After commit and push to the linked version control service, we can create a pull request. This pull request is now visible in Chromatic, but it requires additional action. This action is usually carried out by a continuous integration (CI) build, but we can run it locally, too:

Check out the feature branch if not done yet:

					git checkout feature/chip-component


Publish the Storybook from our feature branch:

					npx chromatic --project-token=PROJECT_TOKEN


And this is the result we are longing for: now you can review the visual changes and accept or deny them:


In this article, you saw an easy way for visual testing of Angular components with Chromatic, a commercial product (we are not related to that company in any way, BTW). Of course, you can also do so without Chromatic and, for example, rely on your own implementation. The steps are equal: build Storybook in the feature branch, create image snapshots (on your own with your own tooling), and compare them with the baseline.


Current articles, screencasts and interviews by our experts

Don’t miss any content on Angular, .NET Core, Blazor, Azure, and Kubernetes and sign up for our free monthly dev newsletter.

EN Newsletter Anmeldung (#7)
Related Articles
One of the more pragmatic ways to get going on the current AI hype, and to get some value out of it, is by leveraging semantic search. This is, in itself, a relatively simple concept: You have a bunch of documents and want to find the correct one based on a given query. The semantic part now allows you to find the correct document based on the meaning of its contents, in contrast to simply finding words or parts of words in it like we usually do with lexical search. In our last projects, we gathered some experience with search bots, and with this article, I'd love to share our insights with you.
If you previously wanted to integrate view transitions into your Angular application, this was only possible in a very cumbersome way that needed a lot of detailed knowledge about Angular internals. Now, Angular 17 introduced a feature to integrate the View Transition API with the router. In this two-part series, we will look at how to leverage the feature for route transitions and how we could use it for single-page animations.
.NET 8 brings Native AOT to ASP.NET Core, but many frameworks and libraries rely on unbound reflection internally and thus cannot support this scenario yet. This is true for ORMs, too: EF Core and Dapper will only bring full support for Native AOT in later releases. In this post, we will implement a database access layer with Sessions using the Humble Object pattern to get a similar developer experience. We will use Npgsql as a plain ADO.NET provider targeting PostgreSQL.