Parallel Jest Test Execution

Jest is a powerful JavaScript testing framework, and its ability to run tests in parallel significantly speeds up development cycles, especially for larger projects. This challenge focuses on understanding and demonstrating how to leverage Jest's built-in parallel execution capabilities.

Problem Description

Your task is to create a Jest test suite that showcases the benefits and mechanics of parallel test execution in TypeScript. You will need to:

1. Create mock asynchronous functions: Develop a few simple asynchronous functions that simulate operations that take a measurable amount of time (e.g., using setTimeout).
2. Write Jest tests: Write Jest tests for these mock functions.
3. Observe parallel execution: Configure Jest to run tests in parallel and observe the performance difference compared to sequential execution.
4. Demonstrate synchronization (if necessary): If your tests involve shared state or dependencies that require careful handling in a parallel environment, demonstrate how to manage this.

The goal is to create a clear demonstration that highlights how Jest can run tests concurrently, leading to faster test suite execution times, and to understand how to write tests that are safe to run in parallel.

Examples

Example 1: Basic Asynchronous Test

Let's say we have a simple function that simulates an asynchronous operation:

// src/asyncHelper.ts
export const simulateAsyncOperation = (duration: number): Promise<string> => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(`Operation completed after ${duration}ms`);
    }, duration);
  });
};

A basic Jest test for this would be:

// src/asyncHelper.test.ts
import { simulateAsyncOperation } from './asyncHelper';

describe('simulateAsyncOperation', () => {
  it('should resolve with the correct message after a delay', async () => {
    const startTime = Date.now();
    const message = await simulateAsyncOperation(100);
    const endTime = Date.now();

    expect(message).toBe('Operation completed after 100ms');
    expect(endTime - startTime).toBeGreaterThanOrEqual(100);
  });
});

When run with Jest's default parallel execution, multiple tests like this can run concurrently.

Example 2: Multiple Parallel Tests

Consider a scenario with multiple independent asynchronous tests:

// src/multipleAsync.test.ts
import { simulateAsyncOperation } from './asyncHelper';

describe('Parallel async operations', () => {
  it('should run operation 1 concurrently', async () => {
    await simulateAsyncOperation(200);
    expect(true).toBe(true); // Placeholder assertion
  });

  it('should run operation 2 concurrently', async () => {
    await simulateAsyncOperation(250);
    expect(true).toBe(true); // Placeholder assertion
  });

  it('should run operation 3 concurrently', async () => {
    await simulateAsyncOperation(150);
    expect(true).toBe(true); // Placeholder assertion
  });
});

When Jest runs these tests in parallel, the total execution time should be closer to the duration of the longest test (250ms), rather than the sum of all durations (200 + 250 + 150 = 600ms).

Example 3: Potential Issue with Shared State (Illustrative)

Imagine a scenario where tests accidentally share state. This is generally not recommended for parallel tests, but demonstrating it helps understand the risks.

// src/sharedState.test.ts
// NOTE: This is a demonstration of a potential anti-pattern in parallel testing.
let counter = 0;

describe('Shared state - potential race condition', () => {
  beforeEach(() => {
    // This might run in parallel with other tests, leading to issues
    // if not carefully managed. For this example, we'll reset it.
    // In a real scenario, you'd avoid shared mutable state.
    counter = 0;
  });

  it('should increment counter for test 1', async () => {
    await new Promise(resolve => setTimeout(resolve, 50)); // Simulate work
    counter++;
    expect(counter).toBe(1); // This might fail if another test modifies it concurrently
  });

  it('should increment counter for test 2', async () => {
    await new Promise(resolve => setTimeout(resolve, 50)); // Simulate work
    counter++;
    expect(counter).toBe(1); // This might fail if another test modifies it concurrently
  });
});

In a parallel execution, the counter could be incremented by both tests simultaneously, leading to an unpredictable final value or assertion failures. This highlights the need for test isolation when running in parallel.

Constraints

• Your solution must be implemented in TypeScript.
• You must use Jest for your testing framework.
• Tests should be configured to run in parallel. You will need to demonstrate how to enable this.
• The mock asynchronous functions should have varying durations to clearly show the impact of parallel execution.
• Your test suite should contain at least three distinct test files, each with at least one test, to better illustrate parallel execution across files.

Notes

• Enabling Parallelism: By default, Jest runs tests in parallel. However, you can control this behavior. Consider how you would explicitly enable or disable it. You might want to mention how to configure maxWorkers in jest.config.js or via the command line.
• Test Isolation: Remember that tests running in parallel should be as independent as possible. Avoid shared mutable state between tests or test files unless explicitly managed. For this challenge, focus on creating tests that are inherently independent.
• Observing Performance: To demonstrate the speedup, you'll need to run your tests sequentially as well and compare the total execution times. You can run tests sequentially using the --runInBand flag in Jest.
• Clear Demonstrations: Your code should make it obvious that parallel execution is happening. This can be done by:
  • Having tests with distinct durations.
  • Measuring and logging the total execution time for parallel vs. sequential runs.
  • Ensuring your assertions are correct and don't rely on specific execution order.