test-inventory 0.1.2 → 0.2.1

package/dist/files.d.ts

@@ -12,7 +12,7 @@ export interface FoundFile {
  * left out for Playwright, which doesn't follow them, and read once for Vitest, which does, from the file's own path
  * when it matches too.
  */
-export declare function findFiles(root: string, patterns: string[], ignore: string[], framework: Framework): Promise<{
+export declare function findFiles(root: string, patterns: string[], ignore: string[], framework: Framework, platform?: NodeJS.Platform): Promise<{
     files: FoundFile[];
     diagnostics: Diagnostic[];
 }>;

package/dist/files.js

@@ -43,12 +43,14 @@ function recordingFs(failures) {
  * left out for Playwright, which doesn't follow them, and read once for Vitest, which does, from the file's own path
  * when it matches too.
  */
-export async function findFiles(root, patterns, ignore, framework) {
+export async function findFiles(root, patterns, ignore, framework, platform = process.platform) {
     const failures = [];
     // Only files match; a folder named like a test file, such as a screenshot folder `checkout.spec.ts/`, is not expanded.
-    const matches = await glob(patterns.map((pattern) => normalizePattern(pattern)), {
+    // As in both runners, names that start with a dot match too, as in `.storybook/`.
+    const matches = await glob(patterns.map((pattern) => normalizePattern(pattern, platform)), {
         cwd: root,
-        ignore: ['**/node_modules/**', ...ignore.map((pattern) => normalizePattern(pattern))],
+        dot: true,
+        ignore: ['**/node_modules/**', '**/.git/**', ...ignore.map((pattern) => normalizePattern(pattern, platform))],
         onlyFiles: true,
         expandDirectories: false,
         fs: recordingFs(failures),

package/dist/frameworks/bindings.d.ts

@@ -1,5 +1,6 @@
 import type { Expression, ModuleExportName, Node, Program, VariableDeclarator } from 'oxc-parser';
-import type { ModuleReader, Problem } from '../model.ts';
+import type { ModuleReader, ModuleSource, Problem } from '../model.ts';
+import { type ParsedFile } from '../parse.ts';
 import { type FileContext } from './common.ts';
 /** A name imported from a module other than the framework, which may be a custom `test` object in a fixtures file. */
 export interface ModuleImport {
@@ -26,26 +27,33 @@ export declare function requiredModule(expression: Expression): string | null;
 export declare function bindAll(declarators: VariableDeclarator[], bind: (declarator: VariableDeclarator) => boolean): void;
 /** Whether a module exports `name` as a test object. */
 export declare function exportsTestObject(program: Program, name: string, objects: TestObjects): boolean;
-/** Whether a module re-exports `name` from another module, which the scan does not follow. */
-export declare function reexportsFromModule(program: Program, name: string, isFramework: (source: string) => boolean): boolean;
-/**
- * Whether a module exports `name` as a value built from something imported from another module, directly or through
- * its own variables, as in `const test = baseTest.extend({...})` and then `export const browserTest = test`.
- */
-export declare function buildsFromModule(program: Program, name: string, isFramework: (source: string) => boolean): boolean;
-/** Whether a module imports or requires any of the given sources. */
+/** Whether a module imports, re-exports or requires any of the given sources. */
 export declare function importsFrom(program: Program, matches: (source: string) => boolean): boolean;
+/** Whether a name a module imports from another module is a test object there, which follows that module in turn. */
+export type FollowImport = (source: string, imported: string) => boolean;
 /** How a framework recognizes the modules and test objects of a followed file. */
 export interface Framework {
     name: string;
     isSource: (source: string) => boolean;
-    testObjects: (program: Program) => TestObjects;
+    /** The test objects of a followed module, which uses `follow` for the names it imports from other modules. */
+    testObjects: (program: Program, follow: FollowImport) => TestObjects;
 }
+/** Shared with the walk of imported helpers, so that a module both read and walked is parsed once. */
+export declare function parseModule(module: ModuleSource): ParsedFile;
 /**
- * Follows one import to see whether the module exports a test object. Only one level is followed. A module that has
- * nothing to do with the framework is not reported: the call only looked like a test.
+ * Whether `name` from `source` is a test object, following the module through the modules it re-exports from or builds
+ * on, as deep as it takes. When it isn't, the reason says where the chain ends; it is null for a module that has
+ * nothing to do with the framework, as when a call only looked like a test. Each module is followed once for a name,
+ * however many imports lead to it, as fixtures files that build on several others share their bases.
  */
+export declare function followModule(source: string, name: string, readModule: ModuleReader | null, framework: Framework, path?: readonly string[], followed?: Map<string, Followed>): Followed;
+interface Followed {
+    exported: boolean;
+    reason: string | null;
+}
+/** Follows the import of `name` in a test file, with the diagnostic to report when it isn't a test object. */
 export declare function followImport(name: string, imported: ModuleImport, readModule: ModuleReader | null, file: FileContext, framework: Framework): {
     exported: boolean;
     problem: Problem | null;
 };
+export {};

package/dist/frameworks/bindings.js

@@ -81,95 +81,142 @@ export function bindAll(declarators, bind) {
 }
 /** Whether a module exports `name` as a test object. */
 export function exportsTestObject(program, name, objects) {
+    const own = ownExport(program, name);
+    switch (own?.kind) {
+        case 'default':
+            return objects.isTestObject(own.value);
+        case 'variable':
+            return objects.isTestName(name);
+        case 'function':
+            return false;
+        case 'specifier':
+            return own.source === null ? objects.isTestName(own.local) : objects.reexports(own.source, own.local);
+    }
+    return program.body.some((statement) => {
+        const source = starReexport(statement);
+        return source !== null && objects.reexports(source, name);
+    });
+}
+/**
+ * The module's own export of `name`; null when it has none and only `export *` may pass the name on. An own export
+ * wins over those, as in JavaScript.
+ */
+function ownExport(program, name) {
     for (const statement of program.body) {
-        switch (statement.type) {
-            case 'ExportNamedDeclaration':
-                if (statement.declaration?.type === 'VariableDeclaration') {
-                    for (const declarator of statement.declaration.declarations) {
-                        if (declarator.id.type === 'Identifier' && declarator.id.name === name) {
-                            return objects.isTestName(name);
-                        }
-                    }
-                }
-                for (const specifier of statement.specifiers) {
-                    if (exportName(specifier.exported) !== name)
-                        continue;
-                    const local = exportName(specifier.local);
-                    return statement.source ? objects.reexports(statement.source.value, local) : objects.isTestName(local);
-                }
-                break;
-            case 'ExportDefaultDeclaration':
-                if (name === 'default')
-                    return objects.isTestObject(statement.declaration);
-                break;
-            case 'ExportAllDeclaration':
-                if (!statement.exported && objects.reexports(statement.source.value, name))
-                    return true;
-                break;
-            case 'ExpressionStatement': {
-                const source = commonJsReexport(statement);
-                if (source !== null && objects.reexports(source, name))
-                    return true;
-                break;
-            }
+        if (statement.type === 'ExportDefaultDeclaration' && name === 'default') {
+            return { kind: 'default', value: statement.declaration };
+        }
+        if (statement.type !== 'ExportNamedDeclaration')
+            continue;
+        const { declaration } = statement;
+        if (declaration?.type === 'VariableDeclaration') {
+            const declared = declaration.declarations.some((item) => item.id.type === 'Identifier' && item.id.name === name);
+            if (declared)
+                return { kind: 'variable' };
+        }
+        const named = declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration';
+        if (named && declaration.id?.name === name)
+            return { kind: 'function' };
+        for (const specifier of statement.specifiers) {
+            if (exportName(specifier.exported) !== name)
+                continue;
+            return { kind: 'specifier', local: exportName(specifier.local), source: statement.source?.value ?? null };
         }
     }
-    return false;
+    return null;
 }
-/** Whether a module re-exports `name` from another module, which the scan does not follow. */
-export function reexportsFromModule(program, name, isFramework) {
-    const imported = moduleImports(program, isFramework);
-    return program.body.some((statement) => {
-        const required = commonJsReexport(statement);
-        if (required !== null)
-            return !isFramework(required);
-        if (statement.type === 'ExportAllDeclaration')
-            return !statement.exported && !isFramework(statement.source.value);
-        if (statement.type !== 'ExportNamedDeclaration')
-            return false;
-        // `export { test } from './fixtures'`, or `import { test } from './fixtures'` and then `export { test }`.
-        const fromModule = (local) => statement.source ? !isFramework(statement.source.value) : imported.has(local);
-        return statement.specifiers.some((specifier) => exportName(specifier.exported) === name && fromModule(exportName(specifier.local)));
-    });
+/** The module `export * from 'module'` or `module.exports = require('module')` passes every name on from; or null. */
+function starReexport(statement) {
+    if (statement.type === 'ExportAllDeclaration')
+        return statement.exported ? null : statement.source.value;
+    return commonJsReexport(statement);
 }
 /**
- * Whether a module exports `name` as a value built from something imported from another module, directly or through
- * its own variables, as in `const test = baseTest.extend({...})` and then `export const browserTest = test`.
+ * The module and name a module's export comes from when it re-exports it, as in `export { test } from './base'`, or
+ * builds it from something imported, directly or through its own variables, as in `const test = base.extend({...})`.
  */
-export function buildsFromModule(program, name, isFramework) {
+function importOrigin(program, name, isFramework) {
     const imported = moduleImports(program, isFramework);
+    const own = ownExport(program, name);
+    if (own === null) {
+        for (const statement of program.body) {
+            const source = starReexport(statement);
+            if (source !== null && !isFramework(source))
+                return { source, imported: name, how: 're-exports' };
+        }
+    }
+    else if (own.kind === 'specifier') {
+        // `export { test } from './fixtures'`, or `import { test } from './fixtures'` and then `export { test }`.
+        const from = own.source === null ? imported.get(own.local) : { source: own.source, imported: own.local };
+        if (from && !isFramework(from.source))
+            return { source: from.source, imported: from.imported, how: 're-exports' };
+    }
     const values = new Map();
     for (const declarator of topLevelDeclarators(program)) {
         if (declarator.id.type === 'Identifier' && declarator.init)
             values.set(declarator.id.name, declarator.init);
     }
     const seen = new Set();
-    const builtFromImport = (local) => {
+    // The import a local name is, or is built from: the object `extend` is called on, the test objects a call such as
+    // `mergeTests(a, b)` combines, either side of `?:`, or another local name. Values only passed along, such as a
+    // fixtures object in `base.extend(fixtures)`, are not what the test object is built on.
+    const builtFrom = (local) => {
         const value = values.get(local);
-        if (!value || seen.has(local))
-            return false;
+        if (imported.has(local) || !value || seen.has(local))
+            return imported.get(local) ?? null;
         seen.add(local);
-        return usesImport(value);
+        return builtOn(value);
+    };
+    const builtOn = (node) => {
+        const expression = unwrap(node);
+        switch (expression.type) {
+            case 'Identifier':
+                return builtFrom(expression.name);
+            case 'MemberExpression':
+                return builtOn(expression.object);
+            case 'ConditionalExpression':
+                return builtOn(expression.consequent) ?? builtOn(expression.alternate);
+            case 'CallExpression': {
+                const callee = unwrap(expression.callee);
+                if (callee.type === 'MemberExpression' && propertyName(callee) === 'extend')
+                    return builtOn(callee.object);
+                for (const argument of expression.arguments) {
+                    const found = argument.type === 'SpreadElement' ? null : builtOn(argument);
+                    if (found)
+                        return found;
+                }
+                return null;
+            }
+            default:
+                return null;
+        }
     };
-    const usesImport = (node) => (node.type === 'Identifier' && (imported.has(node.name) || builtFromImport(node.name))) ||
-        childNodes(node).some(usesImport);
     // `export { test as browserTest }` exports a variable under another name.
     const locals = program.body.flatMap((statement) => statement.type === 'ExportNamedDeclaration' && !statement.source
         ? statement.specifiers.filter((item) => exportName(item.exported) === name).map((item) => exportName(item.local))
         : []);
-    return [name, ...locals].some(builtFromImport);
+    for (const local of [name, ...locals]) {
+        const found = values.has(local) ? builtFrom(local) : null;
+        if (found)
+            return { source: found.source, imported: found.imported, how: 'builds' };
+    }
+    return null;
 }
-/** Whether a module imports or requires any of the given sources. */
+/** Whether a module imports, re-exports or requires any of the given sources. */
 export function importsFrom(program, matches) {
     const requires = (node) => {
         const source = node.type === 'CallExpression' ? requiredModule(node) : null;
         return (source !== null && matches(source)) || childNodes(node).some(requires);
     };
-    return program.body.some((statement) => (statement.type === 'ImportDeclaration' && matches(statement.source.value)) || requires(statement));
+    return program.body.some((statement) => ((statement.type === 'ImportDeclaration' || statement.type === 'ExportAllDeclaration') &&
+        matches(statement.source.value)) ||
+        (statement.type === 'ExportNamedDeclaration' && statement.source !== null && matches(statement.source.value)) ||
+        requires(statement));
 }
 /** Parsed modules, kept while their source is, so that a fixtures file many tests import is parsed once. */
 const parsedModules = new WeakMap();
-function parseModule(module) {
+/** Shared with the walk of imported helpers, so that a module both read and walked is parsed once. */
+export function parseModule(module) {
     let parsed = parsedModules.get(module);
     if (!parsed) {
         parsed = parseFile(module.relativeFilePath, module.code);
@@ -177,31 +224,53 @@ function parseModule(module) {
     }
     return parsed;
 }
+/** How many modules deep an import is followed, far more than real fixture chains need. */
+const MAX_DEPTH = 16;
 /**
- * Follows one import to see whether the module exports a test object. Only one level is followed. A module that has
- * nothing to do with the framework is not reported: the call only looked like a test.
+ * Whether `name` from `source` is a test object, following the module through the modules it re-exports from or builds
+ * on, as deep as it takes. When it isn't, the reason says where the chain ends; it is null for a module that has
+ * nothing to do with the framework, as when a call only looked like a test. Each module is followed once for a name,
+ * however many imports lead to it, as fixtures files that build on several others share their bases.
  */
-export function followImport(name, imported, readModule, file, framework) {
-    const unresolved = (reason) => problem('unresolved-test-import', imported.node, `'${name}' is imported from '${imported.source}', which ${reason}; tests that use it are missing.`, snippet(text(file, imported.node)));
+export function followModule(source, name, readModule, framework, path = [], followed = new Map()) {
     // Without a reader, as in scanSource, nothing can be read.
-    const module = readModule ? readModule(imported.source) : { reason: 'could not be read' };
+    const module = readModule ? readModule(source) : { reason: 'could not be read' };
     if ('reason' in module)
-        return { exported: false, problem: unresolved(module.reason) };
+        return { exported: false, reason: module.reason };
+    if (path.includes(module.relativeFilePath))
+        return { exported: false, reason: 'imports it back, in a cycle' };
+    if (path.length >= MAX_DEPTH)
+        return { exported: false, reason: `is more than ${MAX_DEPTH} modules deep` };
+    const key = `${module.relativeFilePath}\0${name}`;
+    let result = followed.get(key);
+    if (!result) {
+        result = followExports(module, name, framework, [...path, module.relativeFilePath], followed);
+        followed.set(key, result);
+    }
+    return result;
+}
+/** Whether a module exports `name` as a test object; `within` is the chain of modules followed to it, itself last. */
+function followExports(module, name, framework, within, followed) {
     const { program, error } = parseModule(module);
     if (error)
-        return { exported: false, problem: unresolved('could not be parsed') };
-    if (exportsTestObject(program, imported.imported, framework.testObjects(program))) {
-        return { exported: true, problem: null };
+        return { exported: false, reason: 'could not be parsed' };
+    const followFrom = (from, imported) => followModule(from, imported, module.readModule, framework, within, followed);
+    const objects = framework.testObjects(program, (from, imported) => followFrom(from, imported).exported);
+    if (exportsTestObject(program, name, objects))
+        return { exported: true, reason: null };
+    const unrecognized = `does not export a ${framework.name} test object that could be recognized`;
+    const origin = importOrigin(program, name, framework.isSource);
+    if (origin) {
+        const end = followFrom(origin.source, origin.imported).reason ?? unrecognized;
+        return { exported: false, reason: `${origin.how} it from '${origin.source}', which ${end}` };
     }
-    let reason = null;
-    if (reexportsFromModule(program, imported.imported, framework.isSource)) {
-        reason = 're-exports it from another module, which is not followed';
-    }
-    else if (buildsFromModule(program, imported.imported, framework.isSource)) {
-        reason = 'builds it from another module, which is not followed';
-    }
-    else if (importsFrom(program, framework.isSource)) {
-        reason = `does not export a ${framework.name} test object that could be recognized`;
-    }
-    return { exported: false, problem: reason ? unresolved(reason) : null };
+    return { exported: false, reason: importsFrom(program, framework.isSource) ? unrecognized : null };
+}
+/** Follows the import of `name` in a test file, with the diagnostic to report when it isn't a test object. */
+export function followImport(name, imported, readModule, file, framework) {
+    const { exported, reason } = followModule(imported.source, imported.imported, readModule, framework);
+    const problemFound = reason
+        ? problem('unresolved-test-import', imported.node, `'${name}' is imported from '${imported.source}', which ${reason}; tests that use it are missing.`, snippet(text(file, imported.node)))
+        : null;
+    return { exported, problem: problemFound };
 }

package/dist/frameworks/common.d.ts

@@ -1,6 +1,6 @@
-import type { Argument, Expression, Node, StringLiteral, TemplateLiteral, VariableDeclarator } from 'oxc-parser';
+import type { Argument, CallExpression, Expression, Node, StringLiteral, TemplateLiteral, VariableDeclarator } from 'oxc-parser';
 import { type FunctionNode } from '../ast.ts';
-import type { Condition, Problem, Span, Title } from '../model.ts';
+import type { Condition, Problem, Returns, Span, Title } from '../model.ts';
 import { type SourceText } from '../source.ts';
 import type { DiagnosticCode } from '../types.ts';
 import { type Resolved, type Values } from '../values.ts';
@@ -46,6 +46,16 @@ export declare function mayHoldTestObject(declarator: VariableDeclarator): decla
  * called like one. The call that creates it can't be followed, so its calls are read as tests on trust.
  */
 export declare function localTestObject(file: FileContext, name: string, declarator: CreatedDeclarator): Problem;
+/**
+ * A warning for a call shaped like a test on what a function named like a test object returns, as in
+ * `conditionalTest({ min: 22 })('title', fn)`, when the function can't be found. What it returns is read on trust.
+ */
+export declare function returnedTestObject(file: FileContext, call: CallExpression): Problem;
+/**
+ * The test or describe function a function returns, in the adapter's terms: what all its values have in common, as
+ * `shared` combines two; null when it may return something else.
+ */
+export declare function returnedFunction<T>(returns: Returns, shared: (a: T | null, b: T | null) => T | null): T | null;
 /**
  * Whether a call on a name imported from a local file is shaped like a test declaration, `name('title', fn)`, and
  * so worth following to see if the name is a custom test object.

package/dist/frameworks/common.js

@@ -80,6 +80,24 @@ export function localTestObject(file, name, declarator) {
     const created = snippet(text(file, declarator.init));
     return problem('local-test-object', declarator, `'${name}' is created by ${created}, which is not followed; calls shaped like tests are read as tests.`, created);
 }
+/**
+ * A warning for a call shaped like a test on what a function named like a test object returns, as in
+ * `conditionalTest({ min: 22 })('title', fn)`, when the function can't be found. What it returns is read on trust.
+ */
+export function returnedTestObject(file, call) {
+    const created = snippet(text(file, call));
+    return problem('local-test-object', call, `What ${created} returns is not followed; calls on it shaped like tests are read as tests.`, created);
+}
+/**
+ * The test or describe function a function returns, in the adapter's terms: what all its values have in common, as
+ * `shared` combines two; null when it may return something else.
+ */
+export function returnedFunction(returns, shared) {
+    if (!returns.values)
+        return null;
+    const found = returns.values.map(({ expression, scopes }) => returns.adapter.testFunction(expression, scopes));
+    return found.slice(1).reduce(shared, found[0]);
+}
 /** A title written as a string, a template, or text joined to one, as in `'cycles through ' + venue`. */
 function isTitleShaped(node) {
     if (node?.type === 'BinaryExpression' && node.operator === '+') {
@@ -93,8 +111,12 @@ function isTitleShaped(node) {
  */
 export function looksLikeDeclaration(args) {
     const last = args.at(-1);
-    // The body is the last argument: a function, or a function passed by name.
-    const body = isFunctionNode(last) || last?.type === 'Identifier' || last?.type === 'MemberExpression';
+    // The body is the last argument, a function or a function passed by name, or a function before a timeout, as in
+    // Vitest's `test('title', fn, 30_000)`.
+    const body = isFunctionNode(last) ||
+        last?.type === 'Identifier' ||
+        last?.type === 'MemberExpression' ||
+        (args.length === 3 && isFunctionNode(args[1]));
     return isTitleShaped(args.at(0)) && args.length >= 2 && args.length <= 3 && body;
 }
 /**

package/dist/frameworks/playwright.d.ts

@@ -1,4 +1,4 @@
-import type { CallExpression, Program } from 'oxc-parser';
+import type { CallExpression, Expression, Node, Program } from 'oxc-parser';
 import type { Adapter, ApiCall, CallContext, ModuleReader, Problem } from '../model.ts';
 import { type FileContext } from './common.ts';
 export declare class PlaywrightAdapter implements Adapter {
@@ -11,6 +11,7 @@ export declare class PlaywrightAdapter implements Adapter {
     private readonly imports;
     private readonly followed;
     private readonly reported;
+    /** Variables and names of functions read as test objects on trust, each reported once. */
     private readonly assumed;
     private readonly aliases;
     constructor(program: Program, file: FileContext, readModule: ModuleReader | null);
@@ -20,12 +21,30 @@ export declare class PlaywrightAdapter implements Adapter {
      * can't be followed is reported only outside test and hook bodies, where a call can declare tests.
      */
     private testLinks;
+    private linksFromTest;
+    /**
+     * The members of `test` a call returns: none for a test object, as `conditionalTest({ min: 22 })` may return, or
+     * those of a describe function. As for a variable chosen by a condition, only the members all its values have apply.
+     * When the function can't be found, a call named like a test object is read as one on trust, with a warning.
+     */
+    private returned;
+    testFunction(expression: Expression, scopes: readonly Node[]): string[] | null;
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     private assumeLocal;
     private looksLikeTest;
-    /** The members of `test` a variable holds a describe function from, as in `const serialDescribe = test.describe.serial`. */
-    private describeAlias;
-    private describeMembers;
+    /**
+     * Whether a call through an imported name is worth following to the module: shaped like a test, or any call with a
+     * title and a body through a name that reads like a test function, as `it.effect('title', fn)` on a test object that
+     * a package extends.
+     */
+    private worthFollowing;
+    /**
+     * The members of `test` a variable holds: those of a describe function, as in `const serialDescribe =
+     * test.describe.serial`, or none for a test object a function returns.
+     */
+    private alias;
+    /** The members of `test` a value holds: none for a test object, or those of a describe function. */
+    private members;
     /** Follows the import of `name` once, and reports it once when it can't be followed and `report` is set. */
     private follow;
     /** Whether an argument is, or works out to, a string, as a title is. Spread arguments are handled before. */