Kent C. Dodds
Professional Trainer
JavaScript Testing Practices and Principles
3 hours, 39 minutes CC
Course Description
Learn the principles and best practices for writing maintainable test applications to catch errors before your product reaches the end user! Follow along with Kent C. Dodds and learn the fundamentals behind tests and testing frameworks, the distinctions of different forms of testing and when to use them appropriately to ensure your tests give you the confidence you need. You will also learn to write unit and integration tests with the popular Jest testing framework, mock dependencies, and use test-driven development to write new features and help find bugs!
This course and others like it are available as part of our Frontend Masters video subscription.
Preview
CloseCourse Details
Published: August 23, 2018
Learning Paths
Topics
Learn Straight from the Experts Who Shape the Modern Web
Your Path to Senior Developer and Beyond
- 200+ In-depth courses
- 18 Learning Paths
- Industry Leading Experts
- Live Interactive Workshops
Table of Contents
Intro to Testing
Section Duration: 31 minutes
Kent C. Dodds introduces the course as a primer for testing and testing frameworks so that students gain confidence in testing, and the ability to write tests that are maintainable. Ken also covers cloning the git repository and sets the routine for the course. Note: The repository has moved. The correct location is below.
Kent introduces some common bugs, what is generally done about these bugs, and gives an introduction to tests, with examples on what static, unit, integration, and a look of E2E tests.
Kent reviews the first exercise where the audience is instructed to access the GitHub repository that was previously cloned and to write a simple test in pure JavaScript that reveals the bug and throws an error.
After walking through the solution to the Your First Test Exercise, Kent provides instructions for the next exercise, which is about writing a simple assertion library.
Kent writes the solution to the assertion library exercise in pure JavaScript and goes over critical issues revealed in the exercises and instructs the audience to continue to the next exercise.
After coding a simple testing framework from scratch in pure JavaScript, Kent introduces Jest as an example of how a testing framework can increase the productivity of the user.
Unit Tests
Section Duration: 59 minutes
Kent provides an overview of Jest's assertion methods.
Kent reviews Jest and demonstrates watch mode on files in the repository.
Kent demonstrates how to write a pure function with Jest and introduces test-driven development.
Kent introduces the userToJson exercise, which is a practical look at testing a JavaScript utility function.
Kent walks through the userToJson exercise in multiple ways and teaches how to use your test code to communicate intent.
Kent fields a question that segues into test factories, describe blocks, colocating tests, Jest globals, other tools to use in addition to Jest, and other topics.
After introducing code coverage reports, which are a way to see what code is covered by your tests, Kent reviews its benefits as well as addressing the pitfalls of misinterpreting the data or misusing the feature.
Mocks
Section Duration: 48 minutes
After explaining mocking, Kent introduces the exercise where the goal is to create a mock for a dependency in a test. The simplest form of mocking a function in a module is by using monkey patching to swap the actual implementation with a fake implementation.
Kent codes the solution to the previous exercise by monkey patching a fake implementation of the getWinner function so that a more specific assertion can be made.
In this exercise, students are to gain more confidence out of a mock by asserting that it is being called in the way that is expected.
After coding the solution for the mock function to keep track of how it is called and to add an assertion for it, Kent introduces the next exercise with the goal of implementing jest.spyOn.
Kent codes the solution to Jest spyOn, which allows the user to keep track of when existing functions are called and mock their implementations.
Kent codes the solution using jest.mock, which allows the user to mock an entire module to avoid monkey patching module exports. Then Kent demonstrates another exercise that allows the user to apply the mock in almost all of the tests, rather than having it isolated.
While answering a student question about the appropriateness to mock an API when the actual API is still in development, Kent is lead to the topic of discussing whether to use dependency injection or mocking.
Kent walks through a test from scratch that tests the user's module. Then Kent shows the importance of being explicit in tests and discusses edge cases for this implementation.
Kent reviews an example of how to construct a test that ensures the users being retrieved from a database are what is expected.
Testing Practices
Section Duration: 49 minutes
To test Express middleware that interacts with the database, Kent shows that one can either mock or initialize the database. In this demonstration, Kent initializes the database and asserts that the endpoints are returning the correct items from the database.
Kent live codes the solution to the Unit Tests for Express Middleware exercise, where the test checks that all posts are returning from the database, the specific post is being returned, and updatePost updates the correct post with the given changes.
After demonstrating how object factories are constructed, using a previous example as scaffolding, Kent gives reviews test-cleanup.
Kent begins the section by introducing an exercise with the instructions to implement a delete function using test driven development (TDD). He then goes into further detail by outlining of the process of TDD, and in what use cases that it's a good idea to implement the practice.
The solution to the exercise introduced at the beginning of Test Driven Development is live-coded.
Integration Tests
Section Duration: 21 minutes
Kent codes an integration test for a node server noting differences when testing on the server, such as the need to stop the server after the tests are completed. Then Kent introduces a tool to help write these tests called Axios, a promise based HTTP client.
Wrapping Up
Section Duration: 9 minutes
Kent wraps up the course by reviewing additional learning materials testing, and answers student questions about the page objects pattern and tests as documentation.
Learn Straight from the Experts Who Shape the Modern Web
- In-depth Courses
- Industry Leading Experts
- Learning Paths
- Live Interactive Workshops