This chapter offers tips and techniques for testing Angular applications. Along the way you will learn some general testing principles and techniques but the focus is on testing applications written with Angular

Table of Contents

1. Introduction to Angular Testing
   
   
2. Setup
   • setup files: karma.conf, karma-test-shim, systemjs.config
   • npm packages
3. The first karma test
   
   
4. Introduction to the Angular testing utilities
   
   
5. The sample application and its tests
   
   
6. A simple component test
   • configureTestingModule
   • createComponent
   • ComponentFixture, DebugElement, query(By.css)
   • detectChanges
   • autoDetectChanges
7. Test a component with a service dependency
   • test doubles
   • get the injected service
   • TestBed.get
8. Test a component with an async service
   • spies
   • async
   • whenStable
   • fakeAsync
   • tick
   • jasmine.done
9. Test a component with an external template
   • async in beforeEach
   • compileComponents
10. Test a component with inputs and outputs
    • triggerEventHandler
11. Test a component inside a test host component
    
    
12. Test a routed component
    • inject
13. Test a routed component with parameters
    • Observable test double
14. Use a page object to simplify setup
    
    
15. Setup with module imports
    
    
16. Override component providers
    
    
17. Test a RouterOutlet component
    • stubbing unneeded components
    • Stubbing the RouterLink
    • By.directive and injected directives
18. "Shallow" component tests with NO_ERRORS_SCHEMA
    
    
19. Test an attribute directive
    
    
20. Isolated unit tests
    • Services
    • Pipes
    • Components
21. Angular testing utility APIs
    • Stand-alone functions: async, fakeAsync, etc.
    • TestBed
    • ComponentFixture
    • DebugElement
22. FAQ

It’s a big agenda. Fortunately, you can learn a little bit at a time and put each lesson to use.

Live examples

The chapter sample code is available as live examples for inspection, experiment, and download.

• The sample application
• The first spec
• The complete application specs
• A grab bag of demonstration specs

Introduction to Angular Testing

You write tests to explore and confirm the behavior of the application.

1. They guard against changes that break existing code (“regressions”).

2. They clarify what the code does both when used as intended and when faced with deviant conditions.

3. They reveal mistakes in design and implementation. Tests shine a harsh light on the code from many angles. When a part of the application seems hard to test, the root cause is often a design flaw, something to cure now rather than later when it becomes expensive to fix.

Tools and Technologies

You can write and run Angular tests with a variety of tools and technologies. This chapter describes specific choices that are known to work well.

Setup

Many think writing tests is fun. Few enjoy setting up the test environment. To get to the fun as quickly as possible, the deep details of setup appear later in the chapter (forthcoming). A bare minimum of discussion plus the downloadable source code must suffice for now.

There are two fast paths to getting started.

1. Start a new project following the instructions in the QuickStart github repository.

2. Start a new project with the Angular CLI.

Both approaches install npm packages, files, and scripts pre-configured for applications built in their respective modalities. Their artifacts and procedures differ slightly but their essentials are the same and there are no differences in the test code.

In this chapter, the application and its tests are based on the QuickStart repo.

Setup files

Here's brief description of the setup files.

npm packages

The sample tests are written to run in Jasmine and karma. The two "fast path" setups added the appropriate Jasmine and karma npm packages to the devDependencies section of the package.json. They were installed when you ran npm install.

The first karma test

Start with a simple test to make sure the setup works properly.

Create a new file called 1st.spec.ts in the application root folder, app/

Put spec files somewhere within the app/ folder. The karma.conf.js tells karma to look for spec files there, for reasons explained below.

Add the following code to app/1st.spec.ts.

Run karma

Compile and run it in karma from the command line with this command:

The command compiles the application and test code and starts karma. Both processes watch pertinent files, write messages to the console, and re-run when they detect changes.

After a few moments, karma opens a browser and starts writing to the console.

Hide (don't close!) the browser and focus on the console output which should look something like this.

Both the compiler and karma continue to run. The compiler output is preceeded by [0]; the karma output by [1].

Change the expectation from true to false.

The compiler watcher detects the change and recompiles.

The karma watcher detects the change to the compilation output and re-runs the test.

It failed of course.

Restore the expectation from false back to true. Both processes detect the change, re-run, and karma reports complete success.

Test debugging

Debug specs in the browser in the same way you debug an application.

• Reveal the karma browser window (hidden earlier).
• Click the "DEBUG" button; it opens a new browser tab and re-runs the tests
• Open the browser's “Developer Tools” (F12 or Ctrl-Shift-I).
• Pick the "sources" section
• Open the 1st.spec.ts test file (Ctrl-P, then start typing the name of the file).
• Set a breakpoint in the test
• Refresh the browser … and it stops at the breakpoint.

Introduction to the Angular Testing Utilities

Many tests explore how applications classes interact with Angular and the DOM while under Angular's control.

Such tests are easy to write with the help of the Angular testing utilities which include the TestBed class and some helper functions.

Tests written with these utilities are the main focus of this chapter. But they are not the only tests you should write.

Isolated unit tests

Isolated unit tests examine an instance of a class all by itself without any dependence on Angular or any injected values. The tester creates a test instance of the class with new, supplying test doubles for the constructor parameters as needed, and then probes the test instance API surface.

You can and should write isolated unit tests for pipes and services.

Components can be tested in isolation as well. However, isolated unit tests don't reveal how these classes interact with Angular. In particular, they can't reveal how a component class interacts with its own template or with other components. Such tests require the Angular testing utilities.

Testing with the Angular Testing Utilities

The Angular testing utilities include the TestBed class and several helper functions from @angular/core/testing.

The TestBed creates an Angular testing module — an @NgModule class — that you configure to produce the module environment for the class you want to test. You tell the TestBed to create an instance of the component-under-test and probe that instance with tests.

Before each spec, the TestBed resets itself to a base state. The base state includes a default testing module configuration consisting of the declarables (components, directives, and pipes) and providers (some of them mocked) that almost everyone needs.

This default configuration is merely a foundation for testing an app. You call TestBed.configureTestingModule with an object that defines additional imports, declarations, providers and schemas to fit your application tests. Optional override... methods can fine-tune aspects of the configuration.

After configuring the TestBed, tell it to create an instance of the component-under-test and the test fixture that you'll need to inspect and control the component's immediate environment.

Angular tests can interact with the HTML in the test DOM, simulate user activity, tell Angular to perform specific task (such as change detection), and see the effects of these actions both in the component-under-test and in the test DOM.

A comprehensive review of the Angular testing utilities appears later in the chapter. Let's dive right into Angular testing, starting with the components of a sample application.

The sample application and its tests

This chapter tests a cut-down version of the Tour of Heroes tutorial app.

The following live example shows how it works and provides the complete source code.

The following live example runs all the tests of this application inside the browser, using the Jasmine Test Runner instead of karma.

It includes the tests discussed in this chapter and additional tests for you to explore. This live example contains both application and test code. Give it some time to load and warm up.

Test a component

The top of the screen displays application title, presented by the BannerComponent in app/banner.component.ts.

BannerComponent has an inline template and an interpolation binding. The component is probably too simple to be worth testing in real life but it's perfect for a first encounter with the TestBed.

The corresponding app/banner-component.spec.ts sits in the same folder as the component, for reasons explained here;

Start with ES6 import statements to get access to symbols referenced in the spec.

Here's the setup for the tests followed by observations about the beforeEach:

TestBed.configureTestingModule takes an @NgModule-like metadata object. This one simply declares the component to test, BannerComponent.

It lacks imports because (a) it extends the default testing module configuration which already has what BannerComponent needs and (b) BannerComponent doesn't interact with any other components.

createComponent

TestBed.createComponent creates an instance of BannerComponent to test and returns a fixture.

TestBed.createComponent closes the current TestBed instance to further configuration. You cannot call any more TestBed configuration methods, not configureTestModule nor any of the override... methods. The TestBed throws an error if you try.

ComponentFixture, DebugElement, and query(By.css)

The createComponent method returns a ComponentFixture, a handle on the test environment surrounding the created component. The fixture provides access to the component instance itself and to the DebugElement which is a handle on the component's DOM element.

The title property value was interpolated into the DOM within <h1> tags. Use the fixture's DebugElement to query for the <h1> element by CSS selector.

The query method takes a predicate function and searches the fixture's entire DOM tree for the first element that satisfies the predicate. The result is a different DebugElement, one associated with the matching DOM element.

The By class is an Angular testing utility that produces useful predicates. Its By.css static method produces a standard CSS selector predicate that filters the same way as a jQuery selector.

Finally, the setup assigns the DOM element from the DebugElement nativeElement property to el. The tests will assert that el contains the expected title text.

The tests

Jasmine runs the beforeEach function before each of these tests

These tests ask the DebugElement for the native HTML element to satisfy their expectations.

detectChanges: Angular change detection within a test

Each test tells Angular when to perform change detection by calling fixture.detectChanges(). The first test does so immediately, triggering data binding and propagation of the title property to the DOM element.

The second test changes the component's title property and only then calls fixture.detectChanges(); the new value appears in the DOM element.

In production, change detection kicks in automatically when Angular creates a component or the user enters a keystroke or an asynchronous activity (e.g., AJAX) completes.

The TestBed.createComponent does not trigger change detection. The fixture does not automatically push the component's title property value into the data bound element, a fact demonstrated in the following test:

This behavior (or lack of it) is intentional. It gives the tester an opportunity to inspect or change the state of the component before Angular initiates data binding or calls lifecycle hooks.

Automatic change detection

Some testers prefer that the Angular test environment run change detection automatically. That's possible by configuring the TestBed with the AutoDetect provider:

Here are three tests that illustrate how AutoDetect works.

The first test shows the benefit of automatic change detection.

The second and third test reveal an important limitation. The Angular testing environment does not know that the test changed the component's title. AutoDetect responds to asynchronous activities such as promise resolution, timers, and DOM events. But a direct, synchronous update of the component property is invisible to AutoDetect. The test must call fixture.detectChanges() manually to trigger another cycle of change detection.

Test a component with a dependency

Components often have service dependencies. The WelcomeComponent displays a welcome message to the logged in user. It knows who the user is based on a property of the injected UserService:

The WelcomeComponent has decision logic that interacts with the service, logic that makes this component worth testing. Here's the testing module configuration for the spec file, app/welcome.component.spec.ts:

This time, in addition to declaring the component-under-test, the configuration adds a UserService provider to the providers list. But not the real UserService.

Provide service test doubles

A component-under-test doesn't have to be injected with real services. In fact, it is usually better if they are test doubles (stubs, fakes, spies, or mocks). The purpose of the spec is to test the component, not the service, and real services can be trouble.

Injecting the real UserService could be a nightmare. The real service might try to ask the user for login credentials and try to reach an authentication server. These behaviors could be hard to intercept. It is far easier and safer to create and register a test double in place of the real UserService.

This particular test suite supplies a minimal UserService stub that satisfies the needs of the WelcomeComponent and its tests:

Get injected services

The tests need access to the (stub) UserService injected into the WelcomeComponent.

Angular has a hierarchical injection system. There can be injectors at multiple levels, from the root injector created by the TestBed down through the component tree.

The safest way to get the injected service, the way that always works, is to get it from the injector of the component-under-test. The component injector is a property of the fixture's DebugElement.

TestBed.get

You may also be able to get the service from the root injector via TestBed.get. This is easier to remember and less verbose. But it only works when Angular injects the component with the service instance in the test's root injector. Fortunately, in this test suite, the only provider of UserService is the root testing module, so it is safe to call TestBed.get as follows:

Always get the service from an injector

Surprisingly, you dare not reference the userServiceStub object that was provided to the testing module in the body of your test. It does not work! The userService instance injected into the component is a completely different object, a clone of the provided userServiceStub.

Final setup and tests

Here's the complete beforeEach using TestBed.get:

And here are some tests:

The first is a sanity test; it confirms that the stubbed UserService is called and working.

The remaining tests confirm the logic of the component when the service returns different values. The second test validates the effect of changing the user name. The third test checks that the component displays the proper message when there is no logged-in user.

Test a component with an async service

Many services return values asynchronously. Most data services make an HTTP request to a remote server and the response is necessarily asynchronous.

The "About" view in this sample displays Mark Twain quotes. The TwainComponent handles the display, delegating the server request to the TwainService. Both are in the app/shared folder because the author intends to display Twain quotes on other pages someday. Here is the TwainComponent.

The TwainService implementation is irrelevant at this point. It is sufficient to see within ngOnInit that twainService.getQuote returns a promise which means it is asynchronous.

In general, tests should not make calls to remote servers. They should emulate such calls. The setup in this app/shared/twain.component.spec.ts shows one way to do that:

Spying on the real service

This setup is similar to the welcome.component.spec setup. But instead of creating a stubbed service object, it injects the real service (see the testing module providers) and replaces the critical getQuote method with a Jasmine spy.

The spy is designed such that any call to getQuote receives an immediately resolved promise with a test quote. The spy bypasses the actual getQuote method and therefore will not contact the server.

Here are the tests with commentary to follow:

Synchronous tests

The first two tests are synchronous. Thanks to the spy, they verify that getQuote is called after the first change detection cycle during which Angular calls ngOnInit.

Neither test can prove that a value from the service is be displayed. The quote itself has not arrived, despite the fact that the spy returns a resolved promise.

This test must wait at least one full turn of the JavaScript engine before the value becomes available. The test must become asynchronous.

The async function in it

Notice the async in the third test.

The async function is one of the Angular testing utilities. It simplifies coding of asynchronous tests by arranging for the tester's code to run in a special async test zone.

The async function takes a parameterless function and returns a function which becomes the argument to the Jasmine it call.

The body of the async argument looks much like the body of a normal it argument. There is nothing obviously asynchronous about it. For example, it doesn't return a promise and there is no done function to call as there is in standard Jasmine asynchronous tests.

Some functions called within a test (such as fixture.whenStable) continue to reveal their asynchronous behavior.

whenStable

The test must wait for the getQuote promise to resolve in the next turn of the JavaScript engine.

This test has no direct access to the promise returned by the call to testService.getQuote which is private and inaccessible inside TwainComponent.

Fortunately, the getQuote promise is accessible to the async test zone which intercepts all promises issued within the async method call.

The ComponentFixture.whenStable method returns its own promise which resolves when the getQuote promise completes. In fact, the whenStable promise resolves when all pending asynchronous activities within this test complete ... the definition of "stable".

Then the test resumes and kicks off another round of change detection (fixture.detectChanges) which tells Angular to update the DOM with the quote. The getQuote helper method extracts the display element text and the expectation confirms that the text matches the test quote.

The fakeAsync function

The fourth test verifies the same component behavior in a different way.

Notice that fakeAsync replaces async as the it argument. The fakeAsync function is another of the Angular testing utilities.

Like async, it takes a parameterless function and returns a function that becomes the argument to the Jasmine it call.

The fakeAsync function enables a linear coding style by running the test body in a special fakeAsync test zone.

The principle advantage of fakeAsync over async is that the test appears to be synchronous. There is no then(...) to disrupt the visible flow of control. The promise-returning fixture.whenStable is gone, replaced by tick().

The tick function

The tick function is one of the Angular testing utilities and a companion to fakeAsync. It can only be called within a fakeAsync body.

Calling tick() simulates the passage of time until all pending asynchronous activities complete, including the resolution of the getQuote promise in this test case.

It returns nothing. There is no promise to wait for. Proceed with the same test code as formerly appeared within the whenStable.then() callback.

Even this simple example is easier to read than the third test. To more fully appreciate the improvement, imagine a succession of asynchronous operations, chained in a long sequence of promise callbacks.

jasmine.done

While fakeAsync and even async function greatly simplify Angular asynchronous testing, you can still fallback to the traditional Jasmine asynchronous testing technique.

You can still pass it a function that takes a done callback. Now you are responsible for chaining promises, handling errors, and calling done at the appropriate moment.

Here is a done version of the previous two tests:

Although we have no direct access to the getQuote promise inside TwainComponent, the spy does and that makes it possible to wait for getQuote to finish.

The jasmine.done technique, while discouraged, may become necessary when neither async nor fakeAsync can tolerate a particular asynchronous activity. That's rare but it happens.

Test a component with an external template

The TestBed.createComponent is a synchronous method. It assumes that everything it could need is already in memory.

That has been true so far. Each tested component's @Component metadata has a template property specifying an inline templates. Neither component had a styleUrls property. Everything necessary to compile them was in memory at test runtime.

The DashboardHeroComponent is different. It has an external template and external css file, specified in templateUrl and styleUrls properties.

The compiler must read these files from a file system before it can create a component instance.

The TestBed.compileComponents method asynchronously compiles all the components configured in its current testing module. After it completes, external templates and css files, have been "inlined" and TestBed.createComponent can do its job synchronously.

The app/dashboard/dashboard-hero.component.spec.ts demonstrates the pre-compilation process:

The async function in beforeEach

Notice the async call in the beforeEach, made necessary by the asynchronous TestBed.compileComponents method. The async function arranges for the tester's code to run in a special async test zone that hides the mechanics of asynchronous execution, just as it does when passed to an it test.

compileComponents

In this example, TestBed.compileComponents compiles one component, the DashboardComponent. It's the only declared component in this testing module.

Tests later in this chapter have more declared components and some of them import application modules that declare yet more components. Some or all of these components could have external templates and css files. TestBed.compileComponents compiles them all asynchronously at one time.

The compileComponents method returns a promise so you can perform additional tasks after it finishes. The promise isn't needed here.

compileComponents closes configuration

Calling compileComponents closes the current TestBed instance is further configuration. You cannot call any more TestBed configuration methods, not configureTestModule nor any of the override... methods. The TestBed throws an error if you try.

The DashboardHeroComponent spec follows the asynchonous beforeEach with a synchronous beforeEach that completes the setup steps and runs tests ... as described in the next section.

Test a component with inputs and outputs

A component with inputs and outputs typically appears inside the view template of a host component. The host uses a property binding to set the input property and uses an event binding to listen to events raised by the output property.

The testing goal is to verify that such bindings work as expected. The tests should set input values and listen for output events.

The DashboardHeroComponent is a tiny example of a component in this role. It displays an individual hero provided by the DashboardComponent. Clicking that hero tells the DashboardComponent that the user has selected the hero.

The DashboardHeroComponent is embedded in the DashboardComponent template like this:

The DashboardHeroComponent appears in an *ngFor repeater which sets each component's hero input property to the iteration value and listens for the components selected event.

Here's the component's definition again:

While testing a component this simple has little intrinsic value, it's worth knowing how. Three approaches come to mind:

1. Test it as used by DashboardComponent
2. Test it as a stand-alone component
3. Test it as used by a substitute for DashboardComponent

A quick look at the DashboardComponent constructor discourages the first approach:

The DashboardComponent depends upon the Angular router and the HeroService. You'd probably have to replace them both with test doubles and that looks like a lot of work. The router seems particularly challenging.

The immediate goal is to test the DashboardHeroComponent, not the DashboardComponent, and there's no need to work hard unnecessarily. Let's try the second and third options.

Test DashboardHeroComponent stand-alone

Here's the spec file setup.

The async beforeEach was discussed above. Having compiled the components asynchronously with compileComponents, the rest of the setup proceeds synchronously in a second beforeEach, using the basic techniques described earlier.

Note how the setup code assigns a test hero (expectedHero) to the component's hero property, emulating the way the DashboardComponent would set it via the property binding in its repeater.

The first test follows:

It verifies that the hero name is propagated through to template with a binding. There's a twist. The template passes the hero name through the Angular UpperCasePipe so the test must match the element value with the uppercased name:

The second test verifies click behavior. Clicking the hero should raise a selected event that the host component (DashboardComponent presumably) can hear:

The component exposes an EventEmitter property. The test subscribes to it just as the host component would do.

The heroEl is a DebugElement that represents the hero <div>. The test calls triggerEventHandler with the "click" event name. The "click" event binding responds by calling DashboardHeroComponent.click().

If the component behaves as expected, click() tells the component's selected property to emit the hero object, the test detects that value through its subscription to selected, and the test should pass.

triggerEventHandler

The Angular DebugElement.triggerEventHandler can raise any data-bound event by its event name. The second parameter is the event object passed to the handler.

In this example, the test triggers a "click" event with a null event object.

The test assumes (correctly in this case) that the runtime event handler — the component's click() method — doesn't care about the event object.

Other handlers will be less forgiving. For example, the RouterLink directive expects an object with a button property indicating the mouse button that was pressed. The directive throws an error if the event object doesn't do this correctly.

Clicking a button, an anchor, or an arbitrary HTML element is a common test task. Make that easy by encapsulating the click-triggering process in a helper such as the click function below:

The first parameter is the element-to-click. You can pass a custom event object as the second parameter if you wish. The default is a (partial) left-button mouse event object accepted by many handlers including the RouterLink directive.

Here's the previous test, rewritten using this click helper.

Test a component inside a test host component

In the previous approach the tests themselves played the role of the host DashboardComponent. A nagging suspicion remains. Will the DashboardHeroComponent work properly when properly data-bound to a host component?

Testing with the actual DashboardComponent host is doable but seems more trouble than its worth. It's easier to emulate the DashboardComponent host with a test host like this one:

The test host binds to DashboardHeroComponent as the DashboardComponent would but without the distraction of the Router, the HeroService or even the *ngFor repeater.

The test host sets the component's hero input property with its test hero. It binds the component's selected event with its onSelected handler that records the emitted hero in its selectedHero property. Later the tests check that property to verify that the DashboardHeroComponent.selected event really did emit the right hero.

The setup for the test-host tests is similar to the setup for the stand-alone tests:

This testing module configuration shows two important differences:

1. It declares both the DashboardHeroComponent and the TestHostComponent.
2. It creates the TestHostComponent instead of the DashboardHeroComponent.

The fixture returned by createComponent holds an instance of TestHostComponent instead of an instance of DashboardHeroComponent.

Of course creating the TestHostComponent has the side-effect of creating a DashboardHeroComponent because the latter appears within the template of the former. The query for the hero element (heroEl) still finds it in the test DOM albeit at greater depth in the element tree than before.

The tests themselves are almost identical to the stand-alone version

Only the selected event test differs. It confirms that the selected DashboardHeroComponent hero really does find its way up through the event binding to the host component.

Test a routed component

Testing the actual DashboardComponent seemed daunting because it injects the Router.

It also injects the HeroService but faking that is a familiar story. The Router has a complicated API and is entwined with other services and application pre-conditions.

Fortunately, the DashboardComponent isn't doing much with the Router

This is often the case. As a rule you test the component, not the router, and care only if the component navigates with the right address under the given conditions. Stubbing the router with a test implementation is an easy option. This should do the trick:

Now we setup the testing module with the test stubs for the Router and HeroService and create a test instance of the DashboardComponent for subsequent testing.

The following test clicks the displayed hero and confirms (with the help of a spy) that Router.navigateByUrl is called with the expected url.

The inject function

Notice the inject function in the second it argument.

The inject function is one of the Angular testing utilities. It injects services into the test function where you can alter, spy on, and manipulate them.

The inject function has two parameters

1. an array of Angular dependency injection tokens
2. a test function whose parameters correspond exactly to each item in the injection token array

This example injects the Router from the current TestBed injector. That's fine for this test because the Router is (and must be) provided by the application root injector.

If you need a service provided by the component's own injector, call fixture.debugElement.injector.get instead:

The inject function closes the current TestBed instance to further configuration. You cannot call any more TestBed configuration methods, not configureTestModule nor any of the override... methods. The TestBed throws an error if you try.

Test a routed component with parameters

Clicking a Dashboard hero triggers navigation to heroes/:id where :id is a route parameter whose value is the id of the hero to edit. That URL matches a route to the HeroDetailComponent.

The router pushes the :id token value into the ActivatedRoute.params Observable property, Angular injects the ActivatedRoute into the HeroDetailComponent, and the component extracts the id so it can fetch the corresponding hero via the HeroDetailService. Here's the HeroDetailComponent constructor:

HeroDetailComponent listens for changes to the ActivatedRoute.params in its ngOnInit method.

A test can explore how the HeroDetailComponent responds to different id parameter values by manipulating the ActivatedRoute injected into the component's constructor.

By now you know how to stub the Router and a data service. Stubbing the ActivatedRoute would follow the same pattern except for a complication: the ActivatedRoute.params is an Observable.

Observable test double

The hero-detail.component.spec.ts relies on an ActivatedRouteStub to set ActivatedRoute.params values for each test. This is a cross-application, re-usable test helper class. We recommend locating such helpers in a testing folder sibling to the app folder. This sample keeps ActivatedRouteStub in testing/router-stubs.ts:

Notable features of this stub:

• The stub implements only two of the ActivatedRoute capabilities: params and snapshot.params.

• BehaviorSubject drives the stub's params Observable and returns the same value to every params subscriber until it's given a new value.

• The HeroDetailComponent chain its expressions to this stub params Observable which is now under the tester's control.

• Setting the testParams property causes the subject to push the assigned value into params. That triggers the HeroDetailComponent params subscription, described above, in the same way that navigation does.

• Setting the testParams property also updates the stub's internal value for the snapshot property to return.

Observable tests

Here's a test demonstrating the component's behavior when the observed id refers to an existing hero:

When the id cannot be found, the component should re-route to the HeroListComponent. The test suite setup provided the same RouterStub described above which spies on the router without actually navigating. This test supplies a "bad" id and expects the component to try to navigate.

While this app doesn't have a route to the HeroDetailComponent that omits the id parameter, it might add such a route someday. The component should do something reasonable when there is no id.

In this implementation, the component should create and display a new hero. New heroes have id=0 and a blank name. This test confirms that the component behaves as expected:

Use a page object to simplify setup

The HeroDetailComponent is a simple view with a title, two hero fields, and two buttons.

But there's already plenty of template complexity.

To fully exercise the component, the test needs ...

• to wait until a hero arrives before *ngIf allows any element in DOM
• element references for the title name span and name input-box to inspect their values
• two button references to click
• spies on services and component methods

Even a small form such as this one can produce a mess of tortured conditional setup and CSS element selection.

Tame the madness with a Page class that simplifies access to component properties and encapsulates the logic that sets them. Here's the Page class for the hero-detail.component.spec.ts

Now the important hooks for component manipulation and inspection are neatly organized and accessible from an instance of Page.

A createComponent method creates a page and fills in the blanks once the hero arrives.

The observable tests in the previous section demonstrate how createComponent and page keep the tests short and on message. There are no distractions: no waiting for promises to resolve and no searching the DOM for element values to compare. Here are a few more HeroDetailComponent tests to drive the point home.

Setup with module imports

Earlier component tests configured the testing module with a few declarations like this:

The DashboardComponent is simple. It needs no help. But more complex components often depend on other components, directives, pipes, and providers and these must be added to the testing module too.

Fortunately, the TestBed.configureTestingModule parameter parallels the metadata passed to the @NgModule decorator which means you can also specify providers and imports.

The HeroDetailComponent requires a lot of help despite its small size and simple construction. In addition to the support it receives from the default testing module CommonModule, it needs:

• NgModel and friends in the FormsModule enable two-way data binding
• The TitleCasePipe from the shared folder
• Router services (which these tests are stubbing)
• Hero data access services (also stubbed)

One approach is to configure the testing module from the individual pieces as in this example:

Because many app components need the FormsModule and the TitleCasePipe, the developer created a SharedModule to combine these and other frequently requested parts. The test configuration can use the SharedModule too as seen in this alternative setup:

It's a bit tighter and smaller, with fewer import statements (not shown).

Import the feature module

The HeroDetailComponent is part of the HeroModule Feature Module that aggregates more of the interdependent pieces including the SharedModule. Try a test configuration that imports the HeroModule like this one:

That's really crisp. Only the test doubles in the providers remain. Even the HeroDetailComponent declaration is gone.

Override component providers

The HeroDetailComponent provides its own HeroDetailService.

It's not possible to stub the component's HeroDetailService in the providers of the TestBed.configureTestingModule. Those are providers for the testing module, not the component. They prepare the dependency injector at the fixture level.

Angular creates the component with its own injector which is a child of the fixture injector. It registers the component's providers (the HeroDetailService in this case) with the child injector. A test cannot get to child injector services from the fixture injector. And TestBed.configureTestingModule can't configure them either.

Angular has been creating new instances of the real HeroDetailService all along!

What if you aren't so lucky. What if faking the HeroService is hard? What if HeroDetailService makes its own server requests?

The TestBed.overrideComponent method can replace the component's providers with easy-to-manage test doubles as seen in the following setup variation:

Notice that TestBed.configureTestingModule no longer provides a (fake) HeroService because it's not needed.

The overrideComponent method

Focus on the overrideComponent method.

It takes two arguments: the component type to override (HeroDetailComponent) and an override metadata object. The overide metadata object is a generic defined as follows:

A metadata override object can either add-and-remove elements in metadata properties or completely reset those properties. This example resets the component's providers metadata.

The type parameter, T, is the kind of metadata you'd pass to the @Component decorator:

StubHeroDetailService

This example completely replaces the component's providers with an array containing the StubHeroDetailService. The StubHeroDetailService is dead simple. It doesn't need a HeroService (fake or otherwise).

The override tests

Now the tests can control the component's hero directly by manipulating the stub's testHero.

More overrides

The TestBed.overrideComponent method can be called multiple times for the same or different components. The TestBed offers similar overrideDirective, overrideModule, and overridePipe methods for digging into and replacing parts of these other classes.

Explore the options and combinations on your own.

Test a RouterOutlet component

The AppComponent displays routed components in a <router-outlet>. It also displays a navigation bar with anchors and their RouterLink directives.

The component class does nothing.

Unit tests can confirm that the anchors are wired properly without engaging the router. See why this is worth doing below.

Stubbing unneeded components

The test setup should look familiar

The AppComponent is the declared test subject The setup extends the default testing module with one real component (BannerComponent) and several stubs.

• BannerComponent is simple and harmless to use as is.

• The real WelcomeComponent has an injected service. WelcomeStubComponent is a placeholder with no service to worry about.

• The real RouterOutlet is complex and errors easily. The RouterOutletStubComponent (in testing/router-stubs.ts) is safely inert.

The component stubs are essential. Without them, the Angular compiler doesn't recognize the <app-welcome> and <router-outlet> tags and throws an error.

Stubbing the RouterLink

The RouterLinkStubDirective contributes substantively to the test

The host metadata property wires the click event of the host element (the <a>) to the directive's onClick method. The URL bound to the [routerLink] attribute flows to the directive's linkParams property. Clicking the anchor should trigger the onClick method which sets the telltale navigatedTo property. Tests can inspect that property to confirm the expected click-to-navigation behavior.

By.directive and injected directives

A little more setup triggers the initial data binding and gets references to the navigation links:

Two points of special interest:

1. You can locate elements by directive, using By.directive, not just by css selectors.

2. You can use the component's dependency injector to get an attached directive because Angular always adds attached directives to the component's injector.

Here are some tests that leverage this setup:

What good are these tests?

Stubbed RouterLink tests can confirm that a component with links and an outlet is setup properly, that the component has the links it should have, and that they are all pointing in the expected direction. These tests do not concern whether the app will succeed in navigating to the target component when the user clicks a link.

Stubbing the RouterLink and RouterOutlet is the best option for such limited testing goals. Relying on the real router would make them brittle. They could fail for reasons unrelated to the component. For example, a navigation guard could prevent an unauthorized user from visiting the HeroListComponent. That's not the fault of the AppComponent and no change to that component could cure the failed test.

A different battery of tests can explore whether the application navigates as expected in the presence of conditions that influence guards such as whether the user is authenticated and authorized. A future chapter update will explain how to write such tests with the RouterTestingModule.

"Shallow component tests" with NO_ERRORS_SCHEMA

The previous setup declared the BannerComponent and stubbed two other components for no reason other than to avoid a compiler error.

Without them, the Angular compiler doesn't recognize the <app-banner>, <app-welcome> and <router-outlet> tags in the app.component.html template and throws an error.

Add NO_ERRORS_SCHEMA to the testing module's schemas metadata to tell the compiler to ignore unrecognized elements and attributes. You no longer have to declare irrelevant components and directives.

These tests are shallow because they only "go deep" into the components you want to test. Here is a setup (with import statements) that demonstrates the improved simplicity of shallow tests, relative to the stubbing setup.

The only declarations are the component-under-test (AppComponent) and the RouterLinkStubDirective that contributes actively to the tests. The tests in this example are unchanged.

Test an attribute directive

An attribute directive modifies the behavior of an element, component or another directive. Its name reflects the way the directive is applied: as an attribute on a host element.

The sample application's HighlightDirective sets the background color of an element based on either a data bound color or a default color (lightgray). It also sets a custom property of the element (customProperty) to true for no reason other than to show that it can.

It's used throughout the application, perhaps most simply in the AboutComponent:

Testing the specific use of the HighlightDirective within the AboutComponent requires only the techniques explored above (in particular the "Shallow test" approach).

However, testing a single use case is unlikely to explore the full range of a directive's capabilities. Finding and testing all components that use the directive is tedious, brittle, and almost as unlikely to afford full coverage.

Isolated unit tests might be helpful. But attribute directives like this one tend to manipulate the DOM. Isolated unit tests don't and therefore don't inspire confidence in the directive's efficacy.

A better solution is to create an artificial test component that demonstrates all ways to apply the directive.

Here are some tests of this component:

A few techniques are noteworthy:

• The By.directive predicate is a great way to get the elements that have this directive when their element types are unknown.

• The :not pseudo-class in By.css('h2:not([highlight])') helps find <h2> elements that do not have the directive. By.css('*:not([highlight])') finds any element that does not have the directive.

• DebugElement.styles affords access to element styles even in the absence of a real browser, thanks to the DebugElement abstraction. But feel free to exploit the nativeElement when that seems easier or more clear than the abstraction.

• Angular adds a directive to the injector of the element to which it is applied. The test for the default color uses the injector of the 2nd <h2> to get its HighlightDirective instance and its defaultColor.

• DebugElement.properties affords access to the artificial custom property that is set by the directive.

Isolated Unit Tests

Testing applications with the help of the Angular testing utilities is the main focus of this chapter.

However, it's often more productive to explore the inner logic of application classes with isolated unit tests that don't depend upon Angular. Such tests are often smaller and easier to read, write and maintain.

They don't

• import from the Angular test libraries
• configure a module
• prepare dependency injection providers
• call inject or async or fakeAsync

They do

• exhibit standard, Angular-agnostic testing techniques
• create instances directly with new
• substitute test doubles (stubs, spys, and mocks) for the real dependencies.

Services

Services are good candidates for isolated unit testing. Here are some synchronous and asynchronous unit tests of the FancyService written without assistance from Angular testing utilities.

A rough line count suggests that these isolated unit tests are about 25% smaller than equivalent Angular tests. That's telling but not decisive. The benefit comes from reduced setup and code complexity.

Compare these equivalent tests of FancyService.getTimeoutValue.

They have about the same line-count. But the Angular-dependent version has more moving parts, including a couple of utility functions (async and inject). Both approaches work and it's not much of an issue if you're using the Angular testing utilities nearby for other reasons. On the other hand, why burden simple service tests with added complexity?

Pick the approach that suits you.

Services with dependencies

Services often depend on other services that Angular injects into the constructor. You can test these services without the testbed. In many cases, it's easier to create and inject dependencies by hand.

The DependentService is a simple example

It delegates it's only method, getValue, to the injected FancyService.

Here are several ways to test it.

The first test creates a FancyService with new and passes it to the DependentService constructor.

It's rarely that simple. The injected service can be difficult to create or control. You can mock the dependency, or use a dummy value, or stub the pertinent service method with a substitute method that is easy to control.

These isolated unit testing techniques are great for exploring the inner logic of a service or its simple integration with a component class. Use the Angular testing utilities when writing tests that validate how a service interacts with components within the Angular runtime environment.

Pipes

Pipes are easy to test without the Angular testing utilities.

A pipe class has one method, transform, that turns an input to an output. The transform implementation rarely interacts with the DOM. Most pipes have no dependence on Angular other than the @Pipe metadata and an interface.

Consider a TitleCasePipe that capitalizes the first letter of each word. Here's a naive implementation implemented with a regular expression.

Anything that uses a regular expression is worth testing thoroughly. Use simple Jasmine to explore the expected cases and the edge cases.

Write Angular tests too

These are tests of the pipe in isolation. They can't tell if the TitleCasePipe is working properly as applied in the application components.

Consider adding component tests such as this one:

Components

Component tests typically examine how a component class interacts with its own template or with collaborating components. The Angular testing utilities are specifically designed to facilitate such tests.

Consider this ButtonComp component.

The following Angular test demonstrates that clicking a button in the template leads to an update of the on-screen message.

The assertions verify the data binding flow from one HTML control (the <button>) to the component and from the component back to a different HTML control (the <span>). A passing test means the component and its template are wired up correctly.

Isolated unit tests can more rapidly probe a component at its API boundary, exploring many more conditions with less effort.

Here are a set of unit tests that verify the component's outputs in the face of a variety of component inputs.

Isolated component tests offer a lot of test coverage with less code and almost no setup. This advantage is even more pronounced with complex components that may require meticulous preparation with the Angular testing utilities.

On the other hand, isolated unit tests can't confirm that the ButtonComp is properly bound to its template or even data bound at all. Use Angular tests for that.

Angular Testing Utility APIs

This section takes inventory of the most useful Angular testing features and summarizes what they do.

The Angular testing utilities include the TestBed, the ComponentFixture, and a handful of functions that control the test environment. The TestBed and ComponentFixture classes are covered separately.

Here's a summary of the stand-alone functions, in order of likely utility:

TestBed Class Summary

The TestBed class is one of the principal Angular testing utilities. Its API is quite large and can be overwhelming until you've explored it first a little at a time. Read the early part of this chapter first to get the basics before trying to absorb the full API.

The module definition passed to configureTestingModule, is a subset of the @NgModule metadata properties.

Each overide method takes a MetadataOverride<T> where T is the kind of metadata appropriate to the method, the parameter of an @NgModule, @Component, @Directive, or @Pipe.

The TestBed API consists of static class methods that either update or reference a global instance of theTestBed.

Internally, all static methods cover methods of the current runtime TestBed instance that is also returned by the getTestBed() function.

Call TestBed methods within a BeforeEach() to ensure a fresh start before each individual test.

Here are the most important static methods, in order of likely utility.

A few of the TestBed instance methods are not covered by static TestBed class methods. These are rarely needed.

The ComponentFixture

The TestBed.createComponent<T> creates an instance of the component T and returns a strongly typed ComponentFixture for that component.

The ComponentFixture properties and methods provide access to the component, its DOM representation, and aspects of its Angular environment.

ComponentFixture properties

Here are the most important properties for testers, in order of likely utility.

ComponentFixture methods

The fixture methods cause Angular to perform certain tasks to the component tree. Call these method to trigger Angular behavior in response to simulated user action.

Here are the most useful methods for testers.

DebugElement

The DebugElement provides crucial insights into the component's DOM representation.

From the test root component's DebugElement, returned by fixture.debugElement, you can walk (and query) the fixture's entire element and component sub-trees.

Here are the most useful DebugElement members for testers in approximate order of utility.

The DebugElement.query(predicate) and DebugElement.queryAll(predicate) methods take a predicate that filters the source element's subtree for matching DebugElement.

The predicate is any method that takes a DebugElement and returns a truthy value. The following example finds all DebugElements with a reference to a template local variable named "content":

The Angular By class has three static methods for common predicates:

• By.all - return all elements
• By.css(selector) - return elements with matching CSS selectors.
• By.directive(directive) - return elements that Angular matched to an instance of the directive class.

Many custom application directives inject the Renderer and call one of its set... methods.

The test environment substitutes the DebugDomRender for the runtime Renderer. The DebugDomRender updates additional dictionary properties of the DebugElement when something calls a set... method.

These dictionary properties are primarily of interest to authors of Angular DOM inspection tools but they may provide useful insights to testers as well.

Here's an example of Renderer tests from the live "Specs Bag" sample.

Why put specs next to the things they test?

We recommend putting unit test spec files in the same folder as the application source code files that they test because

• Such tests are easy to find
• You see at a glance if a part of our application lacks tests.
• Nearby tests can reveal how a part works in context.
• When you move the source (inevitable), you remember to move the test.
• When you rename the source file (inevitable), you remember to rename the test file.

When would I put specs in a test folder?

Application integration specs can test the interactions of multiple parts spread across folders and modules. They don't really belong to part in particular so they don't have a natural home next to any one file.

It's often better to create an appropriate folder for them in the tests directory.

Of course specs that test the test helpers belong in the test folder, next to their corresponding helper files.