test-inventory 0.7.0 → 0.9.0

package/dist/frameworks/playwright.js

@@ -209,6 +209,7 @@ export class PlaywrightAdapter {
     imports;
     followed = new Map();
     reported = new Set();
+    refusedRests = new Set();
     /** Variables and names of functions read as test objects on trust, each reported once. */
     assumed = new Set();
     aliases = new Map();
@@ -259,6 +260,7 @@ export class PlaywrightAdapter {
             return this.configure(call, context);
         if (HOOKS.has(key)) {
             const fn = hookFunction(this.file, context.scopes, call.arguments);
+            this.checkFixtureArguments(fn);
             return {
                 kind: 'hook',
                 name: key,
@@ -270,6 +272,8 @@ export class PlaywrightAdapter {
         }
         if (RUN_MEMBERS.has(key))
             return this.runSetting(call, key, context);
+        if (key === 'extend')
+            this.checkExtendFixtures(call, context);
         if (OTHER_MEMBERS.has(key))
             return { kind: 'other' };
         return this.invalid(call, names, "is not part of Playwright's API", context);
@@ -476,6 +480,7 @@ export class PlaywrightAdapter {
         const line = this.file.source.line(call.start);
         const fn = isFunctionNode(last) ? last : null;
         const hashed = fn ?? namedFunction(this.file, context.scopes, last);
+        this.checkFixtureArguments(hashed);
         return {
             kind: 'test',
             title,
@@ -495,6 +500,56 @@ export class PlaywrightAdapter {
             problems,
         };
     }
+    /**
+     * Playwright reads which fixtures a function takes from its source, and refuses a rest property among them, as
+     * `({ page, ...fixtures })`, failing the whole run. A nested one, as `({ page: { mouse, ...rest } })`, is allowed.
+     */
+    checkFixtureArguments(fn) {
+        const parameter = fn?.params[0];
+        const rest = parameter?.type === 'ObjectPattern' ? parameter.properties.find((item) => item.type === 'RestElement') : null;
+        if (!rest || this.refusedRests.has(rest))
+            return;
+        this.refusedRests.add(rest);
+        const source = snippet(text(this.file, rest));
+        const message = `Playwright refuses the rest property ${source} in fixture arguments, so it fails to load the file and runs no tests at all.`;
+        this.problems.push(problem('invalid-fixture-argument', rest, message, source));
+    }
+    /** The fixture functions of `test.extend({ ... })`, each given as a function or as `[function, options]`. */
+    checkExtendFixtures(call, context) {
+        const argument = call.arguments.at(0);
+        if (argument && argument.type !== 'SpreadElement')
+            this.checkFixtureObject(argument, context.scopes, new Set());
+    }
+    /**
+     * An object of fixtures, written in place or held in a constant, with the objects it spreads; `seen` ends a constant
+     * that spreads itself, which throws at run time.
+     */
+    checkFixtureObject(expression, scopes, seen) {
+        const node = unwrap(expression);
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        if (node.type === 'Identifier') {
+            const constant = this.file.values.constantOf(node.name, scopes);
+            if (constant)
+                this.checkFixtureObject(constant.init, constant.scopes, seen);
+            return;
+        }
+        if (node.type !== 'ObjectExpression')
+            return;
+        for (const property of node.properties) {
+            if (property.type === 'SpreadElement') {
+                this.checkFixtureObject(property.argument, scopes, seen);
+                continue;
+            }
+            const value = unwrap(property.value);
+            const fn = value.type === 'ArrayExpression' ? value.elements[0] : value;
+            if (isFunctionNode(fn))
+                this.checkFixtureArguments(fn);
+            else if (fn?.type === 'Identifier')
+                this.checkFixtureArguments(this.file.values.functionOf(fn.name, scopes));
+        }
+    }
     /** `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], {
@@ -505,6 +560,8 @@ export class PlaywrightAdapter {
     }
     modifier(call, state, context) {
         const [condition, description] = [call.arguments.at(0), call.arguments.at(1)];
+        if (isFunctionNode(condition))
+            this.checkFixtureArguments(condition);
         const problems = [];
         if (isTitleLiteral(condition)) {
             const callee = snippet(text(this.file, call.callee));

package/dist/frameworks/test-functions.d.ts

@@ -0,0 +1,194 @@
+import type { Argument, CallExpression, Expression, Node, Program } from 'oxc-parser';
+import type { Adapter, ApiCall, CallContext, ModuleReader, Problem, Span } from '../model.ts';
+import type { ParsedFile } from '../parse.ts';
+import type { HookCounts } from '../types.ts';
+import { type Exported, type FollowImport, type TestObjects } from './bindings.ts';
+import { type Chain, type FileContext, type Link } from './common.ts';
+export type Kind = 'test' | 'describe';
+/** A test or describe function and the links after it, as in `test.skipIf(isCI)`. */
+export interface TestFunction {
+    kind: Kind;
+    links: Link[];
+}
+/** A name that starts a chain: the function it is, and the links it stands for, as Jest's `fit` stands for `it.only`. */
+export interface Start {
+    kind: Kind;
+    links: readonly string[];
+}
+/**
+ * How a framework with `describe` and `test` functions, imported or used as globals, names them: Vitest and Jest.
+ */
+export interface Dialect {
+    /** The framework's name in messages. */
+    name: string;
+    /** The module the functions are imported from. */
+    source: string;
+    /** Modules of other frameworks, which a file of this one doesn't import. */
+    mismatched: ReadonlySet<string>;
+    /** The names that start a chain, as exported and as globals; a map, so `constructor` matches nothing inherited. */
+    starts: ReadonlyMap<string, Start>;
+    /** Each hook's name in code, and the name it is counted under, as Mocha's `before` is counted as `beforeAll`. */
+    hooks: ReadonlyMap<string, keyof HookCounts>;
+    /** Members that build a test object from another, such as Vitest's `extend`. */
+    derivations: ReadonlySet<string>;
+    /** Members that give a test function a mode, as `skip` and `only` do, which a variable can hold it with. */
+    modifiers: ReadonlySet<string>;
+    /** Whether the test function carries the others, as Vitest's `test.describe` and `describe.test` do. */
+    carriesKinds: boolean;
+    /** Whether an expression is the framework's module, as `import.meta.vitest` or `require('@jest/globals')` are. */
+    isModule: (expression: Expression) => boolean;
+    /** Why a default import of the module fails; null when it gives the module. */
+    defaultImport: string | null;
+    /** Why `require()` of the module fails; null when the module can be required. */
+    required: string | null;
+    /** Other modules the runner reads as its own, as Bun rewrites `@jest/globals` and `vitest` to `bun:test`. */
+    aliases?: ReadonlySet<string>;
+    /** What the module is when called, as `node:test`'s default export and `require()` are its `test`. */
+    callable?: Start;
+    /** The module's other members, which a chain on the callable module may start with and is then no test. */
+    others?: ReadonlySet<string>;
+    /** Whether the functions must be imported, as the runner sets no globals; `starts` are then exports only. */
+    importOnly?: boolean;
+}
+/** What a test function chosen at run time, as in `isCI ? it.skip : it`, is either way: only the links both have. */
+export declare function shared(a: TestFunction | null, b: TestFunction | null): TestFunction | null;
+/** The names a file binds to the framework's test functions, hooks, other exports and module. */
+export declare class SuiteBindings implements TestObjects {
+    readonly starts: Map<string, Start>;
+    readonly hooks: Map<string, keyof HookCounts>;
+    readonly namespaces: Set<string>;
+    /** Other names imported from the framework, by their exported name, such as Vitest's `bench` or Jest's `jest`. */
+    readonly members: Map<string, string>;
+    /** The import specifiers and declarators that bind those names, to tell them from local names that shadow them. */
+    readonly declarations: Set<Node>;
+    readonly problems: Problem[];
+    private readonly dialect;
+    /** Names imported from other modules, which may be test objects there. */
+    private readonly imported;
+    private readonly follow;
+    /** The module's functions and the variables they may build test objects in; see `ModuleFunctions`. */
+    private readonly functions;
+    private readonly program;
+    /** Names the module declares or imports at its top level, which hide the framework's globals. */
+    private readonly declared;
+    /** Whether the module is one a scanned file imports from, where no walk reads its globals and chains. */
+    private readonly isFollowed;
+    constructor(program: Program, dialect: Dialect, follow: FollowImport, isFollowed?: boolean);
+    isTestName(name: string): boolean;
+    /**
+     * `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: Expression, followsCalls?: boolean): boolean;
+    returnsTestObject(name: string): boolean;
+    /**
+     * What a name or chain stands for: one bound from the framework, a global the module doesn't hide, a member of the
+     * module, or one of those with modifiers, as `it.skip`; null otherwise.
+     */
+    startOf(expression: Expression): Start | null;
+    /**
+     * What a value stands for when the file binds it: in a scanned file, a name bound from the framework or a member of
+     * its module, as the walk reads globals and chains itself; in a followed module, also globals and chains.
+     */
+    private boundStart;
+    /** A name the module is bound to: its namespace, and its `test` too when the module can be called. */
+    private bindModule;
+    exportedStart(name: string): Start | null;
+    private holdsTestObject;
+    reexports(source: string, imported: string, exported: Exported): boolean;
+    /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
+    private importsTestObject;
+    /** Whether an expression is the framework's module: a namespace import, or the module itself. */
+    isNamespace(expression: Expression): boolean;
+    private bindMember;
+    private bind;
+}
+/** Where a chain's names are looked up. */
+export type Lookup = Pick<CallContext, 'scopes' | 'inBody' | 'returnsOf'>;
+/**
+ * What Vitest's and Jest's adapters share: how a call's chain is followed to the test or describe function it starts
+ * from, through imports, variables, helper functions and globals.
+ */
+export declare abstract class SuiteAdapter implements Adapter {
+    readonly problems: Problem[];
+    readonly fileTags: string[];
+    readonly fileTagSpans: Span[];
+    usesGlobals: boolean;
+    protected readonly file: FileContext;
+    protected readonly bindings: SuiteBindings;
+    protected readonly dialect: Dialect;
+    /** Describe callbacks and the name of their first parameter, which Vitest calls with its `test`. */
+    protected readonly suiteParameters: Map<Node, string>;
+    private readonly readModule;
+    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;
+    /** First members that show a name imported from a local file is used as the framework's `test`. */
+    private readonly testMembers;
+    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null, dialect: Dialect, testMembers: Iterable<string>);
+    abstract classify(call: CallExpression, context: CallContext): ApiCall | null;
+    /** Whether a variable that holds a test function may hold this link after it, as `const skipOnCi = test.skipIf(isCI)`. */
+    protected abstract isAliasLink(kind: Kind, link: Link): boolean;
+    protected abstract hook(call: CallExpression, name: keyof HookCounts, context: CallContext): ApiCall;
+    testFunction(expression: Expression, scopes: readonly Node[], returnsOf: CallContext['returnsOf']): TestFunction | null;
+    /**
+     * The function a chain calls and the links after it, or null when it isn't the framework's. An import that can't be
+     * followed is reported only outside test and hook bodies, where a call can declare tests.
+     */
+    protected resolve(chain: Chain, args: readonly Argument[], lookup: Lookup): TestFunction | null;
+    private start;
+    /**
+     * What a chain on the framework's module starts with: the member it names, or for a module that can be called, as
+     * `node:test`'s, the module itself, as in `test.skip(...)`.
+     */
+    private member;
+    /**
+     * The member a name is destructured from a test or describe function as, with that function's kind and the
+     * expression it is taken from: `each`, `test` and `test` in `const { each } = test`; null for any other name.
+     */
+    protected destructuredMember(name: string, lookup: Lookup): {
+        kind: Kind;
+        member: string;
+        from: Expression;
+    } | null;
+    /**
+     * The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`, with the member `name`
+     * takes when it is destructured, as in `const { beforeEach } = test`. The members Vitest reads through `this`, such as
+     * `each` and `skipIf`, return a test function only when called, so their calls are never read through a variable.
+     */
+    private alias;
+    private aliasOf;
+    /**
+     * The test functions a value may hold, and whether it may also hold something else, as `process.env.CI` may. A test
+     * function is never falsy, so `test.skip || test` and `test.skip ?? test` hold `test.skip`, while
+     * `process.env.CI && test.skip || test` may hold either. Both branches of `?:` have to be test functions.
+     */
+    private choices;
+    /**
+     * 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;
+    /** The framework as followed modules are read. */
+    private framework;
+    /** Follows the import of `name` once, and reports it once when it can't be followed and `report` is set. */
+    private follow;
+    /** Hooks called directly, such as `beforeEach(...)` imported from the framework or used as a global. */
+    protected hookCall(call: CallExpression, context: CallContext): ApiCall | null;
+    /** The number of items of a table, also when not all its values are known; see `Values.lengthOf`. */
+    protected arrayLength(node: Argument | undefined, context: CallContext): number | null;
+}