test-inventory 0.7.0 → 0.9.0

package/dist/dependency-hash.js

@@ -5,8 +5,9 @@ import { exportName, parseModule } from "./frameworks/bindings.js";
 import { destructuredNames, problem, takesWhole } from "./frameworks/common.js";
 import { shortHash, hashNodes } from "./hash.js";
 import { parseFile } from "./parse.js";
-import { snippet } from "./source.js";
+import { snippet, SourceText } from "./source.js";
 import { bindingNames, isScopeNode, Values } from "./values.js";
+const NOTHING_MERGED = { files: [], byFile: new Map(), parts: new Map() };
 /** Statements that only declare something, unless code in them runs while they are evaluated. */
 const DECLARATIONS = new Set([
     'ImportDeclaration',
@@ -386,11 +387,11 @@ export class DependencyGraph {
         return { units, byFile, places, fixtures, asks, snapshots };
     }
     /**
-     * Everything a test's roots reach on top of `base`, the code its file runs when loaded, which all its tests share,
-     * with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
-     * followed.
+     * Everything a test's roots reach on top of `bases`, such as the code its file runs when loaded, which all its tests
+     * share, with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
+     * followed. `shared` is what the bases cover, put together once for the many tests that share them.
      */
-    dependencies(roots, bases, needs, snapshots, report) {
+    dependencies(roots, bases, shared, needs, snapshots, report) {
         const reached = [...bases, this.reach(roots, bases)];
         // A fixture can ask for one an object it extends defines, or use another test object, so names are shared by
         // every test object reached, and each name and object is read once.
@@ -476,11 +477,13 @@ export class DependencyGraph {
             this.reported.add(key);
             report(place);
         }
-        const files = [...new Set(reached.flatMap((item) => [...item.byFile.keys()]))].sort();
+        const added = hashesByFile(reached.slice(bases.length));
+        const files = [...new Set([...shared.files, ...added.keys()])].sort();
         const parts = files.map((file) => {
-            return [file, reached.flatMap((item) => item.byFile.get(file) ?? []).sort()];
+            const own = added.get(file);
+            return own ? part(file, [...(shared.byFile.get(file) ?? []), ...own]) : shared.parts.get(file);
         });
-        return { hash: shortHash(JSON.stringify(parts)), files, isComplete: places.length === 0 };
+        return { hash: shortHash(`[${parts.join(',')}]`), files, isComplete: places.length === 0 };
     }
     newModule(relativeFilePath, parsed, text, values, readModule) {
         return {
@@ -632,7 +635,8 @@ export class DependencyGraph {
     }
     /** A place in a module the scan can't follow, as a unit that marks the tests that reach it. */
     placeUnit(module, at, message, isQuiet = false) {
-        const { source } = module.parsed;
+        // A JSON config, such as Jest's package.json, is taken by its text.
+        const source = module.parsed?.source ?? new SourceText(module.text);
         const unit = this.newUnit(module, [], new Map(), false);
         unit.edges = new Set();
         const text = snippet(source.slice(at.start, at.end)) || null;
@@ -665,7 +669,11 @@ export class DependencyGraph {
         if ('module' in gap) {
             const module = this.moduleOf(gap.module);
             // The path a setup key names, where the config writes it.
-            const at = gap.text === null ? null : literalIn(module.parsed.program, gap.text);
+            let at = null;
+            if (gap.text !== null && module.parsed)
+                at = literalIn(module.parsed.program, gap.text);
+            else if (gap.text !== null)
+                at = jsonStringIn(module.text, gap.text);
             return this.placeUnit(module, at ?? { start: 0, end: 0 }, gap.message, gap.isQuiet);
         }
         const module = this.newModule(gap.relativeFilePath, null, null, new Values(), null);
@@ -1300,6 +1308,33 @@ export class DependencyGraph {
         return edges;
     }
 }
+/** The hashes of several reaches by file, in the order the reaches come. */
+function hashesByFile(reaches) {
+    const byFile = new Map();
+    for (const item of reaches) {
+        for (const [file, hashes] of item.byFile)
+            byFile.set(file, [...(byFile.get(file) ?? []), ...hashes]);
+    }
+    return byFile;
+}
+/** A file and its hashes, sorted, as text: the hash is taken of these parts, in the order of the files. */
+function part(file, hashes) {
+    return JSON.stringify([file, hashes.sort()]);
+}
+/** What `merged` covers with what one more reach adds, the parts of the files it adds hashes to written again. */
+function combine(merged, reach) {
+    if (reach.byFile.size === 0)
+        return merged;
+    const byFile = new Map(merged.byFile);
+    const parts = new Map(merged.parts);
+    for (const [file, hashes] of reach.byFile) {
+        const all = [...(merged.byFile.get(file) ?? []), ...hashes];
+        parts.set(file, part(file, all));
+        byFile.set(file, all);
+    }
+    const files = [...new Set([...merged.files, ...reach.byFile.keys()])].sort();
+    return { files, byFile, parts };
+}
 /** Whether an identifier refers to a binding, rather than naming a property, a label or a member. */
 function isReference(key, parent) {
     switch (parent?.type) {
@@ -1360,6 +1395,12 @@ function literalIn(node, value) {
     }
     return null;
 }
+/** Where a JSON file writes a string, as `"./setup.js"`; null when it doesn't. */
+function jsonStringIn(text, value) {
+    const written = JSON.stringify(value);
+    const start = text.indexOf(written);
+    return start === -1 ? null : { start, end: start + written.length };
+}
 /**
  * The snapshot files the matchers of a test compare against, from the project root, at the runners' default places:
  * Vitest's `__snapshots__/<file>.snap`, paths given to `toMatchFileSnapshot()`, and browser screenshots in
@@ -1468,6 +1509,7 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
         ...runsWith.gaps.map((gap) => graph.gapUnit(gap)),
     ];
     const base = graph.reach([load, ...config]);
+    const baseMerged = combine(NOTHING_MERGED, base);
     // The describes around a test and the helper call that registers it are shared by the tests there, often thousands
     // for one helper call, so what they reach is walked once for all of them.
     const contexts = new Map();
@@ -1481,7 +1523,8 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
                 if (around.suite)
                     roots.push(...suiteUnit(around.suite));
             }
-            context = graph.reach(roots, [base]);
+            const reach = graph.reach(roots, [base]);
+            context = { reach, merged: combine(baseMerged, reach) };
             byCall.set(registeredBy, context);
         }
         return context;
@@ -1528,6 +1571,7 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
             needs.names.push(...scope.setupFixtures);
             needs.all ||= scope.takesAllFixtures;
         }
-        return graph.dependencies(roots, [base, contextOf(test.scope, test.registeredBy)], needs, snapshots, report);
+        const context = contextOf(test.scope, test.registeredBy);
+        return graph.dependencies(roots, [base, context.reach], context.merged, needs, snapshots, report);
     };
 }

package/dist/diagnostics.js

@@ -18,9 +18,11 @@ export const LEVELS = {
     'test-without-body': 'error',
     'describe-not-called': 'error',
     'async-describe': 'error',
+    'describe-throws': 'error',
     'nested-test': 'warning',
     'tag-without-at': 'error',
     'removed-api': 'error',
+    'invalid-fixture-argument': 'error',
     'only-in-skipped-describe': 'warning',
     'config-may-change-state': 'warning',
     'undefined-tag': 'error',
@@ -49,8 +51,21 @@ export const LEVELS = {
  * calls that throw while the file is collected.
  */
 export const REJECTS_FILE = {
-    playwright: new Set(['test-without-body', 'tag-without-at', 'invalid-chain', 'duplicate-title']),
+    playwright: new Set([
+        'test-without-body',
+        'tag-without-at',
+        'invalid-chain',
+        'duplicate-title',
+        'invalid-fixture-argument',
+    ]),
     vitest: new Set(['invalid-chain', 'removed-api', 'undefined-tag']),
+    jest: new Set(['invalid-chain', 'test-without-body', 'async-describe', 'describe-throws']),
+    mocha: new Set(['invalid-chain', 'test-without-body']),
+    jasmine: new Set(['invalid-chain', 'test-without-body', 'async-describe', 'describe-throws']),
+    cypress: new Set(['invalid-chain', 'test-without-body', 'describe-throws']),
+    webdriverio: new Set(['invalid-chain', 'test-without-body', 'async-describe', 'describe-throws']),
+    node: new Set(['invalid-chain']),
+    bun: new Set(['invalid-chain', 'test-without-body']),
 };
 export function toDiagnostic(problem, relativeFilePath, source, testId = null) {
     const position = problem.node && source ? source.position(problem.node.start) : null;

package/dist/extract.d.ts

@@ -53,6 +53,8 @@ export interface PendingSuite {
 }
 export interface PendingTest {
     scope: Scope;
+    /** The test whose body declares this one as a subtest; null for a test declared in the file or a describe. */
+    parent: PendingTest | null;
     declaration: TestDeclaration;
     call: CallExpression;
     /** For a test declared in an imported helper, the call in the scanned file that registers it; null otherwise. */

package/dist/extract.js

@@ -1,8 +1,7 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyName, returnValues, unwrap, } from "./ast.js";
-import { exportName } from "./frameworks/bindings.js";
+import { commonJsExport, exportName } from "./frameworks/bindings.js";
 import { problem, readCount } from "./frameworks/common.js";
 import { snippet, splitLines } from "./source.js";
-import { vitestCaseTitle } from "./case-titles.js";
 import { isScopeNode } from "./values.js";
 /** How many helpers deep a call is followed into the functions it calls, far more than real suites nest. */
 const MAX_DEPTH = 16;
@@ -363,14 +362,18 @@ class Walker {
                 return;
             case 'ForInStatement':
             case 'ForOfStatement': {
-                const values = leavesEarly(node.body) ? null : this.loopValues(node);
+                const leaves = leavesEarly(node.body);
+                const values = leaves ? null : this.loopValues(node);
                 const expands = values ? this.expands(node, values, context) : 'no';
                 if (values && expands === 'yes') {
                     this.expandLoop(node, values, context);
                     return;
                 }
+                // For `for...in`, the keys are what `Object.keys()` lists.
+                const listed = node.type === 'ForOfStatement' && !leaves ? node.right : null;
+                const count = values?.length ?? (listed ? this.frame.values.lengthOf(listed, this.scopes.slice(0, -1)) : null);
                 this.walkUnexpanded(node, expands === 'limit', () => {
-                    this.visitChildren(node, this.inLoop(context, values?.length ?? null));
+                    this.visitChildren(node, this.inLoop(context, count));
                 });
                 return;
             }
@@ -571,7 +574,8 @@ class Walker {
         const list = resolved.ok && Array.isArray(resolved.value) ? resolved.value : null;
         for (const arg of call.arguments) {
             if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
-                const values = leavesEarly(arg.body) ? null : list;
+                const leaves = leavesEarly(arg.body);
+                const values = leaves ? null : list;
                 const expands = values ? this.expands(null, values, context) : 'no';
                 if (values && expands === 'yes') {
                     // The callback gets each element, its index and the array.
@@ -583,8 +587,9 @@ class Walker {
                     }
                 }
                 else {
+                    const count = values?.length ?? (leaves ? null : this.frame.values.lengthOf(callee.object, this.scopes));
                     this.walkUnexpanded(call, expands === 'limit', () => {
-                        this.visitCallback(arg, this.inLoop(context, values?.length ?? null));
+                        this.visitCallback(arg, this.inLoop(context, count));
                     });
                 }
             }
@@ -692,9 +697,11 @@ class Walker {
                 context.test?.problems.push(...api.problems.map((item) => this.here(item)));
                 return true;
             case 'invalid': {
-                const afterLoad = context.test !== null || context.hookScope !== null || context.helper !== null;
+                // Code that runs after the file loads, or only when a condition holds, can't be sure to stop it loading.
+                const afterLoad = context.test !== null || context.hookScope !== null || context.helper !== null || context.isInCondition;
                 this.report(afterLoad ? { ...api.problem, afterLoad } : api.problem);
-                return api.declaration ? this.handle(call, api.declaration, context) : true;
+                // Under a condition, the call either never runs or fails the file, so it declares nothing either way.
+                return api.declaration && !context.isInCondition ? this.handle(call, api.declaration, context) : true;
             }
             case 'other':
                 return false;
@@ -710,11 +717,7 @@ class Walker {
         return this.functionIn(this.frame, name, scopes);
     }
     functionIn(frame, name, scopes) {
-        const declaration = frame.values.declarationOf(name, scopes);
-        if (declaration?.type === 'FunctionDeclaration')
-            return declaration;
-        const init = declaration?.type === 'VariableDeclarator' && declaration.init ? unwrap(declaration.init) : null;
-        return init?.type === 'ArrowFunctionExpression' || init?.type === 'FunctionExpression' ? init : null;
+        return frame.values.functionOf(name, scopes);
     }
     /**
      * Records a call to a function declared in the file. A call from the file or a describe returns the function, to be
@@ -793,11 +796,10 @@ class Walker {
     }
     /** The function a name imported from a local module stands for, in the file that writes it; null otherwise. */
     importedFunction(name, scopes, from = this.frame) {
-        const declaration = from.values.declarationOf(name, scopes);
         const source = from.values.importSource(name, scopes);
         if (source === null)
             return null;
-        const imported = declaration?.type === 'ImportSpecifier' ? exportName(declaration.imported) : 'default';
+        const imported = from.values.importedName(name, scopes);
         const frame = this.openFrom(from, source);
         return frame ? this.exportedFunction(frame, imported, new Set(), 0) : null;
     }
@@ -821,14 +823,18 @@ class Walker {
             return null;
         searched.add(key);
         const { program } = frame.parsed;
-        const local = (localName) => {
-            const fn = this.functionIn(frame, localName, [program]);
-            return fn ? { fn, frame } : null;
-        };
         const from = (source, exported) => {
             const module = this.openFrom(frame, source);
             return module ? this.exportedFunction(module, exported, searched, depth + 1) : null;
         };
+        const local = (localName) => {
+            const fn = this.functionIn(frame, localName, [program]);
+            if (fn)
+                return { fn, frame };
+            // A name the module imports and exports again, as `import helper from './a'; export { helper }`.
+            const source = frame.values.importSource(localName, [program]);
+            return source === null ? null : from(source, frame.values.importedName(localName, [program]));
+        };
         for (const statement of program.body) {
             if (statement.type === 'ExportDefaultDeclaration' && name === 'default') {
                 const declaration = statement.declaration;
@@ -857,7 +863,12 @@ class Walker {
                 return statement.source ? from(statement.source.value, localName) : local(localName);
             }
         }
-        return null;
+        // A CommonJS module: `module.exports = { registerSettlement }` or `exports.registerSettlement = function () {}`.
+        const commonJs = commonJsExport(program, name);
+        const value = commonJs ? unwrap(commonJs) : null;
+        if (value?.type === 'Identifier')
+            return local(value.name);
+        return isFunctionNode(value) ? { fn: value, frame } : null;
     }
     /**
      * Walks a function at one of its calls from the file or a describe, as the runner runs it there: with the scopes
@@ -946,6 +957,18 @@ class Walker {
      * called instead.
      */
     runSetting(call, api, context) {
+        if (api.fileWide) {
+            for (const item of api.problems)
+                this.report(item);
+            // Called by a function or while tests run, it changes only the tests that run after it.
+            if (context.declaredIn !== null || context.test || context.hookScope)
+                return;
+            const { settings, problems } = this.guardedRun(call, api.settings, api.argument, context.guards);
+            for (const item of problems)
+                this.report(item);
+            mergeRun(this.fileScope.details.run, settings);
+            return;
+        }
         if (context.declaredIn !== null && !context.test) {
             for (const item of api.problems)
                 this.report(item);
@@ -984,11 +1007,18 @@ class Walker {
                 conditions: own.map((condition) => joinConditions([...guards, ...(condition === null ? [] : [condition])])),
             };
         }
-        if (settings.timeout !== undefined && guard !== null) {
-            const message = `Option timeout: ${argument} is set only when ${guard}; it is not applied.`;
+        const unapplied = (key) => {
+            const message = `Option ${key}: ${argument} is set only when ${guard}; it is not applied.`;
             problems.push(problem('unresolved-option', call, message, snippet(this.text(call))));
+        };
+        if (settings.timeout !== undefined && guard !== null) {
+            unapplied('timeout');
             delete settings.timeout;
         }
+        if (settings.retry !== undefined && guard !== null) {
+            unapplied('retry');
+            delete settings.retry;
+        }
         return { settings, problems };
     }
     /** Run settings a helper sets when a test body or a `beforeEach` calls it, under the conditions around the call. */
@@ -1011,7 +1041,7 @@ class Walker {
     expectCall(call, test) {
         const callee = unwrap(call.callee);
         const [root, member] = callee.type === 'MemberExpression' ? [unwrap(callee.object), propertyName(callee)] : [callee, 'call'];
-        if (root.type !== 'Identifier' || root.name !== 'expect')
+        if (!this.isExpect(root))
             return;
         if (member === 'call' || member === 'soft' || member === 'poll' || member === 'element')
             test.expectCount += 1;
@@ -1026,6 +1056,20 @@ class Walker {
             test.problems.push(...problems.map((item) => this.here(item)));
         }
     }
+    /**
+     * Whether an expression is `expect`, or Playwright's `expect.configure(...)`, which gives an `expect` with other
+     * defaults, written in place or kept in a variable.
+     */
+    isExpect(expression) {
+        const node = unwrap(expression);
+        if (node.type === 'Identifier') {
+            if (node.name === 'expect')
+                return true;
+            const declaration = this.frame.values.declarationOf(node.name, this.scopes);
+            return declaration?.type === 'VariableDeclarator' && declaration.init !== null && isConfigured(declaration.init);
+        }
+        return isConfigured(node);
+    }
     /** Reports a problem not tied to a test, once, however many times a function with it is walked. */
     report(found) {
         const item = this.here(found);
@@ -1167,14 +1211,20 @@ class Walker {
             test.problems.push(problem('test-in-function', test.call, `The test is declared in a function, and ${why}. The runner registers the test at each call of the function, in the describe around the call; it is listed once, where it is written.`));
         }
     }
-    nested(call, context) {
+    nested(call, context, isTest) {
         if (!context.test && !context.hookScope)
             return false;
-        this.report(problem('nested-test', call, 'A test or describe declared inside a test or hook body is not collected by the runner, so it is not listed.', snippet(this.frame.parsed.source.slice(call.start, call.end))));
+        const inTest = context.test !== null && !context.hookScope && this.frame.adapter.nestsTests === true;
+        if (isTest && inTest)
+            return false;
+        const message = inTest
+            ? 'A describe declared inside a test body runs as a nested describe of the test, but the scan does not list it or its tests.'
+            : 'A test or describe declared inside a test or hook body is not collected by the runner, so it is not listed.';
+        this.report(problem('nested-test', call, message, snippet(this.frame.parsed.source.slice(call.start, call.end))));
         return true;
     }
     declareTest(call, declaration, context) {
-        if (context.quiet || this.nested(call, context))
+        if (context.quiet || this.nested(call, context, true))
             return;
         for (const item of this.cases(declaration, call, context))
             this.declareCase(call, item, context);
@@ -1198,9 +1248,9 @@ class Walker {
         const title = declaration.title;
         if (!title || title.isDynamic)
             return single("the scan can't work out the title");
-        const titles = declaration.cases.map((item, index) => vitestCaseTitle(title.text, item.items, index, this.options.version));
+        const titles = declaration.cases.map((item) => item.title);
         if (titles.some((text) => text === null)) {
-            return single("the title shows an array or object, which the scan doesn't format the way Vitest does");
+            return single("the title shows a value the scan doesn't format the way the runner does");
         }
         if (declaration.kind === 'describe' && this.expands(null, declaration.cases, context) === 'limit') {
             return single(`expanding it would take the file past ${MAX_EXPANDED.toLocaleString('en-US')} loop passes and describe cases`);
@@ -1220,6 +1270,7 @@ class Walker {
         const empty = emptyTitle(declaration, call);
         const test = {
             scope: context.scope,
+            parent: context.test,
             declaration,
             call,
             site: this.site,
@@ -1275,7 +1326,7 @@ class Walker {
             walk();
     }
     declareSuite(call, declaration, context) {
-        if (context.quiet || this.nested(call, context))
+        if (context.quiet || this.nested(call, context, false))
             return;
         for (const item of this.cases(declaration, call, context))
             this.declareSuiteCase(call, item, context);
@@ -1370,3 +1421,12 @@ class Walker {
 export function extract(main, openModule, options = { expandCases: false, version: null }) {
     return new Walker(main, openModule, options).run();
 }
+/** Whether an expression is a call of `expect.configure()`. */
+function isConfigured(expression) {
+    const node = unwrap(expression);
+    const callee = node.type === 'CallExpression' ? unwrap(node.callee) : null;
+    if (callee?.type !== 'MemberExpression' || propertyName(callee) !== 'configure')
+        return false;
+    const object = unwrap(callee.object);
+    return object.type === 'Identifier' && object.name === 'expect';
+}

package/dist/files.js

@@ -82,8 +82,10 @@ export async function findFiles(root, patterns, ignore, framework, platform = pr
         const absolutePath = path.resolve(root, match);
         const realPath = realpathSync(absolutePath);
         const linked = realPath !== path.join(realRoot, match);
-        if (linked && framework === 'playwright') {
-            diagnostics.push(fileDiagnostic('symlink-ignored', match, 'The file is reached through a symbolic link, which Playwright does not follow.'));
+        // Vitest and Mocha load a file through a link; Node.js loads it once, by its real path.
+        if (linked && framework !== 'vitest' && framework !== 'mocha') {
+            const name = framework === 'jest' ? 'Jest' : 'Playwright';
+            diagnostics.push(fileDiagnostic('symlink-ignored', match, `The file is reached through a symbolic link, which ${name} does not follow.`));
             continue;
         }
         candidates.push({ absolutePath, relativeFilePath: match, realPath, linked });

package/dist/filter.js

@@ -18,6 +18,7 @@ const TEST_KEYS = Object.keys({
     dependencies: true,
     hasUnfollowedDependencies: true,
     suiteId: true,
+    parentTestId: true,
     suitePath: true,
     relativeFilePath: true,
     fileName: true,

package/dist/framework-version.d.ts

@@ -1,6 +1,8 @@
 import type { Framework } from './types.ts';
-/** Oldest supported version of each framework. */
-export declare const OLDEST: Record<Framework, [number, number]>;
+/** Each framework's name in messages. */
+export declare const FRAMEWORK_NAMES: Record<Framework, string>;
+/** Oldest supported version of each framework, as major, minor and for Bun, whose 1.2.23 changed how it runs tests, patch. */
+export declare const OLDEST: Record<Framework, number[]>;
 /** Where the framework version came from. */
 export interface DetectedVersion {
     version: string;
@@ -9,6 +11,8 @@ export interface DetectedVersion {
     /** Only a range is known, such as `^4.0.0`; `version` is its lowest version. */
     range: string | null;
 }
+/** The root, then each folder above it, as a monorepo package's dependencies may be installed or locked higher up. */
+export declare function folders(root: string): string[];
 /**
  * The framework version from the installed package, then a lockfile, then package.json, each looked for in the root
  * and the folders above it. A version range, as in `^4.0.0`, is used only when nothing else is found. When none of
@@ -16,3 +20,10 @@ export interface DetectedVersion {
  * below the root that declares it and holds one of the scanned `files` is read the same way, from its own folder up.
  */
 export declare function detectFrameworkVersion(root: string, framework: Framework, files: readonly string[]): DetectedVersion | null;
+/**
+ * The runner a project uses, for a scan without `framework`: the one whose package a package.json in the root or a
+ * folder below it, outside `ignore`, lists, or whose config is there. Only when none is found there do the package.json files above the
+ * root count, as a monorepo may declare its runner once at its top. Throws an `OptionsError` when the project uses
+ * none of them or several, naming what it found.
+ */
+export declare function detectFramework(root: string, ignore: readonly string[]): Framework;