@test-station/adapter-node-test 0.1.8 → 0.2.10

package/README.md

@@ -14,7 +14,7 @@ npm install --save-dev @test-station/adapter-node-test
 
 - runs `node --test` suites and normalizes the output into the shared report model
 - injects Node's built-in `--test-reporter` flag for NDJSON capture
-- supports coverage when the suite command is a direct `node --test ...` invocation
+- supports coverage for direct `node --test ...` commands and supported package-script wrappers
 - writes raw NDJSON artifacts under `raw/`
 
 ## Direct Use
@@ -26,3 +26,32 @@ const adapter = createNodeTestAdapter();
 ```
 
 Use adapter id `node-test` in `test-station.config.mjs`.
+
+## Supported Coverage Patterns
+
+Coverage collection works when the adapter can safely resolve the executed command to a single `node --test ...` invocation. Supported patterns are:
+
+- direct commands such as `['node', '--test', 'tests/**/*.test.js']`
+- package scripts invoked with `yarn`, `npm run`, or `pnpm run` when the script itself resolves directly to `node --test ...`
+- explicit `suite.coverage.command` values that resolve to one of the patterns above
+
+Examples:
+
+```js
+{
+  adapter: 'node-test',
+  command: ['yarn', 'test:runtime'],
+}
+```
+
+```js
+{
+  adapter: 'node-test',
+  command: ['yarn', 'test:runtime'],
+  coverage: {
+    command: ['node', '--test', 'tests/runtime/**/*.test.js'],
+  },
+}
+```
+
+Shell-heavy wrappers such as chained commands (`&&`, `||`, pipes, redirections) are intentionally not treated as coverage-safe.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@test-station/adapter-node-test",
-  "version": "0.1.8",
+  "version": "0.2.10",
   "publishConfig": {
     "access": "public"
   },

package/src/index.js

@@ -14,10 +14,12 @@ export function createNodeTestAdapter() {
     phase: 3,
     async run({ project, suite, execution }) {
       const commandSpec = parseCommandSpec(suite.command);
-      const directNodeTest = isDirectNodeTestCommand(commandSpec);
-      const primaryExecution = await executeNodeTestRun(commandSpec, {
+      const resolvedCommand = resolveNodeTestCommand(commandSpec, {
         cwd: suite.cwd || project.rootDir,
-        suiteEnv: suite.env,
+      });
+      const primaryExecution = await executeNodeTestRun(resolvedCommand.commandSpec, {
+        cwd: suite.cwd || project.rootDir,
+        suiteEnv: mergeEnvRecords(suite.env, resolvedCommand.env),
         rawRelativePath: `${slugify(suite.packageName || 'default')}-${slugify(suite.id)}-node.ndjson`,
       });
       const parsed = parseNodeEvents(parseNdjson(primaryExecution.stdout), suite.cwd || project.rootDir);
@@ -26,13 +28,20 @@ export function createNodeTestAdapter() {
       let coverageArtifact = null;
 
       if (execution?.coverage && suite?.coverage?.enabled !== false) {
-        if (!directNodeTest) {
-          warnings.push('Coverage pass skipped for wrapped node:test command; use a direct node --test invocation to collect coverage.');
+        const coverageCommandSpec = suite?.coverage?.command
+          ? parseCommandSpec(suite.coverage.command)
+          : commandSpec;
+        const resolvedCoverageCommand = resolveNodeTestCommand(coverageCommandSpec, {
+          cwd: suite.cwd || project.rootDir,
+        });
+
+        if (!resolvedCoverageCommand.directNodeTest) {
+          warnings.push(createUnsupportedCoverageWarning(Boolean(suite?.coverage?.command)));
         } else {
-          const coverageExecution = await executeNodeTestRun(commandSpec, {
+          const coverageExecution = await executeNodeTestRun(resolvedCoverageCommand.commandSpec, {
             cwd: suite.cwd || project.rootDir,
             enableCoverage: true,
-            suiteEnv: suite.env,
+            suiteEnv: mergeEnvRecords(suite.env, resolvedCoverageCommand.env),
             rawRelativePath: `${slugify(suite.packageName || 'default')}-${slugify(suite.id)}-node-coverage.ndjson`,
           });
           const coverageParsed = parseNodeEvents(parseNdjson(coverageExecution.stdout), suite.cwd || project.rootDir);
@@ -153,10 +162,207 @@ function tokenizeCommand(command) {
 }
 
 function isDirectNodeTestCommand(commandSpec) {
-  const binary = path.basename(commandSpec.command).toLowerCase();
+  const binary = normalizeBinaryName(commandSpec.command);
   return binary.startsWith('node') && commandSpec.args.includes('--test');
 }
 
+function resolveNodeTestCommand(commandSpec, options = {}) {
+  const normalized = extractLeadingEnvAssignments(commandSpec);
+  if (isDirectNodeTestCommand(normalized.commandSpec)) {
+    return {
+      commandSpec: normalized.commandSpec,
+      env: normalized.env,
+      directNodeTest: true,
+    };
+  }
+
+  const packageScript = resolvePackageScriptNodeTestCommand(normalized.commandSpec, options);
+  if (packageScript) {
+    return {
+      commandSpec: packageScript.commandSpec,
+      env: mergeEnvRecords(normalized.env, packageScript.env),
+      directNodeTest: true,
+    };
+  }
+
+  return {
+    commandSpec: normalized.commandSpec,
+    env: normalized.env,
+    directNodeTest: false,
+  };
+}
+
+function resolvePackageScriptNodeTestCommand(commandSpec, options = {}) {
+  const invocation = parsePackageScriptInvocation(commandSpec);
+  if (!invocation) {
+    return null;
+  }
+
+  const packageJsonPath = findClosestPackageJson(options.cwd);
+  if (!packageJsonPath) {
+    return null;
+  }
+
+  const seenScripts = options.seenScripts || new Set();
+  const scriptKey = `${packageJsonPath}:${invocation.scriptName}`;
+  if (seenScripts.has(scriptKey)) {
+    return null;
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const scriptValue = pkg?.scripts?.[invocation.scriptName];
+  if (typeof scriptValue !== 'string' || scriptValue.trim().length === 0) {
+    return null;
+  }
+
+  const scriptCommand = parseCommandSpec(scriptValue);
+  if (containsShellControlTokens([scriptCommand.command, ...scriptCommand.args])) {
+    return null;
+  }
+
+  const normalizedScript = extractLeadingEnvAssignments(scriptCommand);
+  const scriptCommandSpec = appendForwardedArgs(normalizedScript.commandSpec, invocation.forwardedArgs);
+  if (isDirectNodeTestCommand(scriptCommandSpec)) {
+    return {
+      commandSpec: scriptCommandSpec,
+      env: normalizedScript.env,
+    };
+  }
+
+  const nested = resolvePackageScriptNodeTestCommand(scriptCommandSpec, {
+    cwd: path.dirname(packageJsonPath),
+    seenScripts: new Set([...seenScripts, scriptKey]),
+  });
+  if (!nested) {
+    return null;
+  }
+
+  return {
+    commandSpec: nested.commandSpec,
+    env: mergeEnvRecords(normalizedScript.env, nested.env),
+  };
+}
+
+function extractLeadingEnvAssignments(commandSpec) {
+  const tokens = [commandSpec.command, ...commandSpec.args];
+  const env = {};
+  let index = 0;
+
+  while (index < tokens.length && isEnvAssignmentToken(tokens[index])) {
+    const token = tokens[index];
+    const equalsIndex = token.indexOf('=');
+    env[token.slice(0, equalsIndex)] = token.slice(equalsIndex + 1);
+    index += 1;
+  }
+
+  if (index >= tokens.length) {
+    return {
+      commandSpec,
+      env,
+    };
+  }
+
+  return {
+    commandSpec: {
+      command: tokens[index],
+      args: tokens.slice(index + 1),
+    },
+    env,
+  };
+}
+
+function parsePackageScriptInvocation(commandSpec) {
+  const binary = normalizeBinaryName(commandSpec.command);
+  const args = [...commandSpec.args];
+
+  if (binary === 'yarn') {
+    let scriptIndex = 0;
+    if (args[0] === 'run') {
+      scriptIndex = 1;
+    }
+    const scriptName = args[scriptIndex];
+    if (!scriptName || scriptName.startsWith('-')) {
+      return null;
+    }
+    return {
+      manager: 'yarn',
+      scriptName,
+      forwardedArgs: normalizeForwardedArgs(args.slice(scriptIndex + 1)),
+    };
+  }
+
+  if (binary === 'npm' || binary === 'pnpm') {
+    if (args[0] !== 'run') {
+      return null;
+    }
+    const scriptName = args[1];
+    if (!scriptName || scriptName.startsWith('-')) {
+      return null;
+    }
+    return {
+      manager: binary,
+      scriptName,
+      forwardedArgs: normalizeForwardedArgs(args.slice(2)),
+    };
+  }
+
+  return null;
+}
+
+function normalizeForwardedArgs(args) {
+  if (!Array.isArray(args) || args.length === 0) {
+    return [];
+  }
+  if (args[0] === '--') {
+    return args.slice(1);
+  }
+  return args;
+}
+
+function appendForwardedArgs(commandSpec, forwardedArgs) {
+  if (!Array.isArray(forwardedArgs) || forwardedArgs.length === 0) {
+    return commandSpec;
+  }
+  return {
+    command: commandSpec.command,
+    args: [...commandSpec.args, ...forwardedArgs],
+  };
+}
+
+function findClosestPackageJson(startDir) {
+  let current = path.resolve(startDir || process.cwd());
+  while (true) {
+    const candidate = path.join(current, 'package.json');
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function containsShellControlTokens(tokens) {
+  return tokens.some((token) => ['&&', '||', ';', '|', '>', '>>', '<', '2>', '2>>', '2>&1'].includes(token));
+}
+
+function isEnvAssignmentToken(token) {
+  return typeof token === 'string' && /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
+}
+
+function normalizeBinaryName(command) {
+  return path.basename(command || '').toLowerCase().replace(/\.cmd$/, '');
+}
+
+function createUnsupportedCoverageWarning(hasCoverageCommand) {
+  if (hasCoverageCommand) {
+    return 'Coverage pass skipped for suite.coverage.command because it did not resolve to a supported node:test pattern.';
+  }
+  return 'Coverage pass skipped for wrapped node:test command; use a direct node --test invocation, a supported yarn/npm/pnpm package script, or suite.coverage.command.';
+}
+
 function withReporterArgs(args, options = {}) {
   const filtered = [];
   for (let index = 0; index < args.length; index += 1) {
@@ -499,6 +705,13 @@ function sanitizeEnv(env) {
   return nextEnv;
 }
 
+function mergeEnvRecords(...records) {
+  return records.reduce((merged, record) => ({
+    ...merged,
+    ...normalizeEnvRecord(record),
+  }), {});
+}
+
 function resolveSuiteEnv(suiteEnv) {
   return {
     ...sanitizeEnv(process.env),