- Overview
- Transcript
8.6 Unit Testing Pipes
In this lesson you'll see how we can unit test the transform method of a custom pipe that we've created ourselves.
1.Introduction6 lessons, 42:00
1.1Introduction00:48
1.2Get Started With Angular-CLI11:09
1.3Developing With Angular-CLI13:17
1.4TypeScript vs. JavaScript06:54
1.5Angular Modules From the CLI04:31
1.6CLI Options05:21
2.Get Started With Angular7 lessons, 42:38
2.1Bootstrapping the Application04:30
2.2The Application Module04:15
2.3The Application Component08:06
2.4Component Styling03:06
2.5Global Styling05:11
2.6Creating a Component With the CLI09:34
2.7Creating a Service With the CLI07:56
3.Core Concepts7 lessons, 55:20
3.1Component Trees06:20
3.2Dependency Injection06:52
3.3Content Projection05:38
3.4Component and Directive Lifecycle Methods06:31
3.5Component-Only Lifecycle Methods05:28
3.6Decorators07:36
3.7Models16:55
4.Template Deep Dive11 lessons, 1:10:56
4.1Basic Data Binding With Interpolation05:35
4.2Property Bindings07:07
4.3Attribute Bindings03:29
4.4Event Bindings08:16
4.5Class and Style Bindings05:44
4.6The `NgClass` and `NgStyle` Directives05:04
4.7The `*ngIf` Directive04:41
4.8The `*ngFor` Directive09:29
4.9Inputs05:33
4.10Using Pipes in a Template07:31
4.11Using Pipes in a Class08:27
5.Forms10 lessons, 1:45:41
5.1Handling User Input With Template Reference Variables07:06
5.2Template-Driven Forms11:10
5.3Template-Driven Forms: Validation and Submission14:00
5.4Reactive Forms11:26
5.5Using a `FormBuilder`08:01
5.6Reactive Validation With Built-in Validators14:53
5.7Creating Custom Validators for Template-Driven Forms12:18
5.8Creating Custom Validators for Reactive Forms08:26
5.9Observing Form State Changes12:40
5.10Working With the `@HostListener` Decorator05:41
6.Routing9 lessons, 1:15:10
6.1Defining and Configuring Routes07:53
6.2Rendering Components With Router Outlets10:14
6.3Using Router Links for Navigation05:25
6.4Navigating Routes Using the Router06:24
6.5Determining the Active Route Using an Activated Route07:16
6.6Working With Route Parameters10:42
6.7Using Route Guards07:36
6.8Observing Router Events10:55
6.9Adding Child Routes08:45
7.Using the HTTP Client5 lessons, 56:24
7.1Sending an HTTP Request10:52
7.2Handling an HTTP Response11:22
7.3Setting Request Headers12:33
7.4Intercepting Requests09:04
7.5Finishing the Example Application12:33
8.Testing10 lessons, 1:23:27
8.1Service Unit Test Preparation10:45
8.2Unit Testing Services13:24
8.3Component Unit Test Preparation12:35
8.4Unit Testing Components07:27
8.5Unit Testing Component Templates06:58
8.6Unit Testing Pipes04:41
8.7Unit Testing Directives04:56
8.8Unit Testing Validators04:48
8.9Unit Testing Observables11:37
8.10Unit Testing HTTP Interceptors06:16
9.Building for Production1 lesson, 03:40
9.1Building for Production03:40
10.Conclusion1 lesson, 01:32
10.1Conclusion01:32
8.6 Unit Testing Pipes
Hi, folks. In this lesson, we're going to see how we can unit test pipes in Angular. We did create a pipe earlier in the course, which is used to filter out the face cards in the deck when easy mode is enabled. We create the pipe using the CLI, so we already have the spec file ready to go. Let's open it up as well as the actual file being tested, side by side in the editor and like we have done with our other test files. Great, so first of all, let's focus this test. The pipe only has a single dependency, and the default tests should run and pass as it is. So let's just check that's the case. So we can see that one test ran, and that test passed so we don't need to do any special set up in order to get this test file ready for tests. So let's go ahead and update the existing test. So the existing test was creating an instance of the pipe in order to test it. We're gonna want to do that for every single test. So let's a before each that initializes the pipe before each test. So we just new up an instance of the pipe just like as if we were testing a service. So now let's add the test description. What does the pipe actually do? The pipe returns the cards if easy mode is falsey. It doesn't do anything at all. It just returns the cards that were passed to the transform method. So this aspect of the pipe should be quite straightforward to test. We can just pass false to the pipe, and the returned array of cards should still be 52 in length, so we won't need to bring in the deck for this test So we first get the cards array from a fresh instance of the deck. We then pass this array of cards to the transfer method of the pipe setting easy mode, which is the second parameter true false. And we then check the length of the resulting array that gets passed back from the transform method and we specify that it should equal 52. So let's check the output in the browser. And we can see that that test is passing. So now we can test that when we pass true as the second argument, the pipe does filter out the face cards So the text is going to be very similar to before, we've updated the description. We're still going to want the array of cards, so that doesn't need to change. But now, when we use the transform message, we want to pass through as the second argument instead of false. And this time there should only be 36 cards left in the pack once all of the face cards have been taken out. And let's see if this test is passing. And we can see that it is. So that's really all that we need to test for this particular pipe. This particular pipe is very very simple, but pipes are normally much more complex than this, they can be. And in that case, the spec file would be similarly more complex. But for us, that's what we need to do so in this lesson, we saw how we can test a pipe in an Angular application. Pipes are generally one of the easier parts of an application to test, as they're generally quite small and self-contained. So we just need to create an instance of them and invoke the transform method, and check how that behaves. Thanks for watching.