@carecard/validate 3.17.0 → 3.19.0

package/scripts/packageTaskRunner.audit.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+
+const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const composedCommandPattern = /&&|\|\||\bsh -c\b|\bnode -e\b/u;
+const runnerCommandPattern = /^node scripts\/runPackageTask\.mjs ([A-Za-z0-9:_-]+)$/u;
+
+async function loadPackageTaskRunner() {
+  return import(new URL('./runPackageTask.mjs', import.meta.url));
+}
+
+test('delegates composed package tasks to the repository runner', async () => {
+  const runnerCommands = Object.entries(packageJson.scripts ?? {}).filter(([, command]) =>
+    runnerCommandPattern.test(command),
+  );
+
+  for (const [scriptName, command] of Object.entries(packageJson.scripts ?? {})) {
+    assert.doesNotMatch(
+      command,
+      composedCommandPattern,
+      `${scriptName} must delegate composition to runPackageTask.mjs`,
+    );
+  }
+
+  assert.ok(runnerCommands.length > 0, 'at least one package task must use the runner');
+  const { packageTasks } = await loadPackageTaskRunner();
+  for (const [scriptName] of runnerCommands) {
+    assert.ok(packageTasks[scriptName], `${scriptName} must have a runner task`);
+  }
+});
+
+test('does not suppress command execution errors at the CLI boundary', () => {
+  const runnerSource = readFileSync(new URL('./runPackageTask.mjs', import.meta.url), 'utf8');
+
+  assert.doesNotMatch(runnerSource, /catch\s*\{/u);
+});

package/scripts/packageTaskRunner.test.mjs

@@ -0,0 +1,64 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+async function loadPackageTaskRunner() {
+  return import(new URL('./runPackageTask.mjs', import.meta.url));
+}
+
+test('runs task steps in order and stops at the first failure', async () => {
+  const { runPackageTask } = await loadPackageTaskRunner();
+  const executedCommands = [];
+  const fixtureTasks = {
+    fixture: [{ command: 'first' }, { command: 'second' }, { command: 'third' }],
+  };
+
+  const exitCode = runPackageTask(
+    'fixture',
+    step => {
+      executedCommands.push(step.command);
+      return step.command === 'second' ? 7 : 0;
+    },
+    fixtureTasks,
+  );
+
+  assert.equal(exitCode, 7);
+  assert.deepEqual(executedCommands, ['first', 'second']);
+});
+
+test('runs conditional steps only when their required output is missing', async () => {
+  const { runPackageTask } = await loadPackageTaskRunner();
+  const executedCommands = [];
+  const fixtureTasks = {
+    fixture: [{ command: 'build', whenMissing: 'dist/runtime.js' }, { command: 'execute' }],
+  };
+
+  const exitCode = runPackageTask(
+    'fixture',
+    step => {
+      executedCommands.push(step.command);
+      return 0;
+    },
+    fixtureTasks,
+    () => true,
+  );
+
+  assert.equal(exitCode, 0);
+  assert.deepEqual(executedCommands, ['execute']);
+});
+
+test('merges task environment overrides without mutating inherited values', async () => {
+  const { createTaskEnvironment } = await loadPackageTaskRunner();
+  const inheritedEnvironment = { NODE_ENV: 'test', PATH: '/bin' };
+
+  const environment = createTaskEnvironment(
+    { NODE_ENV: 'production', DB_ENV: 'privileged' },
+    inheritedEnvironment,
+  );
+
+  assert.deepEqual(environment, {
+    NODE_ENV: 'production',
+    PATH: '/bin',
+    DB_ENV: 'privileged',
+  });
+  assert.deepEqual(inheritedEnvironment, { NODE_ENV: 'test', PATH: '/bin' });
+});

package/scripts/runPackageTask.mjs

@@ -0,0 +1,135 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const packageTasks = Object.freeze({
+  'validate:audits': [
+    {
+      command: 'node',
+      arguments: [
+        '--test',
+        'scripts/packageTaskRunner.audit.mjs',
+        'scripts/testOrder/testOrderPolicy.audit.mjs',
+        'scripts/testParallel/parallelTestPolicy.audit.mjs',
+      ],
+    },
+    {
+      command: 'mocha',
+      arguments: [
+        '--reporter',
+        'spec',
+        '--timeout',
+        '5000',
+        'test/config/repositoryIsolation.audit.js',
+        'test/config/tddGuidanceDocs.audit.js',
+        'test/dependencyOverrides.audit.js',
+      ],
+    },
+  ],
+  test: [
+    { command: 'npm', arguments: ['run', 'validate:audits'] },
+    { command: 'npm', arguments: ['run', 'test:order'] },
+    { command: 'tsc', arguments: ['--noEmit'] },
+    { command: 'nyc', arguments: ['node', 'test/index.test.js'] },
+  ],
+  'test:types': [
+    { command: 'tsc', arguments: ['--noEmit'] },
+    {
+      command: 'node',
+      arguments: [
+        '-e',
+        "process.stdout.write('\\n  ✔ Type tests passed: tsc --noEmit reported 0 errors across index.d.ts and test/**/*.ts\\n\\n')",
+      ],
+    },
+  ],
+  'test:coverage': [
+    { command: 'npm', arguments: ['run', 'test:order'] },
+    { command: 'tsc', arguments: ['--noEmit'] },
+    { command: 'nyc', arguments: ['node', 'test/index.test.js'] },
+  ],
+  'test:All': [{ command: 'npm', arguments: ['test'] }],
+});
+
+export function createTaskEnvironment(overrides = {}, inheritedEnvironment = process.env) {
+  return { ...inheritedEnvironment, ...overrides };
+}
+
+function getTaskExitCode(result) {
+  if (result.error) {
+    throw result.error;
+  }
+  if (typeof result.status === 'number') {
+    return result.status;
+  }
+  if (result.signal === 'SIGINT') {
+    return 130;
+  }
+  if (result.signal === 'SIGTERM') {
+    return 143;
+  }
+  return 1;
+}
+
+export function executeTaskStep(taskStep) {
+  if (taskStep.removePath) {
+    rmSync(taskStep.removePath, { recursive: true, force: true });
+    return 0;
+  }
+
+  const result = spawnSync(taskStep.command, taskStep.arguments ?? [], {
+    env: createTaskEnvironment(taskStep.environment),
+    shell: false,
+    stdio: 'inherit',
+  });
+  return getTaskExitCode(result);
+}
+
+function shouldRunTaskStep(taskStep, pathExists) {
+  return !taskStep.whenMissing || !pathExists(taskStep.whenMissing);
+}
+
+export function runPackageTask(
+  taskName,
+  executeTask = executeTaskStep,
+  taskDefinitions = packageTasks,
+  pathExists = existsSync,
+) {
+  const taskSteps = taskDefinitions[taskName];
+  if (!Array.isArray(taskSteps)) {
+    throw new Error('Unknown package task.');
+  }
+
+  for (const taskStep of taskSteps) {
+    if (!shouldRunTaskStep(taskStep, pathExists)) {
+      continue;
+    }
+    const exitCode = executeTask(taskStep);
+    if (exitCode !== 0) {
+      return exitCode;
+    }
+  }
+  return 0;
+}
+
+function isDirectExecution() {
+  if (!process.argv[1]) {
+    return false;
+  }
+  return resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+
+function runCommandLineTask() {
+  const taskName = process.argv[2];
+  if (!taskName || !packageTasks[taskName]) {
+    process.stderr.write('[PACKAGE_TASK_CONFIG] Unknown package task.\n');
+    process.exitCode = 2;
+    return;
+  }
+
+  process.exitCode = runPackageTask(taskName);
+}
+
+if (isDirectExecution()) {
+  runCommandLineTask();
+}

package/scripts/testOrder/randomizeTestOrder.cjs

@@ -3,38 +3,48 @@
 const MAX_TEST_ORDER_SEED = 2_147_483_647;
 
 function resolveTestOrderSeed(configuredSeed) {
-    if (configuredSeed === undefined) return undefined;
-    if (!/^[1-9]\d*$/.test(configuredSeed)) throw new Error('TEST_ORDER_SEED must be a positive 32-bit integer.');
-    const seed = Number(configuredSeed);
-    if (!Number.isSafeInteger(seed) || seed > MAX_TEST_ORDER_SEED) throw new Error('TEST_ORDER_SEED must be a positive 32-bit integer.');
-    return seed;
+  if (configuredSeed === undefined) {
+    return undefined;
+  }
+  if (!/^[1-9]\d*$/.test(configuredSeed)) {
+    throw new Error('TEST_ORDER_SEED must be a positive 32-bit integer.');
+  }
+  const seed = Number(configuredSeed);
+  if (!Number.isSafeInteger(seed) || seed > MAX_TEST_ORDER_SEED) {
+    throw new Error('TEST_ORDER_SEED must be a positive 32-bit integer.');
+  }
+  return seed;
 }
 function createSeededRandom(seed) {
-    let state = seed;
-    return function nextRandomValue() {
-        state = (state + 0x6d2b79f5) | 0;
-        let value = Math.imul(state ^ (state >>> 15), 1 | state);
-        value = (value + Math.imul(value ^ (value >>> 7), 61 | value)) ^ value;
-        return ((value ^ (value >>> 14)) >>> 0) / 4_294_967_296;
-    };
+  let state = seed;
+  return function nextRandomValue() {
+    state = (state + 0x6d2b79f5) | 0;
+    let value = Math.imul(state ^ (state >>> 15), 1 | state);
+    value = (value + Math.imul(value ^ (value >>> 7), 61 | value)) ^ value;
+    return ((value ^ (value >>> 14)) >>> 0) / 4_294_967_296;
+  };
 }
 function shuffleValues(values, random) {
-    for (let index = values.length - 1; index > 0; index -= 1) {
-        const replacementIndex = Math.floor(random() * (index + 1));
-        [values[index], values[replacementIndex]] = [values[replacementIndex], values[index]];
-    }
+  for (let index = values.length - 1; index > 0; index -= 1) {
+    const replacementIndex = Math.floor(random() * (index + 1));
+    [values[index], values[replacementIndex]] = [values[replacementIndex], values[index]];
+  }
 }
 function shuffleSuiteTree(suite, random) {
-    for (const childSuite of suite.suites) shuffleSuiteTree(childSuite, random);
-    shuffleValues(suite.tests, random);
-    shuffleValues(suite.suites, random);
+  for (const childSuite of suite.suites) {
+    shuffleSuiteTree(childSuite, random);
+  }
+  shuffleValues(suite.tests, random);
+  shuffleValues(suite.suites, random);
 }
 const mochaHooks = {
-    beforeAll() {
-        const seed = resolveTestOrderSeed(process.env.TEST_ORDER_SEED);
-        if (seed === undefined) return;
-        console.log(`Test order seed: ${seed} (reproduce with TEST_ORDER_SEED=${seed})`);
-        shuffleSuiteTree(this.test.parent, createSeededRandom(seed));
-    },
+  beforeAll() {
+    const seed = resolveTestOrderSeed(process.env.TEST_ORDER_SEED);
+    if (seed === undefined) {
+      return;
+    }
+    console.log(`Test order seed: ${seed} (reproduce with TEST_ORDER_SEED=${seed})`);
+    shuffleSuiteTree(this.test.parent, createSeededRandom(seed));
+  },
 };
 module.exports = { createSeededRandom, mochaHooks, resolveTestOrderSeed, shuffleSuiteTree };

package/scripts/testOrder/randomizeTestOrder.test.mjs

@@ -6,31 +6,31 @@ import testOrderRandomizer from './randomizeTestOrder.cjs';
 const { createSeededRandom, resolveTestOrderSeed, shuffleSuiteTree } = testOrderRandomizer;
 
 function createSuiteTree() {
-    return {
-        suites: [
-            { title: 'alpha', suites: [], tests: [{ title: 'one' }, { title: 'two' }] },
-            { title: 'beta', suites: [], tests: [{ title: 'three' }, { title: 'four' }] },
-            { title: 'gamma', suites: [], tests: [{ title: 'five' }, { title: 'six' }] },
-        ],
-        tests: [{ title: 'root one' }, { title: 'root two' }, { title: 'root three' }],
-    };
+  return {
+    suites: [
+      { title: 'alpha', suites: [], tests: [{ title: 'one' }, { title: 'two' }] },
+      { title: 'beta', suites: [], tests: [{ title: 'three' }, { title: 'four' }] },
+      { title: 'gamma', suites: [], tests: [{ title: 'five' }, { title: 'six' }] },
+    ],
+    tests: [{ title: 'root one' }, { title: 'root two' }, { title: 'root three' }],
+  };
 }
 
 test('uses ordinary ordering unless TEST_ORDER_SEED is explicitly supplied', () => {
-    assert.strictEqual(resolveTestOrderSeed(undefined), undefined);
-    assert.strictEqual(resolveTestOrderSeed('314159'), 314159);
-    for (const invalidSeed of ['', '0', '-1', '1.5', 'seed', '2147483648']) {
-        assert.throws(() => resolveTestOrderSeed(invalidSeed), /TEST_ORDER_SEED/);
-    }
+  assert.strictEqual(resolveTestOrderSeed(undefined), undefined);
+  assert.strictEqual(resolveTestOrderSeed('314159'), 314159);
+  for (const invalidSeed of ['', '0', '-1', '1.5', 'seed', '2147483648']) {
+    assert.throws(() => resolveTestOrderSeed(invalidSeed), /TEST_ORDER_SEED/);
+  }
 });
 
 test('shuffles nested suites and tests reproducibly', () => {
-    const firstTree = createSuiteTree();
-    const secondTree = createSuiteTree();
+  const firstTree = createSuiteTree();
+  const secondTree = createSuiteTree();
 
-    shuffleSuiteTree(firstTree, createSeededRandom(314159));
-    shuffleSuiteTree(secondTree, createSeededRandom(314159));
+  shuffleSuiteTree(firstTree, createSeededRandom(314159));
+  shuffleSuiteTree(secondTree, createSeededRandom(314159));
 
-    assert.deepStrictEqual(firstTree, secondTree);
-    assert.notDeepStrictEqual(firstTree, createSuiteTree());
+  assert.deepStrictEqual(firstTree, secondTree);
+  assert.notDeepStrictEqual(firstTree, createSuiteTree());
 });

package/scripts/testOrder/testOrderPolicy.audit.mjs

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { test } from 'node:test';
+
+const TEST_ORDER_INVARIANCE_RULE =
+  "Non-negotiable test order invariance rule: Every test must pass independently of which tests run before or after it, and the suite must pass in every execution order. Each test must establish the state it needs, isolate mutable state, and clean up state it owns; it must never rely on another test's setup, mutations, or cleanup. Default test, CI, and Husky commands must use the test framework's ordinary ordering and must not force randomized ordering. Random-order execution is an explicit diagnostic only, and every failure it exposes must be fixed at the root cause.";
+
+function listRepositoryFiles() {
+  return execFileSync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], {
+    encoding: 'utf8',
+  })
+    .trim()
+    .split('\n')
+    .filter(Boolean);
+}
+
+function isRequiredTestGuidance(filePath) {
+  return (
+    /^readme\.md$/i.test(filePath) ||
+    filePath === '.codex/AGENTS.md' ||
+    filePath === '.junie/guidelines.md' ||
+    filePath === '.agents/skills/carecard-workspace-standards/SKILL.md' ||
+    /^\.agents\/skills\/[^/]*(?:test|testing)[^/]*\/(?:SKILL\.md|references\/[^/]*(?:test|testing|coding-principles)[^/]*\.md)$/i.test(
+      filePath,
+    )
+  );
+}
+
+test('keeps the non-negotiable test order rule in repository guidance', () => {
+  const guidanceFiles = listRepositoryFiles().filter(isRequiredTestGuidance);
+  assert.ok(guidanceFiles.length > 0, 'No repository test guidance was found.');
+
+  for (const guidanceFile of guidanceFiles) {
+    const normalizedGuidance = readFileSync(guidanceFile, 'utf8').replace(/\s+/g, ' ').trim();
+    assert.ok(
+      normalizedGuidance.includes(TEST_ORDER_INVARIANCE_RULE),
+      `${guidanceFile} must document the non-negotiable test order invariance rule.`,
+    );
+  }
+});
+
+test('keeps default package scripts on the test framework ordinary ordering', () => {
+  const packageJson = JSON.parse(readFileSync('package.json', 'utf8'));
+
+  for (const [scriptName, command] of Object.entries(packageJson.scripts ?? {})) {
+    assert.equal(typeof command, 'string', `${scriptName} must be a string command.`);
+    assert.doesNotMatch(
+      command,
+      /--test-randomize|--test-random-seed/,
+      `${scriptName} must not force randomized test ordering.`,
+    );
+  }
+});

package/scripts/testParallel/parallelTestPolicy.audit.mjs

@@ -0,0 +1,63 @@
+import assert from 'node:assert/strict';
+import { readdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, relative, resolve } from 'node:path';
+import test from 'node:test';
+
+const require = createRequire(import.meta.url);
+const repositoryRoot = resolve(import.meta.dirname, '../..');
+const packageJson = JSON.parse(
+  readFileSync(new URL('../../package.json', import.meta.url), 'utf8'),
+);
+const packageTaskRunnerSource = readFileSync(
+  new URL('../runPackageTask.mjs', import.meta.url),
+  'utf8',
+);
+const testIndexSource = readFileSync(new URL('../../test/index.test.js', import.meta.url), 'utf8');
+const { parallelTestFiles } = require('../../test/index.test.js');
+
+function listRuntimeTestFiles(directoryPath) {
+  return readdirSync(directoryPath, { withFileTypes: true }).flatMap(entry => {
+    const entryPath = join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      return listRuntimeTestFiles(entryPath);
+    }
+    if (!/\.test\.(?:js|mjs)$/.test(entry.name) || entry.name === 'index.test.js') {
+      return [];
+    }
+    return [relative(repositoryRoot, entryPath)];
+  });
+}
+
+test('keeps runtime test selection in the index and package scripts short', () => {
+  assert.equal(packageJson.scripts.test, 'node scripts/runPackageTask.mjs test');
+  assert.equal(
+    packageJson.scripts['test:coverage'],
+    'node scripts/runPackageTask.mjs test:coverage',
+  );
+  assert.match(packageTaskRunnerSource, /arguments: \['run', 'test:order'\]/);
+  assert.match(packageTaskRunnerSource, /arguments: \['node', 'test\/index\.test\.js'\]/);
+  assert.match(packageTaskRunnerSource, /command: 'nyc'/);
+  assert.match(testIndexSource, /parallelTestFiles/);
+  assert.match(testIndexSource, /runIndexedMochaTests/);
+  assert.match(testIndexSource, /if \(require\.main === module\)/);
+});
+
+test('runs static parallel policy in the audit gate and callable runner behavior in the test-order gate', () => {
+  assert.equal(
+    packageJson.scripts['validate:audits'],
+    'node scripts/runPackageTask.mjs validate:audits',
+  );
+  assert.match(packageTaskRunnerSource, /scripts\/testParallel\/parallelTestPolicy\.audit\.mjs/);
+  assert.match(
+    packageJson.scripts['test:order'],
+    /scripts\/testParallel\/runIndexedMochaTests\.test\.mjs/,
+  );
+});
+
+test('selects every runtime test file exactly once', () => {
+  assert.deepEqual(
+    [...parallelTestFiles].sort(),
+    listRuntimeTestFiles(resolve(repositoryRoot, 'test')).sort(),
+  );
+});

package/scripts/testParallel/runIndexedMochaTests.cjs

@@ -9,63 +9,65 @@ const DEFAULT_MAX_PARALLEL_JOBS = 4;
 
 // Pattern: Configuration Boundary - bounds workers without accepting invalid input.
 function resolveParallelJobCount(
-    configuredJobCount,
-    testFileCount,
-    defaultMaximum = DEFAULT_MAX_PARALLEL_JOBS,
-    availableJobCount = availableParallelism(),
+  configuredJobCount,
+  testFileCount,
+  defaultMaximum = DEFAULT_MAX_PARALLEL_JOBS,
+  availableJobCount = availableParallelism(),
 ) {
-    const requestedJobCount =
-        configuredJobCount === undefined ? Math.min(availableJobCount, defaultMaximum) : Number.parseInt(configuredJobCount, 10);
+  const requestedJobCount =
+    configuredJobCount === undefined
+      ? Math.min(availableJobCount, defaultMaximum)
+      : Number.parseInt(configuredJobCount, 10);
 
-    if (!Number.isInteger(requestedJobCount) || requestedJobCount < 1) {
-        throw new Error('TEST_PARALLEL_JOBS must be a positive integer.');
-    }
-    return Math.min(requestedJobCount, testFileCount);
+  if (!Number.isInteger(requestedJobCount) || requestedJobCount < 1) {
+    throw new Error('TEST_PARALLEL_JOBS must be a positive integer.');
+  }
+  return Math.min(requestedJobCount, testFileCount);
 }
 
 // Pattern: Command Builder - keeps Mocha worker details out of package metadata.
 function buildMochaArguments(testFiles, jobCount) {
-    const requireFromRunner = createRequire(__filename);
-    return [
-        requireFromRunner.resolve('mocha/bin/mocha.js'),
-        '--parallel',
-        '--jobs',
-        String(jobCount),
-        '--require',
-        resolve('scripts/testOrder/randomizeTestOrder.cjs'),
-        ...testFiles,
-    ];
+  const requireFromRunner = createRequire(__filename);
+  return [
+    requireFromRunner.resolve('mocha/bin/mocha.js'),
+    '--parallel',
+    '--jobs',
+    String(jobCount),
+    '--require',
+    resolve('scripts/testOrder/randomizeTestOrder.cjs'),
+    ...testFiles,
+  ];
 }
 
 // Pattern: Process Adapter - returns the exact test process result to the index.
 function runIndexedMochaTests(testFiles) {
-    if (testFiles.length === 0) {
-        throw new Error('The package test index must select at least one test file.');
-    }
+  if (testFiles.length === 0) {
+    throw new Error('The package test index must select at least one test file.');
+  }
 
-    const jobCount = resolveParallelJobCount(process.env.TEST_PARALLEL_JOBS, testFiles.length);
-    const child = spawn(process.execPath, buildMochaArguments(testFiles, jobCount), {
-        env: {
-            ...process.env,
-            NODE_ENV: 'test',
-        },
-        stdio: 'inherit',
-    });
+  const jobCount = resolveParallelJobCount(process.env.TEST_PARALLEL_JOBS, testFiles.length);
+  const child = spawn(process.execPath, buildMochaArguments(testFiles, jobCount), {
+    env: {
+      ...process.env,
+      NODE_ENV: 'test',
+    },
+    stdio: 'inherit',
+  });
 
-    return new Promise((resolveExit, rejectExit) => {
-        child.once('error', rejectExit);
-        child.once('exit', (code, signal) => {
-            if (signal) {
-                rejectExit(new Error(`Mocha exited from signal ${signal}.`));
-                return;
-            }
-            resolveExit(code ?? 1);
-        });
+  return new Promise((resolveExit, rejectExit) => {
+    child.once('error', rejectExit);
+    child.once('exit', (code, signal) => {
+      if (signal) {
+        rejectExit(new Error(`Mocha exited from signal ${signal}.`));
+        return;
+      }
+      resolveExit(code ?? 1);
     });
+  });
 }
 
 module.exports = {
-    buildMochaArguments,
-    resolveParallelJobCount,
-    runIndexedMochaTests,
+  buildMochaArguments,
+  resolveParallelJobCount,
+  runIndexedMochaTests,
 };

package/scripts/testParallel/runIndexedMochaTests.test.mjs

@@ -6,16 +6,22 @@ const require = createRequire(import.meta.url);
 const { buildMochaArguments, resolveParallelJobCount } = require('./runIndexedMochaTests.cjs');
 
 test('uses bounded Mocha file workers without randomized default ordering', () => {
-    assert.equal(resolveParallelJobCount(undefined, 8, 4, 12), 4);
-    assert.equal(resolveParallelJobCount('2', 8, 4, 12), 2);
+  assert.equal(resolveParallelJobCount(undefined, 8, 4, 12), 4);
+  assert.equal(resolveParallelJobCount('2', 8, 4, 12), 2);
 
-    const argumentsList = buildMochaArguments(['test/example.test.js'], 2);
+  const argumentsList = buildMochaArguments(['test/example.test.js'], 2);
 
-    assert.ok(argumentsList.includes('--parallel'));
-    assert.deepEqual(argumentsList.slice(argumentsList.indexOf('--jobs'), argumentsList.indexOf('--jobs') + 2), ['--jobs', '2']);
-    assert.ok(argumentsList.includes('test/example.test.js'));
+  assert.ok(argumentsList.includes('--parallel'));
+  assert.deepEqual(
+    argumentsList.slice(argumentsList.indexOf('--jobs'), argumentsList.indexOf('--jobs') + 2),
+    ['--jobs', '2'],
+  );
+  assert.ok(argumentsList.includes('test/example.test.js'));
 });
 
 test('rejects invalid worker configuration instead of changing execution silently', () => {
-    assert.throws(() => resolveParallelJobCount('0', 8, 4, 12), /TEST_PARALLEL_JOBS must be a positive integer/);
+  assert.throws(
+    () => resolveParallelJobCount('0', 8, 4, 12),
+    /TEST_PARALLEL_JOBS must be a positive integer/,
+  );
 });