In an earlier post, I went over some of the reasons you might want your E2E tests to run against a stubbed version of any really slow or unpredictable dependencies.
Let’s see how this might look in an Angular context, making use of the framework’s inbuilt dependency injection, and TypeScript.
NB I’m going to use Nrwl Nx to spin up these example bits of code inside a shared ‘workspace’ or ‘monorepo’ (the terminology seems to change).
If you are unfamiliar with Nrwl Nx you should check it out! I’ve used their tooling extensively at work, and after a few hiccups can strongly recommend it. See here for a slightly outdated explanation of why/how I’ve used their stuff in the past.
Basically though, they provide a way of easily building multiple applications/libraries from within one repository, supporting code reuse between applications, with convenience tooling, built on top of the Angular CLI, for handling unit testing, e2e testing, builds etc. as well as a bunch of generators for generating opinionated bits of ‘best practice’ Angular/ngrx code. (And you get all of this for freeeee!)
The method I’m using for stubbing dependencies would be equally applicable to a ‘vanilla’ Angular application however.
Meet the players
1) Our main Angular application. It has a button which when clicked will call our Slow Ass Api’s
getInformation endpoint, and when finished will render the result (of type
2) Our Slow Ass Api. This is a separate TypeScript library that exposes one method,
getInformation, which returns an object of type
SlowInformation. The (not so) clever bit is that this call will simulate unpredictable slowness, by returning the data after a random amount of time from 0ms up to 10000ms.
3) Our E2E tests. I am going to use Cypress for these because I happen to really like it. If you want to use Protractor, this method will still work, you will just have to use the executeScript method to talk to the window object, instead. Also, if you create your application with Nrwl Nx they will set up all of the code scaffolding and configuration for you to support either Protractor or Cypress (you can choose as part of their interactive setup script).
Below are a bunch of links to specific commits. If you want to play along you can clone the project and checkout individual commits to see how the tests behave at various stages of development.
I will pick up from after the initial project skeleton is put together. As I mentioned, this was done using Nrwl Nx’s extensions to the Angular CLI. If you are curious, you can see what these tools do for you in this commit
slow-information-renderer Angular app (commit):
This uses another of the Nx scripts to generate a fully fledged Angular app, I chose to use Jest and Cypress, and so it also sets up an e2e testing project, which can be run with
npm run e2e
slow information renderer component and
slow information service (commit)
These will be responsible for asking the user to click a button, which will ultimately call our service to call the slow ass api.
Again, this makes use of generator commands to create a boilerplate component with best practices.
Generate and write
slow ass api library (commit)
Due to an over eager interactive rebase I have accidentally lumped my changes in with the generator changes.
Basically though, here I create a library for returning strongly typed data of type
SlowInformation after a random delay (I even unit tested it! I got carried away…)
The main file to concentrate on is
Plug the library into our Angular Application, and do some wiring (commit)
After this, our app will render data from the
slow-ass-api after a delay
Add a naive e2e test (commit)
This commit adds a basic e2e test which is, unfortunately, quite flaky. Because of the random delay in the data coming back, the test sometimes passes, but sometimes doesn’t. This can be demonstrated by making the API resolve more quickly (commit)
With this change, our tests behave properly, unfortunately in the real world you can’t just tell a slow api to be quicker. So we will need a different solution.
Make the test work less flakily (commit)
Here, we experiment with making our test wait 10 seconds to make sure all the data is there. This works pretty well!
However, we have made our tests take longer than they need to, and, crucially if the api ever takes longer than 10 seconds to resolve, our test will fail again. Perhaps this isn’t the best solution after all…
Complexify the app (commit)
We receive some requirements from our Product Owner, and it seems that a new feature is required where if an fact is at
holyCrudThatIsInteresting level of interest, we should put a button up allowing the user to request more information about the fact.
We add the feature and look to update our e2e tests.
Now our app logic is more complicated, we need to account for this complexity in our e2e tests.
Test the new complexified app (commit)
We add a new test for the feature, but unfortunately it only works very very rarely, as if the random fact that comes back is not of the right interest level, our button is not shown, and the test fails. Disaster!
We could start to experiment with making our tests clever, and having them check for the interest level of the fact before progressing, but it is easy to see how an approach like that could blow up and become messy very quickly.
stub slow information service (commit)
We generate a new service, that implements the existing
InformationService in the Angular application. Because it is strongly typed, it must follow the same interface, so we can be relatively confident that we shouldn’t be able to make any methods in our stub return nonsensical or invalid data.
This commit is the meaty part of this post. Here we use Angular’s environment files, as well as their dependency injection, to run our e2e tests with the
StubSlowInformationService instead of the
Now our tests run, and they run quickly.
If the slow-ass-api implementation changes, our stub will stop compiling, and we know that we need to update our code. So this approach is relatively safe, assuming that you have a sufficiently well defined contract for how the api should behave (in this case our TypeScript Type definitions).
Even more control (commit)
Going one step further, in this commit, we expose methods on the window object, meaning that we can change the behaviour of our stub at run time, during our e2e tests.
Again, this is relatively safe if steps are taken to make sure the api contract is adhered to in the Angular application (by respecting the Types defined in the
We have managed to write an e2e test which is quite robust, fast and easy to manage.
Due to fact that both our Angular application, and the
slow ass api conform to a common contract about the behaviour of the API, we can be relatively confident that our tests are meaningful, and represent a realistic interaction with our API.
I think this is a pretty neat approach, and it has proved successful for me at work also. I’d be very keen to hear other peoples’ opinions though as e2e testing in general is something that I’ve found to be a seriously grey area in the frontend world.