Testing with the Angular HttpClient API
Embracing Observables and Immutability FTW
The HttpClientTestingModule
makes it easier to mock requests using the HttpTestingController
service. In this post we’ll learn how to setup our tests and see real examples of how it can be used.
Series
This post is part of the HttpClient API series:
- The new Angular
HttpClient
API - Testing with the Angular
HttpClientTesting
API
Demo
We will create a simple GitHub API service that can get users and make searches. More precisely we will:
- Create the
GithubApiService
and write tests for it. - Consume the service created in our
GithubComponent
to list users and make searches and write tests for it. (this part is not covered in this post)
You can jump straight to the code you want. Check this GitHub repository.
Unit testing services with HttpClient
The service
As mentioned before, our service will allow us to get users and make searches. It'll have two methods getUsers
and search
.
Notice how we throw an error in case the consumer tries to search for a non supported type:
This example should be fun enough for us to write some tests for.
Setup
Now we setup the TestBed
importing the HttpClientTestingModule
and providing the HttpTestingController
. Of course we also provide the service we're testing:
Notice that for convenience we saved the injector and the providers we'll use in our tests in variables. Another option would be to use the inject
function.
We also run HttpTestingController#verify
to make sure that there are no outstanding requests:
Mocking
You can use the HttpTestingController
to mock requests and the flush
method to provide dummy values as responses. As the HTTP request methods return an Observable, we subscribe to it and create our expectations in the callback methods:
Dealing with errors
In this case we're using the error callback of the subscribe
method. We also use the expectNone
matcher to confirm that the request wasn't made:
Testing parameters
In that case we can verify the request.params
to assert if the request was made with the correct parameters. As the HttpParams#set
method is immutable, the result is predictable and the tests easy to write:
Wrapping up
There’s a very simple and common flow for creating the tests:
1- Subscribe to the results of a request
2- Mock the request using expectOne
, expectNone
or match
3- flush
the request passing dummy values (in case of expectNone
this step isn't necessary)
What's next
In the next post we'll cover testing interceptors
. Stay tuned.