test-inventory 0.7.0 → 0.9.0

package/dist/model.d.ts

@@ -37,6 +37,8 @@ export interface Problem {
     level?: DiagnosticLevel;
     /** Raised by code in a test, hook or helper body, which runs after the file is loaded and so can't stop it loading. */
     afterLoad?: boolean;
+    /** The runner still runs the tests the file declared before the call that stops it loading, as WebdriverIO's Mocha. */
+    keepsEarlierTests?: boolean;
 }
 export interface Title {
     text: string;
@@ -87,9 +89,10 @@ interface Declaration {
     cases: TableCase[] | null;
     problems: Problem[];
 }
-/** One case of a `.each` or `.for` table: the items its title is formatted with, and the arguments its callback gets. */
+/** One case of a `.each` or `.for` table: the title the runner gives it, and the arguments its callback gets. */
 export interface TableCase {
-    items: Value[];
+    /** Null when the scan can't format it the way the runner does, as for a title that shows an object. */
+    title: string | null;
     args: Value[];
 }
 export interface TestDeclaration extends Declaration {
@@ -139,6 +142,8 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     settings: RunSettings;
     /** Source text of the first argument. */ argument: string | null;
     problems: Problem[];
+    /** Jest's `jest.retryTimes()`, which applies to every test of the file; a later call replaces it. */
+    fileWide?: boolean;
 } | {
     kind: 'hook';
     name: keyof HookCounts;
@@ -219,6 +224,8 @@ export interface Adapter {
     /** Where each of `fileTags` is written. */
     fileTagSpans: Span[];
     usesGlobals: boolean;
+    /** Whether a test declared in a test's body is a subtest the runner runs as the test does, as in `node:test`. */
+    nestsTests?: boolean;
     classify(call: CallExpression, context: CallContext): ApiCall | null;
     /**
      * The test or describe function a value holds, in the adapter's own terms, as `it.skip` in `return it.skip`; null

package/dist/node-scripts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The `node --test` commands of a package.json script, each as the files and globs it gives; empty for a command
+ * that gives none. A command runs node:test when `--test` comes before any file, as `node build.js --test` passes it on
+ * to the script.
+ */
+export declare function nodeTestCommands(script: string): string[][];

package/dist/node-scripts.js

@@ -0,0 +1,85 @@
+/** Node.js options that take their value as the next argument, so it is not a file to test. */
+const VALUE_OPTIONS = new Set([
+    '--allow-fs-read',
+    '--allow-fs-write',
+    '--conditions',
+    '-C',
+    '--config-file',
+    '--cpu-prof-dir',
+    '--cpu-prof-name',
+    '--diagnostic-dir',
+    '--disable-warning',
+    '--dns-result-order',
+    '--env-file',
+    '--env-file-if-exists',
+    '--experimental-config-file',
+    '--experimental-loader',
+    '--heap-prof-dir',
+    '--heap-prof-name',
+    '--heapsnapshot-signal',
+    '--icu-data-dir',
+    '--import',
+    '--input-type',
+    '--loader',
+    '--localstorage-file',
+    '--max-http-header-size',
+    '--openssl-config',
+    '--redirect-warnings',
+    '--report-dir',
+    '--report-filename',
+    '--require',
+    '-r',
+    '--secure-heap',
+    '--secure-heap-min',
+    '--test-concurrency',
+    '--test-coverage-branches',
+    '--test-coverage-exclude',
+    '--test-coverage-functions',
+    '--test-coverage-include',
+    '--test-coverage-lines',
+    '--test-global-setup',
+    '--test-isolation',
+    '--test-name-pattern',
+    '--test-random-seed',
+    '--test-reporter',
+    '--test-reporter-destination',
+    '--test-rerun-failures',
+    '--test-shard',
+    '--test-skip-pattern',
+    '--test-timeout',
+    '--title',
+    '--unhandled-rejections',
+    '--watch-kill-signal',
+    '--watch-path',
+]);
+/**
+ * The `node --test` commands of a package.json script, each as the files and globs it gives; empty for a command
+ * that gives none. A command runs node:test when `--test` comes before any file, as `node build.js --test` passes it on
+ * to the script.
+ */
+export function nodeTestCommands(script) {
+    const commands = [];
+    for (const command of script.split(/&&|\|\||[;|]/)) {
+        const words = [...command.matchAll(/'([^']*)'|"([^"]*)"|(\S+)/g)].map((match) => match[1] ?? match[2] ?? match[3]);
+        const node = words.findIndex((word) => /(^|[/\\])node(\.exe)?$/.test(word));
+        if (node === -1)
+            continue;
+        let runsTests = false;
+        const files = [];
+        for (let index = node + 1; index < words.length; index++) {
+            const word = words[index];
+            if (word === '--test')
+                runsTests = true;
+            else if (VALUE_OPTIONS.has(word))
+                index++;
+            else if (!word.startsWith('-')) {
+                if (!runsTests)
+                    break;
+                files.push(word);
+            }
+        }
+        if (runsTests)
+            commands.push(files);
+    }
+    return commands;
+}

package/dist/options.d.ts

@@ -4,11 +4,18 @@ export type { CommentsMode };
 /** @inline */
 export interface ScanOptions {
     /**
-     * Glob patterns for the test files, relative to `root`. As in Playwright and Vitest, they match names that start with
-     * a dot too. Without them, the test files are those the configs in the root and the folders below it run.
+     * Glob patterns for the test files, relative to `root`. As in the runners, they match names that start with a dot
+     * too. Without them, the test files are those the configs in the root and the folders below it run, or for node:test
+     * and Bun those `node --test` and `bun test` run.
      */
     patterns?: string[];
-    framework: Framework;
+    /**
+     * The runner whose tests are listed. Without it, the one the project uses: whose package a package.json in the root
+     * or below lists, whose config is there, or for node:test and Bun, run by a package.json script, else one a
+     * package.json above the root lists. With none of them or
+     * several, the scan throws a `TypeError` that names them.
+     */
+    framework?: Framework;
     /** The project root. Paths in the output are relative to it. Defaults to the current directory. */
     root?: string;
     /** Glob patterns to leave out, in addition to `node_modules` and `.git`. */
@@ -22,6 +29,11 @@ export interface ScanOptions {
      * out, each with the title the runner gives it. Defaults to `false`: one record per declaration.
      */
     expandCases?: boolean;
+    /**
+     * Stops the scan when it aborts: the scan checks it before it starts and between files, and then rejects with the
+     * signal's `reason`, as `fetch` does.
+     */
+    signal?: AbortSignal;
 }
 /** @inline */
 export interface ScanSourceOptions {
@@ -47,6 +59,7 @@ export declare function checkObject(value: unknown, name: string): Record<string
 export declare function checkFramework(value: unknown, option: string): Framework;
 export declare function checkComments(value: unknown, option: string): CommentsMode;
 export declare function checkFlag(value: unknown, option: string): boolean;
+export declare function checkSignal(value: unknown, option: string): AbortSignal | null;
 export declare function checkVersion(value: unknown, option: string): string | null;
 export declare function checkString(value: unknown, option: string): string;
 export declare function checkStrings(value: unknown, option: string, required: boolean): string[];

package/dist/options.js

@@ -1,4 +1,14 @@
-const FRAMEWORKS = ['playwright', 'vitest'];
+const FRAMEWORKS = [
+    'playwright',
+    'vitest',
+    'jest',
+    'mocha',
+    'jasmine',
+    'cypress',
+    'webdriverio',
+    'node',
+    'bun',
+];
 const COMMENTS = ['all', 'non-active', 'none'];
 // A prerelease and build metadata each appear once, so a long input can't make the match backtrack for long.
 const VERSION = /^v?(\d+)\.(\d+)(?:\.\d+)?(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -14,8 +24,10 @@ export function checkObject(value, name) {
     return value;
 }
 export function checkFramework(value, option) {
-    if (!FRAMEWORKS.includes(value))
-        throw invalid(option, '"playwright" or "vitest"');
+    if (!FRAMEWORKS.includes(value)) {
+        const names = FRAMEWORKS.map((name) => `"${name}"`);
+        throw invalid(option, `${names.slice(0, -1).join(', ')} or ${names.at(-1)}`);
+    }
     return value;
 }
 export function checkComments(value, option) {
@@ -32,6 +44,13 @@ export function checkFlag(value, option) {
         throw invalid(option, 'true or false');
     return value;
 }
+export function checkSignal(value, option) {
+    if (value === undefined)
+        return null;
+    if (!(value instanceof AbortSignal))
+        throw invalid(option, 'an AbortSignal');
+    return value;
+}
 export function checkVersion(value, option) {
     if (value === undefined || value === null)
         return null;

package/dist/parse.js

@@ -222,10 +222,25 @@ export function parseFile(fileName, code) {
             error: { message, start: tooDeep, end: tooDeep + 1 },
         };
     }
-    const result = parseSync(fileName, text, parserOptions(fileName));
+    let result;
+    let program;
+    try {
+        result = parseSync(fileName, text, parserOptions(fileName));
+        // The tree is handed over when it is first read.
+        program = result.program;
+    }
+    catch (error) {
+        // The parser can fail to hand over the tree of invalid code, as for a JSX name written as a Unicode escape.
+        return {
+            source: new SourceText(text),
+            program: parseSync(fileName, '', parserOptions(fileName)).program,
+            comments: [],
+            error: { message: error.message, start: 0, end: 0 },
+        };
+    }
     return {
         source: new SourceText(text),
-        program: result.program,
+        program,
         comments: result.comments,
         error: firstError(result.errors),
     };

package/dist/records.d.ts

@@ -52,8 +52,14 @@ export interface VitestTags {
 }
 /** What the config the file uses gives it. */
 export interface FileConfig {
-    /** Whether a `.only` fails the run: Playwright's `forbidOnly`, always, never, or under the condition with this text. */
-    forbidOnly: boolean | string;
+    /**
+     * Why a `.only` fails, from Playwright's `forbidOnly` or Vitest's `allowOnly`, and whether it surely does; null when
+     * it doesn't.
+     */
+    forbidOnly: {
+        message: string;
+        isSure: boolean;
+    } | null;
     /** The names of the projects that run a test, null when unknown, and what they set for it. */
     forTest(test: TestRecord, suites: SuiteRecord[]): {
         projects: string[] | null;

package/dist/records.js

@@ -1,4 +1,4 @@
-import { REJECTS_FILE, toDiagnostic } from "./diagnostics.js";
+import { LEVELS, REJECTS_FILE, toDiagnostic } from "./diagnostics.js";
 import { anySlow, eitherCondition, noHooks, } from "./extract.js";
 import { problem } from "./frameworks/common.js";
 import { hashNodes, shortHash } from "./hash.js";
@@ -184,9 +184,16 @@ class RecordBuilder {
     fileName;
     ordinals = new Map();
     suiteIds = new Map();
+    testIds = new Map();
     diagnostics = [];
     /** The line of the first problem for which the runner refuses the file; null when it loads. */
     rejectedAt = null;
+    /** Whether the tests declared before the line that stops the file loading still run. */
+    keepsEarlierTests = false;
+    /** Jest: the describes with a test of their own that uses `.only`, which then keep their mode from their others. */
+    focused = new Set();
+    /** Jasmine: scopes with a focused spec or describe below them, whose own focus Jasmine gives up for the inner one. */
+    focusedBelow = new Set();
     constructor(parsed, options) {
         this.parsed = parsed;
         this.options = options;
@@ -203,12 +210,24 @@ class RecordBuilder {
             ...extraction.problems.filter((item) => tags === null || isTagMissing || item.code !== 'config-may-change-state'),
             ...undefinedUses.map((use) => use.problem),
         ];
-        const rejecting = [...problems, ...testProblems, ...duplicates.map((item) => item.problem)].filter((item) => REJECTS_FILE[this.options.framework].has(item.code) && item.code !== 'undefined-tag' && item.afterLoad !== true);
+        const rejecting = [...problems, ...testProblems, ...duplicates.map((item) => item.problem)].filter((item) => REJECTS_FILE[this.options.framework].has(item.code) &&
+            item.code !== 'undefined-tag' &&
+            item.afterLoad !== true &&
+            // A warning of a code that rejects files, as for Jest's .each without a body, leaves the file loading.
+            (item.level ?? LEVELS[item.code]) === 'error');
         // Each of these problems points at the code that causes it. Vitest meets the tags in the order they are listed.
         const firstTag = undefinedUses.find((use) => use.isSure)?.problem;
         const lines = [...rejecting, ...(firstTag ? [firstTag] : [])].map((item) => this.parsed.source.line(item.node.start));
         if (lines.length > 0)
             this.rejectedAt = Math.min(...lines);
+        this.keepsEarlierTests = rejecting.length > 0 && rejecting.every((item) => item.keepsEarlierTests === true);
+        this.focused = new Set(extraction.tests.filter((test) => test.declaration.isOnly).map((test) => test.scope));
+        const focusedAt = [
+            ...extraction.tests.filter((test) => test.declaration.isOnly).map((test) => test.scope),
+            // A describe's scope is inside the file's, so it has a parent.
+            ...extraction.suites.filter((suite) => suite.declaration.isOnly).map((suite) => suite.scope.parent),
+        ];
+        this.focusedBelow = new Set(focusedAt.flatMap((scope) => outward(scope)));
         const suites = extraction.suites.map((suite) => this.suite(suite));
         const tests = extraction.tests.map((test) => this.test(test, suites));
         for (const item of problems) {
@@ -258,15 +277,12 @@ class RecordBuilder {
      * warning. `call` is the `.only` call when it is in this file, whose callee the diagnostic shows.
      */
     forbidOnly(located, call) {
-        const forbid = this.options.config?.forbidOnly ?? false;
-        if (forbid === false)
+        const forbid = this.options.config?.forbidOnly ?? null;
+        if (forbid === null)
             return;
-        const message = forbid === true
-            ? 'The config sets forbidOnly, so this .only fails the run before any test runs.'
-            : `The config sets forbidOnly when ${forbid}, so then this .only fails the run before any test runs.`;
         const callee = call && snippet(this.parsed.source.text.slice(call.callee.start, call.callee.end));
-        const found = problem('forbidden-only', located, message, callee);
-        this.diagnostics.push(this.diagnostic(forbid === true ? found : { ...found, level: 'warning' }));
+        const found = problem('forbidden-only', located, forbid.message, callee);
+        this.diagnostics.push(this.diagnostic(forbid.isSure ? found : { ...found, level: 'warning' }));
     }
     suite(pending) {
         const { scope, declaration, call } = pending;
@@ -336,6 +352,39 @@ class RecordBuilder {
             merged[option] = undefined;
         return merged;
     }
+    /**
+     * A Jest test's state, as jest-circus decides it: a describe takes its own `.only` or `.skip`, else the mode around
+     * it; a test without a mode of its own takes its describe's, unless that describe is `.only` and has a test of its
+     * own that uses `.only`. A skipped describe skips every test in it, a todo or a `.only` too, and a `.only` there
+     * focuses nothing.
+     */
+    jestState(pending, scopes) {
+        const { declaration } = pending;
+        const marked = scopes.find((scope) => scope.isOnly || scope.states.some((setting) => setting.state === 'skip'));
+        const skippedBy = marked && !marked.isOnly ? marked.states.find((setting) => setting.state === 'skip') : undefined;
+        const own = (state) => declaration.states.find((setting) => setting.state === state);
+        const passesOnly = marked?.isOnly === true && !this.focused.has(pending.scope);
+        if (skippedBy) {
+            return {
+                chosen: own('skip')
+                    ? { setting: own('skip'), source: 'test' }
+                    : { setting: skippedBy, source: 'suite' },
+                isOnly: false,
+            };
+        }
+        const setting = own('skip') ?? own('todo') ?? own('expectedToFail');
+        return { chosen: setting ? { setting, source: 'test' } : null, isOnly: declaration.isOnly || passesOnly };
+    }
+    /**
+     * Whether Jasmine runs a spec as focused: a `fit`, or a spec in an `fdescribe` with no focused spec or describe
+     * below it, as Jasmine runs only the innermost focus (checked with Jasmine 4.6.0 and 7.0.0).
+     */
+    jasmineFocus(pending, scopes) {
+        if (pending.declaration.isOnly)
+            return true;
+        const nearest = scopes.find((scope) => scope.isOnly);
+        return nearest !== undefined && !this.focusedBelow.has(nearest);
+    }
     test(pending, suites) {
         const { declaration } = pending;
         const dependencies = this.options.dependencies(pending);
@@ -344,7 +393,14 @@ class RecordBuilder {
         const scopes = outward(pending.scope);
         const describes = scopes.filter((scope) => scope.kind === 'describe').reverse();
         const title = declaration.title;
-        const id = this.id([this.describeTitles(describes), title.withoutTags]);
+        const parents = [];
+        for (let parent = pending.parent; parent; parent = parent.parent)
+            parents.unshift(parent);
+        const parentTitles = parents.map((parent) => parent.declaration.title.withoutTags);
+        const id = this.id(parents.length > 0
+            ? [this.describeTitles(describes), parentTitles, title.withoutTags]
+            : [this.describeTitles(describes), title.withoutTags]);
+        this.testIds.set(pending, id);
         const fileScope = scopes[scopes.length - 1];
         const tags = unique([
             ...(this.options.config?.configTags ?? []),
@@ -356,19 +412,32 @@ class RecordBuilder {
         // In Vitest 5 the options of a test's tags win over those the describes pass down; before, the describes' win.
         const tagsFirst = this.options.config?.tags?.beatsDescribes ?? true;
         const tagged = (own, tag, around) => tagsFirst ? [...own, ...tag, ...around] : [...own, ...around, ...tag];
-        const chosen = chooseState([
-            ...declaredStates(pending.states.slice(0, declaration.states.length), fromTags, declaration),
-            ...pending.states.slice(declaration.states.length).map((setting) => ({ setting, source: 'test' })),
-            ...scopes.flatMap((scope) => scope.states.map((setting) => ({
-                setting,
-                source: scope.kind === 'file' ? 'file' : 'suite',
-            }))),
-        ]);
-        // When the runner refuses the file, no test in it runs, whatever else is written.
-        const rejected = this.rejectedAt !== null;
+        const jest = this.options.framework === 'jest' ? this.jestState(pending, scopes) : null;
+        const focused = this.options.framework === 'jasmine' ? this.jasmineFocus(pending, scopes) : null;
+        // A focused Jasmine spec runs inside an `xdescribe`, whose own skip doesn't reach it; `pending()` still does.
+        const declaredSkip = (scope, setting) => focused === true && scope.kind === 'describe' && suiteOf(scope).declaration.states.includes(setting);
+        const chosen = jest
+            ? jest.chosen
+            : chooseState([
+                ...declaredStates(pending.states.slice(0, declaration.states.length), fromTags, declaration),
+                ...pending.states.slice(declaration.states.length).map((setting) => ({ setting, source: 'test' })),
+                // A test the declaration skips never runs its body, so its subtests never run; one its body skips still runs it.
+                ...parents.flatMap((parent) => parent.declaration.states.map((setting) => ({ setting, source: 'suite' }))),
+                ...scopes.flatMap((scope) => scope.states
+                    .filter((setting) => !declaredSkip(scope, setting))
+                    .map((setting) => ({
+                    setting,
+                    source: scope.kind === 'file' ? 'file' : 'suite',
+                }))),
+            ]);
+        // When the runner refuses the file, no test in it runs, whatever else is written, or none after the refused call.
+        const rejected = this.rejectedAt !== null && !(this.keepsEarlierTests && this.parsed.source.line(located.start) < this.rejectedAt);
         const state = rejected ? 'notLoaded' : (chosen?.setting.state ?? 'active');
         const setting = rejected ? null : (chosen?.setting ?? null);
-        const suitePath = describes.flatMap((scope) => suiteOf(scope).declaration.title?.text ?? []);
+        const suitePath = [
+            ...describes.flatMap((scope) => suiteOf(scope).declaration.title?.text ?? []),
+            ...parents.map((parent) => parent.declaration.title.text),
+        ];
         const tagConcurrent = this.options.config?.tags?.concurrentBeatsTags ? undefined : fromTags?.concurrent;
         const tagMode = tagConcurrent === undefined ? null : tagConcurrent ? 'parallel' : 'default';
         const [mode = null] = tagged([declaration.mode], [tagMode], scopes.map((scope) => scope.mode)).filter((item) => item !== null);
@@ -376,7 +445,9 @@ class RecordBuilder {
         for (const values of [fromTags?.meta, ...describes.map((scope) => scope.details.meta), declaration.details.meta]) {
             Object.assign(meta, values);
         }
-        const isOnly = declaration.isOnly || scopes.some((scope) => scope.isOnly) || fromTags?.only === true;
+        const isOnly = jest
+            ? jest.isOnly
+            : (focused ?? (declaration.isOnly || scopes.some((scope) => scope.isOnly) || fromTags?.only === true));
         const comments = this.options.comments === 'all' || (this.options.comments === 'non-active' && state !== 'active')
             ? pending.comments
             : [];
@@ -407,6 +478,7 @@ class RecordBuilder {
             dependencies: dependencies.files,
             hasUnfollowedDependencies: !dependencies.isComplete,
             suiteId: describes.length > 0 ? this.suiteIds.get(describes[describes.length - 1]) : null,
+            parentTestId: pending.parent ? this.testIds.get(pending.parent) : null,
             suitePath,
             relativeFilePath: this.options.relativeFilePath,
             fileName: this.fileName,

package/dist/resolve.d.ts

@@ -2,8 +2,25 @@ import type { ModuleReader } from './model.ts';
 /** Parses JSON written with comments and trailing commas, as tsconfig files often are; null when it isn't JSON. */
 export declare function parseJsonc(text: string): unknown;
 /**
- * Returns a reader for the modules a test file imports. It follows relative paths, tsconfig `paths` and `baseUrl` from
- * the tsconfig nearest the importing file, package.json `imports` (`#name`), and workspace packages whose entry is
- * TypeScript source. Each module it reads carries a reader for the modules that module imports in turn.
+ * How a runner's config maps imports, for every module a test imports: aliases, tried first, as Vite's
+ * `resolve.alias` and Jest's `moduleNameMapper`, and folders a bare name is looked for in, as Jest's `modulePaths` and
+ * `moduleDirectories`.
  */
-export declare function moduleResolver(root: string): (fromFile: string) => ModuleReader;
+export interface ImportMap {
+    /** A string `find` maps the name itself and the names below it, as `@` maps `@/x`; a regex maps what it matches. */
+    aliases: {
+        find: string | RegExp;
+        replacements: string[];
+    }[];
+    /** Folders a bare name is looked for in. */
+    paths: string[];
+    /** Names of folders a bare name is looked for in, in the importing file's folder and each folder above it. */
+    directories: string[];
+}
+/**
+ * Returns a reader for the modules a test file imports. It follows the import map of the config the file runs with,
+ * relative paths, tsconfig `paths` and `baseUrl` from the tsconfig nearest the importing file, package.json `imports`
+ * (`#name`), and workspace packages whose entry is TypeScript source. Each module it reads carries a reader for the
+ * modules that module imports in turn, with the same import map.
+ */
+export declare function moduleResolver(root: string): (fromFile: string, map?: ImportMap | null) => ModuleReader;