test-inventory 0.2.1 → 0.4.0

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, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
+import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
+import { atLeast, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, readCondition, readCount, readOptions, readReason, readStrings, readTitle, refused, 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([
@@ -24,6 +24,10 @@ const STATES = new Map([
 ]);
 /** Members of `test` that are known but don't declare or modify tests. */
 const OTHER_MEMBERS = new Set(['use', 'slow', 'setTimeout', 'extend']);
+/** Members that set how the tests run where they are called. */
+const RUN_MEMBERS = new Set(['slow', 'setTimeout']);
+/** First members of chains that never declare a test, even when Playwright refuses the rest of the chain. */
+const NOT_DECLARING = new Set(['step', 'abort', ...HOOKS, ...OTHER_MEMBERS]);
 /** 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. */
@@ -57,9 +61,12 @@ class PlaywrightBindings {
     /** Names imported from other modules, which may be test objects there. */
     imported;
     follow;
+    /** The module's functions and the variables they may build test objects in; see `ModuleFunctions`. */
+    functions;
     constructor(program, follow) {
         this.imported = moduleImports(program, (source) => isPlaywrightSource(source) || MISMATCHED_SOURCES.has(source));
         this.follow = follow;
+        this.functions = new ModuleFunctions(program, this.imported, follow);
         for (const statement of program.body) {
             if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
                 continue;
@@ -85,41 +92,59 @@ class PlaywrightBindings {
                 }
             }
         }
-        bindAll(allDeclarators(program), (declarator) => {
+        const declarators = allDeclarators(program);
+        bindAll(declarators, (declarator) => {
             const bound = this.bind(declarator);
             if (bound)
                 this.declarations.add(declarator);
             return bound;
         });
+        this.functions.keep(declarators.filter((declarator) => !this.declarations.has(declarator)));
     }
     isTestName(name) {
-        return this.testNames.has(name) || this.importsTestObject(name);
+        return this.testNames.has(name) || this.importsTestObject(name) || this.holdsTestObject(name);
     }
-    isTestObject(expression) {
+    /**
+     * `followsCalls` is cleared where a call is not followed to what it returns: while the names are bound, so that only
+     * a value asked about is followed, as following reads other modules, and in the scanned file, whose calls the walk
+     * follows in their scopes.
+     */
+    isTestObject(expression, followsCalls = true) {
         const node = unwrap(expression);
         switch (node.type) {
             case 'Identifier':
-                return this.testNames.has(node.name) || this.importsTestObject(node.name);
+                return (this.testNames.has(node.name) ||
+                    this.importsTestObject(node.name) ||
+                    (followsCalls && this.holdsTestObject(node.name)));
             case 'MemberExpression':
                 return propertyName(node) === 'test' && this.isModule(node.object);
             case 'ConditionalExpression':
                 // `process.env.CI ? ciTest : test` is a test object either way.
-                return this.isTestObject(node.consequent) || this.isTestObject(node.alternate);
+                return this.isTestObject(node.consequent, followsCalls) || this.isTestObject(node.alternate, followsCalls);
             case 'CallExpression': {
                 const callee = unwrap(node.callee);
                 if (callee.type === 'MemberExpression' && propertyName(callee) === 'extend') {
-                    return this.isTestObject(callee.object);
+                    return this.isTestObject(callee.object, followsCalls);
                 }
+                // `mergeTests(a, b)`, or `defineBrokerTest()`, a function that returns a test object.
                 return callee.type === 'Identifier'
-                    ? this.mergeTestsNames.has(callee.name)
+                    ? this.mergeTestsNames.has(callee.name) || (followsCalls && this.returnsTestObject(callee.name))
                     : callee.type === 'MemberExpression' && propertyName(callee) === 'mergeTests' && this.isModule(callee.object);
             }
             default:
                 return false;
         }
     }
-    reexports(source, imported) {
-        return isPlaywrightSource(source) ? imported === 'test' || imported === 'default' : this.follow(source, imported);
+    returnsTestObject(name) {
+        return this.functions.returnsTestObject(name, (expression) => this.isTestObject(expression));
+    }
+    holdsTestObject(name) {
+        return this.functions.holdsTestObject(name, (expression) => this.isTestObject(expression));
+    }
+    reexports(source, imported, exported) {
+        if (!isPlaywrightSource(source))
+            return this.follow(source, imported, exported);
+        return exported === 'test object' && (imported === 'test' || imported === 'default');
     }
     /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
     importsTestObject(name) {
@@ -148,7 +173,7 @@ class PlaywrightBindings {
                 }
                 return true;
             }
-            if (this.isTestObject(init)) {
+            if (this.isTestObject(init, false)) {
                 this.testNames.add(id.name);
                 return true;
             }
@@ -192,10 +217,11 @@ export class PlaywrightAdapter {
         // A test object the file builds from an imported one, as in `const test = base.extend({...})`, is followed
         // quietly: a call through the import itself is what reports an import that can't be followed.
         const followed = new Map();
-        this.bindings = new PlaywrightBindings(program, (source, imported) => {
-            const key = `${source}\0${imported}`;
-            if (!followed.has(key))
-                followed.set(key, followModule(source, imported, readModule, PLAYWRIGHT).exported);
+        this.bindings = new PlaywrightBindings(program, (source, imported, exported = 'test object') => {
+            const key = `${source}\0${exported}\0${imported}`;
+            if (!followed.has(key)) {
+                followed.set(key, followModule(source, imported, readModule, PLAYWRIGHT, exported).exported);
+            }
             return followed.get(key) === true;
         });
         this.problems = [...this.bindings.mismatches];
@@ -210,14 +236,18 @@ export class PlaywrightAdapter {
         const key = names.join('.');
         const addedIn = ADDED_IN.get(key);
         if (addedIn && !atLeast(this.file.version, ...addedIn)) {
-            return this.invalid(call, `needs Playwright ${addedIn.join('.')} or newer`);
+            return this.invalid(call, names, `needs Playwright ${addedIn.join('.')} or newer`, context);
         }
         if (names[0] === 'info')
             return this.annotationsPush(call, links, context);
+        if ((key === 'step' || key === 'step.skip') && context.inTest && call.arguments.length > 0) {
+            return this.step(call, key === 'step.skip', context);
+        }
         if (names[0] === 'expect' || names[0] === 'step' || key === 'abort')
             return { kind: 'other' };
-        if (links.some((link) => link.args ?? link.template))
-            return this.invalid(call, "is not part of Playwright's API");
+        if (links.some((link) => link.args ?? link.template)) {
+            return this.invalid(call, names, "is not part of Playwright's API", context);
+        }
         if (key === '' || key === 'only' || key === 'skip' || key === 'fixme' || key === 'fail' || key === 'fail.only') {
             return this.testCall(call, key, context);
         }
@@ -226,11 +256,15 @@ export class PlaywrightAdapter {
             return this.describeCall(call, describe, context);
         if (key === 'describe.configure')
             return this.configure(call, context);
-        if (HOOKS.has(key))
-            return { kind: 'hook', fn: findFunction(call.arguments), testContext: null };
+        if (HOOKS.has(key)) {
+            const fn = findFunction(call.arguments);
+            return { kind: 'hook', name: key, fn, testContext: null, fixtures: destructuredNames(fn, 0) };
+        }
+        if (RUN_MEMBERS.has(key))
+            return this.runSetting(call, key, context);
         if (OTHER_MEMBERS.has(key))
             return { kind: 'other' };
-        return this.invalid(call, "is not part of Playwright's API");
+        return this.invalid(call, names, "is not part of Playwright's API", context);
     }
     /**
      * The links after the `test` object, or null when the chain doesn't start from Playwright's `test`. An import that
@@ -283,7 +317,7 @@ export class PlaywrightAdapter {
      */
     returned(call, links, args, lookup) {
         const callee = unwrap(call.callee);
-        if (callee.type !== 'Identifier' || !lookup.returnsOf)
+        if (callee.type !== 'Identifier')
             return null;
         const returns = lookup.returnsOf(callee.name, lookup.scopes);
         if (returns)
@@ -296,8 +330,8 @@ export class PlaywrightAdapter {
         }
         return [];
     }
-    testFunction(expression, scopes) {
-        return this.members(expression, { scopes, inBody: false, returnsOf: null });
+    testFunction(expression, scopes, returnsOf) {
+        return this.members(expression, { scopes, inBody: false, returnsOf });
     }
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     assumeLocal(declaration, name, links, args) {
@@ -343,7 +377,7 @@ export class PlaywrightAdapter {
             // `IS_PLATFORM ? test.describe.serial : test.describe`: only the members both branches have apply.
             return sharedMembers(this.members(node.consequent, lookup), this.members(node.alternate, lookup));
         }
-        if (this.bindings.isTestObject(node))
+        if (this.bindings.isTestObject(node, false))
             return [];
         const chain = readChain(node);
         if (!chain || chain.links.some((link) => link.args ?? link.template))
@@ -376,9 +410,15 @@ export class PlaywrightAdapter {
         const resolved = this.file.values.resolve(node, context.scopes);
         return resolved.ok && typeof resolved.value === 'string';
     }
-    invalid(call, reason) {
+    /** A chain Playwright refuses; one that starts like a declaration also declares a plain test or describe. */
+    invalid(call, names, reason, context) {
         const callee = snippet(text(this.file, call.callee));
-        return { kind: 'invalid', problem: problem('invalid-chain', call, `${callee} ${reason}.`, callee) };
+        const refusal = problem('invalid-chain', call, `${callee} ${reason}.`, callee);
+        return refused(call, refusal, context, () => {
+            if (NOT_DECLARING.has(names[0]))
+                return { kind: 'other' };
+            return names.includes('describe') ? this.describeCall(call, {}, context) : this.testCall(call, '', context);
+        });
     }
     testCall(call, key, context) {
         const args = call.arguments;
@@ -420,6 +460,7 @@ export class PlaywrightAdapter {
             problems.push(titleProblem);
         const line = this.file.source.line(call.start);
         const fn = isFunctionNode(last) ? last : null;
+        const hashed = fn ?? namedFunction(this.file, context.scopes, last);
         return {
             kind: 'test',
             title,
@@ -428,13 +469,23 @@ export class PlaywrightAdapter {
             mode: null,
             details: this.details(args.length === 3 ? args[1] : undefined, context, problems, title.text),
             fn,
-            hashed: fn ?? namedFunction(this.file, context.scopes, last),
+            hashed,
             isParameterized: false,
             caseCount: null,
             testContext: null,
+            fixtures: destructuredNames(hashed, 0),
+            usesBench: false,
             problems,
         };
     }
+    /** `test.step(title, body)` in a test body; a title that can't be worked out is kept as source text. */
+    step(call, isSkipped, context) {
+        const { title } = readTitle(this.file, context.scopes, call.arguments[0], {
+            stripTags: false,
+            functionNames: false,
+        });
+        return { kind: 'step', title, isSkipped, fn: findFunction(call.arguments, 1) };
+    }
     modifier(call, state, context) {
         const [condition, description] = [call.arguments.at(0), call.arguments.at(1)];
         const problems = [];
@@ -479,6 +530,7 @@ export class PlaywrightAdapter {
             isOnly: kind.only === true,
             mode: kind.mode ?? null,
             isShuffled: false,
+            passesDown: null,
             details: this.details(!anonymous && args.length === 3 ? args[1] : undefined, context, problems, title?.text ?? ''),
             fn,
             hashed: fn,
@@ -510,10 +562,37 @@ export class PlaywrightAdapter {
                 problems.push(unresolvedOption(this.file, 'lock', unresolved, importedFrom, 'the lock is missing'));
             }
         }
-        if (!mode && locks.length === 0) {
+        const run = {};
+        const timeout = options?.values.get('timeout');
+        const timeoutValue = timeout ? readCount(this.file, 'timeout', timeout, problems) : null;
+        if (timeoutValue !== null)
+            run.timeout = timeoutValue;
+        const retries = options?.values.get('retries');
+        const count = retries ? readCount(this.file, 'retries', retries, problems) : null;
+        if (count !== null)
+            run.retry = { count, delay: null, condition: null };
+        if (!mode && locks.length === 0 && Object.keys(run).length === 0) {
             return problems.length > 0 ? { kind: 'invalid', problem: problems[0] } : { kind: 'other' };
         }
-        return { kind: 'configure', mode, locks, problems };
+        return { kind: 'configure', mode, locks, run, problems };
+    }
+    /** `test.setTimeout(ms)` or `test.slow(condition?, description?)`, which apply where they are called. */
+    runSetting(call, key, context) {
+        const problems = [];
+        const settings = {};
+        const first = call.arguments.at(0);
+        if (key === 'slow') {
+            const condition = readCondition(this.file, context.scopes, first);
+            if (condition.applies !== 'never')
+                settings.slow = { conditions: condition.text === null ? null : [condition.text] };
+        }
+        else if (first && first.type !== 'SpreadElement') {
+            const option = { node: first, resolved: this.file.values.resolve(first, context.scopes) };
+            const timeout = readCount(this.file, 'timeout', option, problems);
+            if (timeout !== null)
+                settings.timeout = timeout;
+        }
+        return { kind: 'run', settings, argument: first ? snippet(text(this.file, first)) : null, problems };
     }
     /** `test.info().annotations.push(...)` inside a test body. */
     annotationsPush(call, links, context) {
@@ -529,7 +608,7 @@ export class PlaywrightAdapter {
     }
     /** Reads the `{ tag, annotation, lock }` details of a test or describe. */
     details(node, context, problems, title) {
-        const details = { tags: titleTags(title), annotations: [], locks: [], meta: null };
+        const details = { tags: titleTags(title), annotations: [], locks: [], meta: null, run: {} };
         if (!node)
             return details;
         const options = readOptions(this.file, context.scopes, node);

package/dist/frameworks/vitest.d.ts

@@ -26,7 +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;
+    testFunction(expression: Expression, scopes: readonly Node[], returnsOf: CallContext['returnsOf']): TestFunction | null;
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     private benchCall;
     private chainCall;
@@ -62,6 +62,11 @@ export declare class VitestAdapter implements Adapter {
     private hookCall;
     private hook;
     private contextSkip;
+    /**
+     * `annotate(message, type?)` from the test context (3.2), as an annotation of type `notice` when no type is given; the
+     * second argument may also be an attachment.
+     */
+    private annotate;
     private declaration;
     /** Whether an argument holds options: an object, a name for one, or anything but a function before the body. */
     private isOptions;
@@ -69,6 +74,8 @@ export declare class VitestAdapter implements Adapter {
     /** Vitest's order: `only` wins over `skip`, which wins over `todo`. */
     private states;
     private readDeclarationOptions;
+    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`; the runner ignores an object before. */
+    private retry;
     private meta;
     private caseCount;
     private arrayLength;