Are tests inside one file run in parallel in Jest?

Question

Jest states in docs: "Jest virtualizes JavaScript environments and runs tests in parallel across worker processes."

But what about multiple tests inside one file, do they run in parallel or this statement applies just to the test files? Can I assume that tests in one file run in order of appearance and in serial?

Answer 1

You can safely assume tests inside a single file will run in the order of appearance. You could prove this by putting a console.log in each it block.

It's probably worth mentioning that it's generally bad practice to rely on the order of execution / external state...and you never know, Jest (or the current underlying test runner, Jasmine) may decide to run them in a random order in a newer version.

Answer 2

Jest in 2020

To add a bit more information on this, async tests are run in series inside of a describe() statement. This is useful for IO/Database setup and cleanup functions. Just take a look at the following example:

some.spec.js

describe("my asynchronous tests", () => {
  beforeEach(async () => {
    console.log('> setup test')
    // SOMETHING ASYNCHRONOUS
  });
  afterEach(async () => {
    console.log('< teardown test')
    // SOMETHING ASYNCHRONOUS
  });

  test("test 1", async () => {
    console.log('-- starting test 1');
    // SOMETHING ASYNCHRONOUS
    console.log('-- finished test 1');
  }, 100000);

  test("test 2", async () => {
    console.log('-- starting test 2');
    // SOMETHING ASYNCHRONOUS
    console.log('-- finished test 2');
  }, 100000);
});

Outputs:

> setup test
-- starting test 1
-- finished test 1
< teardown test
> setup test
-- starting test 2
-- finished test 2
< teardown test

Multiple describe() statements will execute in parallel though, even if they're in the same file.

Answer 3

Note, you may get side effects of two tests running in parallel if one of them times out after 5 seconds - jest stops waiting for the timed out test, but it's code continues executing, in parallel with the following test jest picks up.

(pulled out quite an amount of hair before I realised that this was the reason of the side effects that led me here)

Answer 4

You can use test.concurrent('test run concurrently', () => { ... }) if you want to run them in parallel inside one file is too slow. It is a bit buggy and not well documented, but at least there's a way there.

One thing I notice is it does not wait for async stuff in the beforeAll() so you need some of your own trick(like setInterval to wait) to make it work as expected.

Answer 5

To make test files run sequentially use -i or --runInBand flag

jest --runInBand

ref: jest docs

Weirdly enough, running the tests sequentially finishes faster on my M1 Mac!, better test for you use case

Answer 6

Some additional info to @Klesun answer. One can repeat this with following

test('first test', async () => {
    console.error('first test before waitFor');
    try {
        await waitFor(async () => { throw new Error(''); }, { timeout: 6000 });
    } catch (e) { }
    console.error('first test after waitFor');
}, 5000);

test('second test', async () => {
    console.error('second test before timeout');
    await new Promise((r) => setTimeout(r, 6100));
    console.error('second test after timeout');
}, 6200);

Where the output will be:

first test before waitFor
second test before timeout
first test after waitFor
second test after timeout

Removing setTimeout from second test will hide "first test after waitFor" since test for this file will be finished.

Additionally this causes true cause of failure to be somewhat hidden. For example if we remove try ... catch the only thing that will be reported to us will be thrown: "Exceeded timeout of 5000 ms for a test. for test('first test', async () => { and not exact spot (waitFor in this case). This can be a bit cumbersome to track in longer running tests. I would expect that the best path to track where error lies in these cases would be to increase test timeout.