test-inventory 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # test-inventory
 
+## 0.2.1
+
+### Patch Changes
+
+- [#28](https://github.com/Huldoser/test-inventory/pull/28) [`04ff6d2`](https://github.com/Huldoser/test-inventory/commit/04ff6d2dd5a7ecc8fabffbf16b259fc9f2a68110) - A skip in a `catch` block, such as `context.skip()` when a test server can't start, is conditional, with the `catch` clause as its condition, as in `catch (error)`. It was recorded as an unconditional skip before. A test declared in a `catch` block gets `isInCondition: true`.
+
+- [#32](https://github.com/Huldoser/test-inventory/pull/32) [`3fcc933`](https://github.com/Huldoser/test-inventory/commit/3fcc93368dc9a4d810ff52b8d7d5fe4f99ca63ee) - Globs match folders and files whose names start with a dot, as in `.storybook/` or `.github/scripts/`, as they do in Playwright and Vitest; test files there were left out before. `.git` folders are always left out, like `node_modules`.
+
+- [#31](https://github.com/Huldoser/test-inventory/pull/31) [`631cc6b`](https://github.com/Huldoser/test-inventory/commit/631cc6b208aca5b28076da6eba33d8e6426ab778) - Workspace packages are found from both `pnpm-workspace.yaml` and the `workspaces` of `package.json`. When a repository had both, as after a move to pnpm that kept the old list, only `package.json` was read, and a package listed only in `pnpm-workspace.yaml` got an `unresolved-test-import` error.
+
+- [#30](https://github.com/Huldoser/test-inventory/pull/30) [`968e2bc`](https://github.com/Huldoser/test-inventory/commit/968e2bcd15c2157faae8fe91604634b1c1f68175) - A call through an imported name that reads like a test function is followed, and reported with `unresolved-test-import` when it can't be, also when it goes through a member the scan doesn't know, as in `it.effect('title', fn)` from `@effect/vitest`, or passes a timeout after the body, as in `test('title', fn, 60_000)`. Such tests were missing before, with no diagnostic. A module's own export of a name now wins over the same name passed on by `export *`, as in JavaScript: `export const it = ...` next to `export * from 'vitest'` is no longer read as Vitest's `it`.
+
+- [#28](https://github.com/Huldoser/test-inventory/pull/28) [`04ff6d2`](https://github.com/Huldoser/test-inventory/commit/04ff6d2dd5a7ecc8fabffbf16b259fc9f2a68110) - Tests on a test object that a function returns are found, as in `conditionalTest({ min: 22 })('title', fn)` or `const quoteTest = onNode(22)`, when the function is declared in the file or imported from a local file. They were missing before, with no diagnostic. When the function returns a different test function on different runs, as `it.skip` or `it`, only the modifiers they all have apply, as for a variable chosen by a condition. When the function can't be followed and its name reads like a test object, as for one from an installed package, the calls on what it returns are read as tests on trust, with a `local-test-object` warning.
+
 ## 0.2.0
 
 ### Minor Changes

package/dist/extract.js

@@ -80,6 +80,8 @@ class Walker {
     callsWalked = 0;
     /** Problems already reported, since a function walked at several calls finds the same ones each time. */
     reported = new Set();
+    /** What the functions named in calls such as `onNode(22)('title', fn)` return, by the declaration of each name. */
+    returns = new Map();
     /** For each file's program, the scopes around each function in it. */
     scopeChains = new Map();
     constructor(main, openModule) {
@@ -178,6 +180,14 @@ class Walker {
                 this.visit(node.right, this.guarded(context, guard));
                 return;
             }
+            case 'TryStatement':
+                this.visit(node.block, context);
+                // A `catch` block runs only when the `try` block throws, as when a test server can't start.
+                if (node.handler)
+                    this.visit(node.handler, this.guarded(context, this.catchCondition(node.handler)));
+                if (node.finalizer)
+                    this.visit(node.finalizer, context);
+                return;
             case 'SwitchStatement': {
                 const discriminant = this.text(node.discriminant);
                 const values = node.cases.flatMap((switchCase) => (switchCase.test ? [this.text(switchCase.test)] : []));
@@ -241,6 +251,10 @@ class Walker {
             inBody: context.test !== null || context.hookScope !== null,
         };
     }
+    /** A `catch` block's condition, written as its clause: `catch` or `catch (error)`. */
+    catchCondition(handler) {
+        return this.text({ start: handler.start, end: handler.body.start }).trim();
+    }
     guarded(context, guard) {
         return { ...context, isInCondition: true, guards: guard === null ? context.guards : [...context.guards, guard] };
     }
@@ -280,6 +294,7 @@ class Walker {
             testContext: context.testContext,
             inTest: context.test !== null,
             inBody: context.test !== null || context.hookScope !== null,
+            returnsOf: (name, scopes) => this.returnsOf(name, scopes),
         });
         if (!api)
             return false;
@@ -379,7 +394,7 @@ class Walker {
         const fn = this.functionNamed(callee.name, this.scopes);
         if (!fn) {
             const runsHere = !context.test && !context.hookScope && !context.helper;
-            const imported = runsHere && this.callStack.length < MAX_DEPTH ? this.importedFunction(callee.name) : null;
+            const imported = runsHere && this.callStack.length < MAX_DEPTH ? this.importedFunction(callee.name, this.scopes) : null;
             return imported && !this.callStack.includes(imported.fn) ? this.withinLimit(imported, call) : null;
         }
         const sites = this.callSites.get(fn) ?? new Map();
@@ -414,10 +429,30 @@ class Walker {
         }
         return null;
     }
+    /**
+     * What a function declared in the file being walked, or imported from a local module, returns; null otherwise. Each
+     * declaration is looked up once, however many calls use it.
+     */
+    returnsOf(name, scopes) {
+        const declaration = this.frame.values.declarationOf(name, scopes);
+        if (declaration === null)
+            return null;
+        if (!this.returns.has(declaration)) {
+            const local = this.functionNamed(name, scopes);
+            const callee = local ? { fn: local, frame: this.frame } : this.importedFunction(name, scopes);
+            this.returns.set(declaration, callee && this.returnsIn(callee));
+        }
+        return this.returns.get(declaration) ?? null;
+    }
+    returnsIn({ fn, frame }) {
+        // An async function returns a promise, and a generator an iterator, whatever their `return` says.
+        const values = fn.async || fn.generator ? null : returnValues(fn, [...this.scopeChain(fn, frame), fn]);
+        return { adapter: frame.adapter, values };
+    }
     /** The function a name imported from a local module stands for, in the file that writes it; null otherwise. */
-    importedFunction(name) {
-        const declaration = this.frame.values.declarationOf(name, this.scopes);
-        const source = this.frame.values.importSource(name, this.scopes);
+    importedFunction(name, scopes) {
+        const declaration = this.frame.values.declarationOf(name, scopes);
+        const source = this.frame.values.importSource(name, scopes);
         if (source === null)
             return null;
         const imported = declaration?.type === 'ImportSpecifier' ? exportName(declaration.imported) : 'default';
@@ -540,8 +575,8 @@ class Walker {
         this.parents.splice(0, this.parents.length, ...savedParents);
     }
     /** The scopes around a function where it is written, outermost first, to resolve names in it at its calls. */
-    scopeChain(fn) {
-        const { program } = this.frame.parsed;
+    scopeChain(fn, frame = this.frame) {
+        const { program } = frame.parsed;
         let chains = this.scopeChains.get(program);
         if (!chains) {
             const found = new Map();
@@ -808,6 +843,31 @@ class Walker {
         return lines;
     }
 }
+/**
+ * The values a function returns, each with the scopes around it, outermost first; null when it may return no value, as
+ * with `return;` or no `return` at all. A `return` in a function inside it is that function's.
+ */
+function returnValues(fn, scopes) {
+    // Only declarations of overloads have no body.
+    const body = fn.body;
+    if (body.type !== 'BlockStatement')
+        return [{ expression: body, scopes }];
+    const values = [];
+    const visit = (node, around) => {
+        if (node.type === 'ReturnStatement') {
+            values.push(node.argument ? { expression: node.argument, scopes: around } : null);
+            return;
+        }
+        if (node.type === 'FunctionDeclaration' || isFunctionNode(node))
+            return;
+        const inner = isScopeNode(node) ? [...around, node] : around;
+        for (const child of childNodes(node))
+            visit(child, inner);
+    };
+    visit(body, scopes);
+    const always = values.every((value) => value !== null);
+    return always && values.length > 0 ? values : null;
+}
 /** Walks the scanned file; `openModule` reads the modules of imported helpers that the file calls. */
 export function extract(main, openModule) {
     return new Walker(main, openModule).run();

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.js

@@ -81,71 +81,76 @@ export function bindAll(declarators, bind) {
 }
 /** Whether a module exports `name` as a test object. */
 export function exportsTestObject(program, name, objects) {
-    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;
-            }
-        }
+    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 false;
+    return program.body.some((statement) => {
+        const source = starReexport(statement);
+        return source !== null && objects.reexports(source, name);
+    });
 }
 /**
- * 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({...})`.
+ * 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 importOrigin(program, name, isFramework) {
-    const imported = moduleImports(program, isFramework);
+function ownExport(program, name) {
     for (const statement of program.body) {
-        const required = commonJsReexport(statement);
-        if (required !== null && !isFramework(required))
-            return { source: required, imported: name, how: 're-exports' };
-        if (statement.type === 'ExportAllDeclaration' && !statement.exported && !isFramework(statement.source.value)) {
-            return { source: statement.source.value, imported: name, how: 're-exports' };
+        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;
-            const local = exportName(specifier.local);
-            // `export { test } from './fixtures'`, or `import { test } from './fixtures'` and then `export { test }`.
-            if (statement.source) {
-                if (isFramework(statement.source.value))
-                    continue;
-                return { source: statement.source.value, imported: local, how: 're-exports' };
-            }
-            const from = imported.get(local);
-            if (from)
-                return { source: from.source, imported: from.imported, how: 're-exports' };
+            return { kind: 'specifier', local: exportName(specifier.local), source: statement.source?.value ?? null };
         }
     }
+    return null;
+}
+/** 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);
+}
+/**
+ * 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({...})`.
+ */
+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)

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. */

package/dist/frameworks/playwright.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, propertyKey, propertyName, unwrap } from "../ast.js";
 import { snippet } from "../source.js";
 import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, readCondition, readOptions, readReason, readStrings, readTitle, text, unresolvedOption, unresolvedOptions, } from "./common.js";
+import { atLeast, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, readCondition, readOptions, readReason, readStrings, readTitle, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
 const MISMATCHED_SOURCES = new Set(['vitest', '@jest/globals']);
 // Maps rather than object literals, so names such as `constructor` don't match inherited properties.
 const DESCRIBES = new Map([
@@ -26,6 +26,13 @@ const STATES = new Map([
 const OTHER_MEMBERS = new Set(['use', 'slow', 'setTimeout', 'extend']);
 /** First members that show a name imported from a local file is used as Playwright's `test`. */
 const TEST_MEMBERS = new Set(['describe', 'only', 'skip', 'fixme', 'fail', 'step', ...HOOKS]);
+/** The members of `test` a value chosen at run time holds either way: those both have, if both are the same kind. */
+function sharedMembers(a, b) {
+    if (!a || !b || (a[0] === 'describe') !== (b[0] === 'describe'))
+        return null;
+    const differs = a.findIndex((name, index) => b[index] !== name);
+    return differs === -1 ? a : a.slice(0, differs);
+}
 /** Calls that need a newer Playwright than the oldest supported one. */
 const ADDED_IN = new Map([
     ['fail.only', [1, 49]],
@@ -176,6 +183,7 @@ export class PlaywrightAdapter {
     imports;
     followed = new Map();
     reported = new Set();
+    /** Variables and names of functions read as test objects on trust, each reported once. */
     assumed = new Set();
     aliases = new Map();
     constructor(program, file, readModule) {
@@ -195,7 +203,7 @@ export class PlaywrightAdapter {
     }
     classify(call, context) {
         const chain = readChain(call.callee);
-        const links = chain ? this.testLinks(chain, call.arguments, context.scopes, context.inBody) : null;
+        const links = chain ? this.testLinks(chain, call.arguments, context) : null;
         if (!links)
             return null;
         const names = links.map((link) => link.name);
@@ -228,48 +236,68 @@ export class PlaywrightAdapter {
      * The links after the `test` object, or null when the chain doesn't start from Playwright's `test`. An import that
      * can't be followed is reported only outside test and hook bodies, where a call can declare tests.
      */
-    testLinks(chain, args, scopes, inBody) {
+    testLinks(chain, args, lookup) {
+        const links = this.linksFromTest(chain, args, lookup);
+        if (!links)
+            return null;
+        // A test object derived inline, as in `base.extend({ ... }).describe(...)`.
+        return links.slice(links.findLastIndex((link) => link.name === 'extend' && link.args) + 1);
+    }
+    linksFromTest(chain, args, lookup) {
         const { base, links } = chain;
-        let start;
+        const { scopes, inBody } = lookup;
+        const withMembers = (members) => [
+            ...members.map((name) => ({ name, args: null, template: null })),
+            ...links,
+        ];
         if (base.type === 'Identifier') {
             // A local variable or parameter with the same name, such as `(test) => test.result()`, is not Playwright's.
             const declaration = this.file.values.declarationOf(base.name, scopes);
             const bound = declaration !== null && this.bindings.declarations.has(declaration);
             const local = declaration !== null && this.imports.get(base.name)?.node === declaration;
-            const alias = declaration?.type === 'VariableDeclarator' && !bound && !local
-                ? this.describeAlias(declaration, scopes, inBody)
-                : null;
+            const alias = declaration?.type === 'VariableDeclarator' && !bound && !local ? this.alias(declaration, lookup) : null;
             // The module from `require()` is both the namespace and `test`, so `pw.test(...)` reads as the namespace.
             if (bound && this.bindings.namespaces.has(base.name) && links[0]?.name === 'test' && !links[0].args) {
-                start = 1;
-            }
-            else if (bound && this.bindings.testNames.has(base.name)) {
-                start = 0;
+                return links.slice(1);
             }
-            else if (alias) {
-                return [...alias.map((name) => ({ name, args: null, template: null })), ...links];
-            }
-            else if (local &&
-                this.looksLikeTest(links, args) &&
+            if (bound && this.bindings.testNames.has(base.name))
+                return links;
+            if (alias)
+                return withMembers(alias);
+            if (local &&
+                this.worthFollowing(base.name, links, args) &&
                 this.follow(base.name, !inBody && mayDeclareTests(base.name, links))) {
-                start = 0;
-            }
-            else if (declaration !== null && !bound && this.assumeLocal(declaration, base.name, links, args)) {
-                start = 0;
-            }
-            else {
-                return null;
+                return links;
             }
+            return declaration !== null && !bound && this.assumeLocal(declaration, base.name, links, args) ? links : null;
         }
-        else if (this.bindings.isModule(base) && links[0]?.name === 'test' && !links[0].args) {
-            start = 1;
-        }
-        else {
+        if (this.bindings.isModule(base) && links[0]?.name === 'test' && !links[0].args)
+            return links.slice(1);
+        const members = base.type === 'CallExpression' ? this.returned(base, links, args, lookup) : null;
+        return members && withMembers(members);
+    }
+    /**
+     * 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.
+     */
+    returned(call, links, args, lookup) {
+        const callee = unwrap(call.callee);
+        if (callee.type !== 'Identifier' || !lookup.returnsOf)
             return null;
+        const returns = lookup.returnsOf(callee.name, lookup.scopes);
+        if (returns)
+            return returnedFunction(returns, sharedMembers);
+        if (!isTestName(callee.name) || !this.looksLikeTest(links, args))
+            return null;
+        if (!this.assumed.has(callee.name)) {
+            this.assumed.add(callee.name);
+            this.problems.push(returnedTestObject(this.file, call));
         }
-        // A test object derived inline, as in `base.extend({ ... }).describe(...)`.
-        const derived = links.findLastIndex((link) => link.name === 'extend' && link.args);
-        return links.slice(Math.max(start, derived + 1));
+        return [];
+    }
+    testFunction(expression, scopes) {
+        return this.members(expression, { scopes, inBody: false, returnsOf: null });
     }
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     assumeLocal(declaration, name, links, args) {
@@ -286,33 +314,42 @@ export class PlaywrightAdapter {
     looksLikeTest(links, args) {
         return links.length === 0 ? looksLikeDeclaration(args) : TEST_MEMBERS.has(links[0].name);
     }
-    /** The members of `test` a variable holds a describe function from, as in `const serialDescribe = test.describe.serial`. */
-    describeAlias(declarator, scopes, inBody) {
+    /**
+     * 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.
+     */
+    worthFollowing(name, links, args) {
+        return this.looksLikeTest(links, args) || (isTestName(name) && looksLikeDeclaration(args));
+    }
+    /**
+     * 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.
+     */
+    alias(declarator, lookup) {
         let members = this.aliases.get(declarator);
         if (members === undefined) {
             // Set first, so a variable defined through itself ends the lookup.
             this.aliases.set(declarator, null);
-            members = declarator.init ? this.describeMembers(declarator.init, scopes, inBody) : null;
+            members = declarator.init ? this.members(declarator.init, lookup) : null;
             this.aliases.set(declarator, members);
         }
         return members;
     }
-    describeMembers(expression, scopes, inBody) {
+    /** The members of `test` a value holds: none for a test object, or those of a describe function. */
+    members(expression, lookup) {
         const node = unwrap(expression);
         if (node.type === 'ConditionalExpression') {
             // `IS_PLATFORM ? test.describe.serial : test.describe`: only the members both branches have apply.
-            const consequent = this.describeMembers(node.consequent, scopes, inBody);
-            const alternate = this.describeMembers(node.alternate, scopes, inBody);
-            if (!consequent || !alternate)
-                return null;
-            const shared = consequent.findIndex((name, index) => alternate[index] !== name);
-            return shared === -1 ? consequent : consequent.slice(0, shared);
+            return sharedMembers(this.members(node.consequent, lookup), this.members(node.alternate, lookup));
         }
+        if (this.bindings.isTestObject(node))
+            return [];
         const chain = readChain(node);
         if (!chain || chain.links.some((link) => link.args ?? link.template))
             return null;
-        const members = this.testLinks(chain, [], scopes, inBody)?.map((link) => link.name);
-        return members && DESCRIBES.has(members.join('.')) ? members : null;
+        const members = this.testLinks(chain, [], lookup)?.map((link) => link.name);
+        return members && (members.length === 0 || DESCRIBES.has(members.join('.'))) ? members : null;
     }
     /** Follows the import of `name` once, and reports it once when it can't be followed and `report` is set. */
     follow(name, report) {

package/dist/frameworks/vitest.d.ts

@@ -1,7 +1,13 @@
-import type { CallExpression } from 'oxc-parser';
+import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { Adapter, ApiCall, CallContext, ModuleReader, Problem } from '../model.ts';
 import type { ParsedFile } from '../parse.ts';
-import { type FileContext } from './common.ts';
+import { type FileContext, type Link } from './common.ts';
+type Kind = 'test' | 'describe';
+/** A test or describe function and the links after it, as in `test.skipIf(isCI)`. */
+interface TestFunction {
+    kind: Kind;
+    links: Link[];
+}
 export declare class VitestAdapter implements Adapter {
     readonly problems: Problem[];
     readonly fileTags: string[];
@@ -12,6 +18,7 @@ export declare class VitestAdapter 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;
     /** Describe callbacks and the name of their first parameter, which Vitest calls with its `test`. */
@@ -19,6 +26,7 @@ export declare class VitestAdapter implements Adapter {
     private warnedAboutTags;
     constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
     classify(call: CallExpression, context: CallContext): ApiCall | null;
+    testFunction(expression: Expression, scopes: readonly Node[]): TestFunction | null;
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     private benchCall;
     private chainCall;
@@ -31,9 +39,21 @@ export declare class VitestAdapter implements Adapter {
     /** The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`. */
     private alias;
     private aliasOf;
+    /**
+     * The function a call returns, as `conditionalTest({ min: 22 })` returns `it` or `it.skip`: what all the values the
+     * function returns have in common, as for a variable chosen by a condition. When the function can't be found, a call
+     * named like a test object is read as one on trust, with a warning; see `returnedTestObject`.
+     */
+    private returned;
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     private assumeLocal;
     private looksLikeTest;
+    /**
+     * 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;
     /** Vitest as followed modules are read, with the rules of the scanned version. */
     private framework;
     /** Follows the import of `name` once, and reports it once when it can't be followed and `report` is set. */
@@ -54,3 +74,4 @@ export declare class VitestAdapter implements Adapter {
     private arrayLength;
     private tagsUsed;
 }
+export {};

package/dist/frameworks/vitest.js

@@ -1,7 +1,18 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
 import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, text, } from "./common.js";
+import { atLeast, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, text, } from "./common.js";
+/** What a test function chosen at run time, as in `isCI ? it.skip : it`, is either way: only the links both have. */
+function shared(a, b) {
+    if (!a || a.kind !== b?.kind)
+        return null;
+    const same = (link, index) => {
+        const other = b.links.at(index);
+        return other?.name === link.name && !link.args && !link.template && !other.args && !other.template;
+    };
+    const differs = a.links.findIndex((link, index) => !same(link, index));
+    return { kind: a.kind, links: differs === -1 ? a.links : a.links.slice(0, differs) };
+}
 // Maps rather than object literals, so names such as `constructor` don't match inherited properties.
 const KINDS = new Map([
     ['test', 'test'],
@@ -208,6 +219,7 @@ export class VitestAdapter {
     imports;
     followed = new Map();
     reported = new Set();
+    /** Variables and names of functions read as test objects on trust, each reported once. */
     assumed = new Set();
     aliases = new Map();
     /** Describe callbacks and the name of their first parameter, which Vitest calls with its `test`. */
@@ -247,6 +259,9 @@ export class VitestAdapter {
             this.contextSkip(call, context) ??
             this.chainCall(call, context));
     }
+    testFunction(expression, scopes) {
+        return this.aliasOf(expression, { scopes, inBody: false, returnsOf: null });
+    }
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     benchCall(call, context) {
         const base = readChain(call.callee)?.base;
@@ -263,7 +278,7 @@ export class VitestAdapter {
     }
     chainCall(call, context) {
         const chain = readChain(call.callee);
-        const resolved = chain ? this.resolve(chain, call.arguments, context.scopes, context.inBody) : null;
+        const resolved = chain ? this.resolve(chain, call.arguments, context) : null;
         if (!resolved)
             return null;
         const { kind, links } = resolved;
@@ -303,8 +318,8 @@ export class VitestAdapter {
      * The function a chain calls and the links after it, or null when it isn't one of Vitest's. An import that can't be
      * followed is reported only outside test and hook bodies, where a call can declare tests.
      */
-    resolve(chain, args, scopes, inBody) {
-        const start = this.start(chain, args, scopes, inBody);
+    resolve(chain, args, lookup) {
+        const start = this.start(chain, args, lookup);
         if (!start)
             return null;
         let kind = start.kind;
@@ -318,8 +333,13 @@ export class VitestAdapter {
         }
         return { kind, links };
     }
-    start(chain, args, scopes, inBody) {
+    start(chain, args, lookup) {
         const { base, links } = chain;
+        const { scopes, inBody } = lookup;
+        if (base.type === 'CallExpression') {
+            const returned = this.returned(base, links, args, lookup);
+            return returned && { kind: returned.kind, index: 0, modifiers: returned.links };
+        }
         if (base.type !== 'Identifier')
             return null;
         // A name the file doesn't declare is one of Vitest's globals; a local variable or parameter with the same name,
@@ -335,10 +355,10 @@ export class VitestAdapter {
         if (this.suiteParameters.get(declaration) === base.name)
             return { kind: 'test', index: 0 };
         const followed = this.imports.get(base.name)?.node === declaration &&
-            this.looksLikeTest(links, args) &&
+            this.worthFollowing(base.name, links, args) &&
             this.follow(base.name, !inBody && mayDeclareTests(base.name, links));
         if (!followed && !this.bindings.declarations.has(declaration)) {
-            const alias = declaration.type === 'VariableDeclarator' ? this.alias(declaration, scopes, inBody) : null;
+            const alias = declaration.type === 'VariableDeclarator' ? this.alias(declaration, lookup) : null;
             if (alias)
                 return { kind: alias.kind, index: 0, modifiers: alias.links };
             return this.assumeLocal(declaration, base.name, links, args)
@@ -353,37 +373,48 @@ export class VitestAdapter {
         return kind ? { kind, index: 0 } : null;
     }
     /** The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`. */
-    alias(declarator, scopes, inBody) {
+    alias(declarator, lookup) {
         let alias = this.aliases.get(declarator);
         if (alias === undefined) {
             // Set first, so a variable defined through itself ends the lookup.
             this.aliases.set(declarator, null);
-            alias = declarator.init ? this.aliasOf(declarator.init, scopes, inBody) : null;
+            alias = declarator.init ? this.aliasOf(declarator.init, lookup) : null;
             this.aliases.set(declarator, alias);
         }
         return alias;
     }
-    aliasOf(expression, scopes, inBody) {
+    aliasOf(expression, lookup) {
         const node = unwrap(expression);
         if (node.type === 'ConditionalExpression') {
             // `isCI ? describe.concurrent : describe`: only the modifiers both branches have apply.
-            const consequent = this.aliasOf(node.consequent, scopes, inBody);
-            const alternate = this.aliasOf(node.alternate, scopes, inBody);
-            if (!consequent || consequent.kind !== alternate?.kind)
-                return null;
-            const same = (link, index) => {
-                const other = alternate.links.at(index);
-                return other?.name === link.name && !link.args && !link.template && !other.args && !other.template;
-            };
-            const shared = consequent.links.findIndex((link, index) => !same(link, index));
-            return { kind: consequent.kind, links: shared === -1 ? consequent.links : consequent.links.slice(0, shared) };
+            return shared(this.aliasOf(node.consequent, lookup), this.aliasOf(node.alternate, lookup));
         }
         const chain = readChain(node);
-        const resolved = chain ? this.resolve(chain, [], scopes, inBody) : null;
+        const resolved = chain ? this.resolve(chain, [], lookup) : null;
         const allowed = (link) => resolved !== null &&
             (MODIFIERS[resolved.kind].has(link.name) || TABLES.has(link.name) || CONDITIONS.has(link.name));
         return resolved?.links.every(allowed) ? resolved : null;
     }
+    /**
+     * The function a call returns, as `conditionalTest({ min: 22 })` returns `it` or `it.skip`: what all the values the
+     * function returns have in common, as for a variable chosen by a condition. When the function can't be found, a call
+     * named like a test object is read as one on trust, with a warning; see `returnedTestObject`.
+     */
+    returned(call, links, args, lookup) {
+        const callee = unwrap(call.callee);
+        if (callee.type !== 'Identifier' || !lookup.returnsOf)
+            return null;
+        const returns = lookup.returnsOf(callee.name, lookup.scopes);
+        if (returns)
+            return returnedFunction(returns, shared);
+        if (!isTestName(callee.name) || !this.looksLikeTest(links, args))
+            return null;
+        if (!this.assumed.has(callee.name)) {
+            this.assumed.add(callee.name);
+            this.problems.push(returnedTestObject(this.file, call));
+        }
+        return { kind: KINDS.get(callee.name) ?? 'test', links: [] };
+    }
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     assumeLocal(declaration, name, links, args) {
         if (declaration.type !== 'VariableDeclarator' || !mayHoldTestObject(declaration) || !isTestName(name))
@@ -399,6 +430,14 @@ export class VitestAdapter {
     looksLikeTest(links, args) {
         return links.length === 0 ? looksLikeDeclaration(args) : TEST_MEMBERS.has(links[0].name);
     }
+    /**
+     * 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.
+     */
+    worthFollowing(name, links, args) {
+        return this.looksLikeTest(links, args) || (isTestName(name) && looksLikeDeclaration(args));
+    }
     /** Vitest as followed modules are read, with the rules of the scanned version. */
     framework() {
         const version = this.file.version;

package/dist/model.d.ts

@@ -1,4 +1,4 @@
-import type { CallExpression, Node } from 'oxc-parser';
+import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { FunctionNode } from './ast.ts';
 import type { Annotation, DiagnosticCode, DiagnosticLevel, MetaValue } from './types.ts';
 export type State = 'skip' | 'fixme' | 'todo' | 'expectedToFail';
@@ -105,6 +105,20 @@ export interface CallContext {
     inTest: boolean;
     /** Inside a test or hook body, where calls don't declare tests. */
     inBody: boolean;
+    /**
+     * What a function declared in the file, or imported from a local module, returns, for a call on its result such as
+     * `conditionalTest({ min: 22 })('title', fn)`; null when the name is not a function the scan can find.
+     */
+    returnsOf(name: string, scopes: readonly Node[]): Returns | null;
+}
+/** The values a function returns, read by the adapter of the file that writes the function. */
+export interface Returns {
+    adapter: Adapter;
+    /** Each value with the scopes around it; null when the function may return no value, or returns a promise. */
+    values: {
+        expression: Expression;
+        scopes: readonly Node[];
+    }[] | null;
 }
 /** A module read to see whether it exports a custom `test` object. */
 export interface ModuleSource {
@@ -124,5 +138,10 @@ export interface Adapter {
     fileTags: string[];
     usesGlobals: 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
+     * when it holds none. A function the value calls is not followed to what it returns.
+     */
+    testFunction(expression: Expression, scopes: readonly Node[]): unknown;
 }
 export {};

package/dist/options.d.ts

@@ -3,12 +3,15 @@ import type { Framework } from './types.ts';
 export type { CommentsMode };
 /** @inline */
 export interface ScanOptions {
-    /** Glob patterns for the test files, relative to `root`. */
+    /**
+     * Glob patterns for the test files, relative to `root`. As in Playwright and Vitest, they match names that start with
+     * a dot too.
+     */
     patterns: string[];
     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`. */
+    /** Glob patterns to leave out, in addition to `node_modules` and `.git`. */
     ignore?: string[];
     /** The framework version whose rules apply, instead of the one read from the project. */
     frameworkVersion?: string;

package/dist/resolve.js

@@ -267,7 +267,12 @@ function workspacePackages(directory) {
         const workspaces = readJson(path.join(folder, 'package.json'))?.workspaces;
         const fromManifest = Array.isArray(workspaces) ? workspaces : record(workspaces)?.packages;
         const pnpm = readText(path.join(folder, 'pnpm-workspace.yaml'));
-        const patterns = (Array.isArray(fromManifest) ? fromManifest : pnpm ? pnpmWorkspacePatterns(pnpm) : null)?.filter((item) => typeof item === 'string');
+        // pnpm reads only pnpm-workspace.yaml, and npm, Yarn and Bun only package.json, so a repository that moved to
+        // pnpm may still have an old list there. Packages from both are found.
+        const lists = [Array.isArray(fromManifest) ? fromManifest : null, pnpm ? pnpmWorkspacePatterns(pnpm) : null];
+        const patterns = lists.some((list) => list !== null)
+            ? lists.flat().filter((item) => typeof item === 'string')
+            : null;
         if (patterns) {
             // Packages are inside the workspace. A pattern or a link that leads out of its folder could send the search through
             // the whole disk, so neither is followed.

package/dist/types.d.ts

@@ -219,7 +219,7 @@ export interface TestRecord {
     caseCount: Count | null;
     /** Declared inside a loop, `forEach` or `map`. */
     isInLoop: boolean;
-    /** Declared inside `if`, `?:`, `&&` or `switch`. */
+    /** Declared inside `if`, `?:`, `&&`, `switch` or a `catch` block. */
     isInCondition: boolean;
     /** Declared inside a plain function. */
     isInFunction: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-inventory",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Test metadata from source code, not from test results.",
   "keywords": [
     "testing",

package/schema/v1.json

@@ -730,7 +730,7 @@
         },
         "isInCondition": {
           "type": "boolean",
-          "description": "Declared inside `if`, `?:`, `&&` or `switch`."
+          "description": "Declared inside `if`, `?:`, `&&`, `switch` or a `catch` block."
         },
         "isInFunction": {
           "type": "boolean",