Implement Test Splitting with Jest

Testing large codebases can lead to slow test execution times. Jest provides powerful features to split your tests across multiple worker processes, significantly speeding up your test suite. This challenge will focus on understanding and implementing test splitting in a Jest environment.

Problem Description

You are tasked with configuring and demonstrating test splitting in Jest for a given TypeScript project. The goal is to ensure that your tests run in parallel across multiple processes to reduce overall execution time. You will need to modify Jest's configuration to achieve this and then demonstrate its effect.

What needs to be achieved:

• Configure Jest to utilize test splitting.
• Demonstrate that tests are running in parallel.

Key requirements:

• Use Jest's built-in configuration options for test splitting.
• Provide a simple test suite that can clearly show parallel execution.

Expected behavior: When running the Jest test suite, the output should indicate that multiple worker processes are being used. Tests should complete faster than they would if run serially.

Important edge cases to consider:

• What happens if tests have dependencies that are not compatible with parallel execution? (Though for this challenge, we'll assume independent tests).
• How does the number of workers affect performance?

Examples

Example 1: Basic Setup

Imagine a simple project with two independent test files: math.test.ts and string.test.ts.

math.test.ts:

describe('Math Operations', () => {
  test('should add two numbers', () => {
    expect(2 + 2).toBe(4);
  });
  test('should subtract two numbers', () => {
    expect(5 - 3).toBe(2);
  });
});

string.test.ts:

describe('String Operations', () => {
  test('should concatenate strings', () => {
    expect('hello' + ' ' + 'world').toBe('hello world');
  });
  test('should return string length', () => {
    expect('jest'.length).toBe(4);
  });
});

Input: A Jest configuration file (jest.config.ts) that enables test splitting. Running npm test or yarn test.

Output (Illustrative): The Jest output will show that it's using multiple worker processes. The exact number of workers will depend on your machine's CPU cores and Jest's default settings or your explicit configuration. You might see output like:

Jest has detected the following 15 files with tests:
  * math.test.ts
  * string.test.ts
... (other files)
Test Suites: 2 passed, 2 total
...

Crucially, the total execution time will be noticeably shorter than if tests were run one by one.

Example 2: Demonstrating Parallelism

To further illustrate parallel execution, we can introduce a slight delay in each test.

slow.test.ts:

const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));

describe('Slow Operations', () => {
  test('should perform a slow operation 1', async () => {
    await delay(1000); // 1 second delay
    expect(true).toBe(true);
  });
  test('should perform a slow operation 2', async () => {
    await delay(1000); // 1 second delay
    expect(true).toBe(true);
  });
  test('should perform a slow operation 3', async () => {
    await delay(1000); // 1 second delay
    expect(true).toBe(true);
  });
});

Input: The same Jest configuration from Example 1, but with slow.test.ts added to the project. Running npm test or yarn test.

Output (Illustrative): If Jest runs these tests serially, the total execution time would be approximately 3 seconds (3 tests * 1 second each). However, with test splitting enabled and sufficient worker processes, these tests will run concurrently. If Jest uses 3 worker processes, all three tests in slow.test.ts could potentially start at the same time. The output should reflect that the tests passed, and the total execution time should be closer to 1 second (plus overhead) rather than 3 seconds. The Jest output might show:

Test Suites: 3 passed, 3 total
...
Ran 3 tests in 1.5s (1.0s wall clock time)

(The exact wall clock time will vary.)

Constraints

• The project must be set up to use TypeScript with Jest.
• The solution must use Jest's official configuration options for parallel execution.
• The maxWorkers option in jest.config.ts can be set to a specific number or a string (e.g., '50%' or '2').
• For demonstration purposes, it's acceptable to have tests that are artificially slowed down using setTimeout to observe the benefits of parallelism.

Notes

• Consider how Jest determines the default number of workers. It typically defaults to the number of logical CPU cores on your machine.
• You can explicitly control the number of worker processes using the maxWorkers configuration option in your jest.config.ts.
• The output of Jest often indicates the number of worker processes being used. Look for messages related to "workers" or "processes."
• Ensure your test files are placed in a directory that Jest will discover (e.g., __tests__ or files ending in .test.ts or .spec.ts).
• Think about what happens when maxWorkers is set to 1. This effectively disables parallelism and runs tests serially, which can be useful for debugging.