Isolated concurrency utility to run specific tests in isolation

[blake-mealey]

I run my test suite against a shared local DB and I was running into issues with a particular test file which is forced to make some assumptions about the state of the DB while it runs.

I managed to come up with a pretty clean solution for managing this using @ava/cooperate:

// test-concurrency.ts
import type { TestFn } from 'ava';
import { SharedContext } from '@ava/cooperate';

const context = new SharedContext('all-tests');

/**
 * Create a semaphore with a very high initial value. We don't actually want to limit concurrency for most
 * tests but we want a mechanism to force some tests to run in isolation.
 */
const semaphore = context.createSemaphore('all-tests', 1_000_000);

function withSemaphore<TContext>(test: TestFn<TContext>, name: string, amount: number): TestFn<TContext> {
  const test2 = test as TestFn<TContext & { release: () => void }>;
  test2.serial.before(name, async (t) => {
    t.context.release = await semaphore.acquire(amount);
  });
  test2.after.always(name, async (t) => {
    t.context.release();
  });
  // Don't expose `context.release` to tests
  return test2 as TestFn<TContext>;
}

/**
 * Requires an ava test context to down a semaphore shared by all tests by 1. Since the semaphore's initial
 * value is very high this should not affect concurrency for "shared" tests unless an "isolated" test is
 * executing which downs the semaphore's full initial value (see `withIsolatedConcurrency`).
 * @example const test = withSharedConcurrency(ava)
 * @param test - ava test function
 * @returns updated ava test function
 */
export function withSharedConcurrency<TContext>(test: TestFn<TContext>): TestFn<TContext> {
  return withSemaphore(test, 'withShared', 1);
}

/**
 * Requires an ava test context to down a semaphore shared by all tests by its full initial value. This will
 * grant the test context exclusive access until it completes.
 * @example const test = withIsolatedConcurrency(ava)
 * @param test - ava test function
 * @returns updated ava test function
 */
export function withIsolatedConcurrency<TContext>(test: TestFn<TContext>): TestFn<TContext> {
  return withSemaphore(test, 'withIsolated', semaphore.initialValue);
}

Example usage:

// shared-concurrency.test.ts
import ava from 'ava';
import { withSharedConcurrency } from './test-concurrency'

const test = withSharedConcurrency(ava);

test('should run in parallel', (t) => {
  t.pass();
});

// isolated-concurrency.test.ts
import ava from 'ava';
import { withIsolatedConcurrency } from './test-concurrency'

const test = withIsolatedConcurrency(ava);

test('should run in isolation', (t) => {
  t.pass();
});