Setup and Teardown

    If you have some work you need to do repeatedly for many tests, you can use and afterEach hooks.

    For example, let’s say that several tests interact with a database of cities. You have a method initializeCityDatabase() that must be called before each of these tests, and a method clearCityDatabase() that must be called after each of these tests. You can do this with:

    beforeEach and afterEach can handle asynchronous code in the same ways that - they can either take a done parameter or return a promise. For example, if initializeCityDatabase() returned a promise that resolved when the database was initialized, we would want to return that promise:

    1. beforeEach(() => {
    2.   return initializeCityDatabase();
    3. });

    In some cases, you only need to do setup once, at the beginning of a file. This can be especially bothersome when the setup is asynchronous, so you can’t do it inline. Jest provides beforeAll and afterAll hooks to handle this situation.

    1. beforeAll(() => {
    2.   return initializeCityDatabase();
    3. });
    5. afterAll(() => {
    6.   return clearCityDatabase();
    7. });
    9. test('city database has Vienna', () => {
    10.   expect(isCity('Vienna')).toBeTruthy();
    11. });
    13. test('city database has San Juan', () => {
    14.   expect(isCity('San Juan')).toBeTruthy();
    15. });

    The top level before* and after* hooks apply to every test in a file. The hooks declared inside a describe block apply only to the tests within that describe block.

    For example, let’s say we had not just a city database, but also a food database. We could do different setup for different tests:

    Note that the top-level beforeEach is executed before the beforeEach inside the describe block. It may help to illustrate the order of execution of all hooks.

    1. beforeAll(() => console.log('1 - beforeAll'));
    2. afterAll(() => console.log('1 - afterAll'));
    3. beforeEach(() => console.log('1 - beforeEach'));
    4. afterEach(() => console.log('1 - afterEach'));
    8. describe('Scoped / Nested block', () => {
    9.   beforeAll(() => console.log('2 - beforeAll'));
    10.   beforeEach(() => console.log('2 - beforeEach'));
    11.   afterEach(() => console.log('2 - afterEach'));
    13.   test('', () => console.log('2 - test'));
    14. });
    16. // 1 - beforeAll
    17. // 1 - beforeEach
    18. // 1 - test
    19. // 1 - afterEach
    20. // 2 - beforeAll
    21. // 1 - beforeEach
    22. // 2 - beforeEach
    23. // 2 - test
    24. // 2 - afterEach
    25. // 1 - afterEach
    26. // 2 - afterAll
    27. // 1 - afterAll

    Jest executes all describe handlers in a test file before it executes any of the actual tests. This is another reason to do setup and teardown inside before* and after* handlers rather than inside the describe blocks. Once the describe blocks are complete, by default Jest runs all the tests serially in the order they were encountered in the collection phase, waiting for each to finish and be tidied up before moving on.

    1. describe('describe outer', () => {
    2.   console.log('describe outer-a');
    4.   describe('describe inner 1', () => {
    5.     console.log('describe inner 1');
    7.     test('test 1', () => console.log('test 1'));
    8.   });
    10.   console.log('describe outer-b');
    12.   test('test 2', () => console.log('test 2'));
    14.   describe('describe inner 2', () => {
    16.     test('test 3', () => console.log('test 3'));
    17.   });
    19.   console.log('describe outer-c');
    20. });
    22. // describe outer-a
    23. // describe inner 1
    24. // describe outer-b
    25. // describe inner 2
    26. // describe outer-c
    27. // test 1
    28. // test 2
    29. // test 3

    Just like the describe and test blocks Jest calls the before* and after* hooks in the order of declaration. Note that the after* hooks of the enclosing scope are called first. For example, here is how you can set up and tear down resources which depend on each other:

    note

    If you are using jasmine2 test runner, take into account that it calls the after* hooks in the reverse order of declaration. To have identical output, the above example should be altered like this:

    1.   beforeEach(() => console.log('connection setup'));
    2. + afterEach(() => console.log('connection teardown'));
    4.   beforeEach(() => console.log('database setup'));
    5. + afterEach(() => console.log('database teardown'));
    7. - afterEach(() => console.log('database teardown'));
    8. - afterEach(() => console.log('connection teardown'));
    10.   // ...

    If a test is failing, one of the first things to check should be whether the test is failing when it’s the only test that runs. To run only one test with Jest, temporarily change that test command to a test.only:

    1. test.only('this will be the only test that runs', () => {
    2.   expect(true).toBe(false);
    3. });
    5. test('this test will not run', () => {
    6.   expect('A').toBe('A');
    7. });