test-inventory 0.3.0 → 0.4.1

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, ModuleFunctions, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, readCondition, readOptions, readReason, readStrings, readTitle, refused, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
+import { atLeast, findFunction, hookFunction, 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,8 @@ 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`. */
@@ -238,6 +240,9 @@ export class PlaywrightAdapter {
         }
         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)) {
@@ -251,8 +256,12 @@ 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 = hookFunction(this.file, context.scopes, 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, names, "is not part of Playwright's API", context);
@@ -451,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,
@@ -459,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 = [];
@@ -542,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) {
@@ -561,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

@@ -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;

package/dist/frameworks/vitest.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
 import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
+import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, 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)
@@ -37,6 +37,9 @@ const HOOKS = new Map([
     ['afterAll', null],
     ['aroundAll', null],
 ]);
+function isHook(name) {
+    return HOOKS.has(name);
+}
 /** First members of chains that never declare a test, even when Vitest refuses the rest of the chain. */
 const NOT_DECLARING = new Set([...HOOKS.keys(), ...DERIVATIONS]);
 /** First members that show a name imported from a local file is used as Vitest's `test`. */
@@ -91,6 +94,23 @@ function hoistedValue(call, parents) {
     const parent = parents.at(-1);
     return parent?.type === 'AwaitExpression' ? parent : call;
 }
+/** Keys of the test context that Vitest provides itself, with the version that added each; they are not fixtures. */
+const CONTEXT_KEYS = new Map([
+    ['task', [3, 0]],
+    ['expect', [3, 0]],
+    ['skip', [3, 0]],
+    ['onTestFailed', [3, 0]],
+    ['onTestFinished', [3, 0]],
+    ['annotate', [3, 2]],
+    ['signal', [3, 2]],
+    ['bench', [5, 0]],
+]);
+function fixturesOf(fn, index, version) {
+    return destructuredNames(fn, index).filter((name) => {
+        const since = CONTEXT_KEYS.get(name);
+        return !since || !atLeast(version, ...since);
+    });
+}
 /** The names a file binds to Vitest's `test`, `describe`, hooks and namespace. */
 class VitestBindings {
     kinds = new Map();
@@ -202,7 +222,7 @@ class VitestBindings {
         if (kind) {
             this.kinds.set(local, kind);
         }
-        else if (HOOKS.has(imported)) {
+        else if (isHook(imported)) {
             this.hooks.set(local, imported);
         }
         else if (imported === 'bench' && atLeast(version, 5, 0)) {
@@ -227,7 +247,7 @@ class VitestBindings {
             const kind = KINDS.get(key ?? '');
             if (kind)
                 this.kinds.set(property.value.name, kind);
-            if (key !== null && HOOKS.has(key))
+            if (key !== null && isHook(key))
                 this.hooks.set(property.value.name, key);
         }
         return true;
@@ -307,8 +327,8 @@ export class VitestAdapter {
         if (!resolved)
             return null;
         const { kind, links } = resolved;
-        if (kind === 'test' && links.length === 1 && HOOKS.has(links[0].name))
-            return this.hook(call, links[0].name);
+        if (kind === 'test' && links.length === 1 && isHook(links[0].name))
+            return this.hook(call, links[0].name, context);
         if (links.length === 1 && DERIVATIONS.has(links[0].name))
             return { kind: 'other' };
         const last = links.at(-1);
@@ -492,27 +512,28 @@ export class VitestAdapter {
             return null;
         const declaration = this.file.values.declarationOf(callee.name, context.scopes);
         const hook = declaration === null
-            ? HOOKS.has(callee.name) && callee.name
+            ? isHook(callee.name) && callee.name
             : this.bindings.declarations.has(declaration) && this.bindings.hooks.get(callee.name);
-        return hook ? this.hook(call, hook) : null;
+        return hook ? this.hook(call, hook, context) : null;
     }
-    hook(call, name) {
-        const fn = findFunction(call.arguments);
+    hook(call, name, context) {
+        const fn = hookFunction(this.file, context.scopes, call.arguments);
         const index = HOOKS.get(name);
-        return { kind: 'hook', fn, testContext: index === null ? null : skipNames(fn, index) };
+        return {
+            kind: 'hook',
+            name,
+            fn,
+            testContext: index === null ? null : contextNames(fn, index),
+            fixtures: fixturesOf(fn, index, this.file.version),
+        };
     }
     contextSkip(call, context) {
         const names = context.testContext;
         if (!names)
             return null;
-        const callee = unwrap(call.callee);
-        const isSkip = callee.type === 'Identifier'
-            ? names.functions.has(callee.name)
-            : callee.type === 'MemberExpression' &&
-                propertyName(callee) === 'skip' &&
-                callee.object.type === 'Identifier' &&
-                names.objects.has(callee.object.name);
-        if (!isSkip)
+        if (atLeast(this.file.version, 3, 2) && callsContext(call, names, 'annotate'))
+            return this.annotate(call, context);
+        if (!callsContext(call, names, 'skip'))
             return null;
         const [first, second] = call.arguments;
         // skip(), skip(note) or skip(condition, note); before Vitest 3.1 the first argument is always the note.
@@ -527,6 +548,29 @@ export class VitestAdapter {
             problems: reason.problem ? [reason.problem] : [],
         };
     }
+    /**
+     * `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.
+     */
+    annotate(call, context) {
+        const args = call.arguments.map((arg) => arg.type === 'SpreadElement' ? null : this.file.values.resolve(arg, context.scopes));
+        const [message, second] = args;
+        // A second argument that isn't a string is an attachment, given in place of the type.
+        let type = 'notice';
+        if (args.length > 1 && !second?.ok)
+            type = null;
+        else if (second?.ok && typeof second.value === 'string')
+            type = second.value;
+        if (message?.ok && typeof message.value === 'string' && type !== null) {
+            const annotation = { type, description: message.value, lineStart: this.file.source.line(call.start) };
+            return { kind: 'annotations', items: [annotation], problems: [] };
+        }
+        const source = snippet(text(this.file, call));
+        const unresolved = [message, second].find((item) => item && !item.ok);
+        const from = unresolved && !unresolved.ok ? unresolved.importedFrom : null;
+        const missing = problem('unresolved-annotation', call, `Annotation ${source}${origin(from)} could not be worked out; it is missing.`, source);
+        return { kind: 'annotations', items: [], problems: [missing] };
+    }
     declaration(call, kind, links, context) {
         const args = call.arguments;
         const callee = snippet(text(this.file, call.callee));
@@ -548,6 +592,7 @@ export class VitestAdapter {
         // (title, fn, timeout), (title, options, fn) or the removed (title, fn, options)
         let options;
         let body;
+        let timeout;
         let refusal = null;
         const [second, third] = [args.at(1), args.at(2)];
         if (args.some((arg) => arg.type === 'SpreadElement')) {
@@ -565,9 +610,23 @@ export class VitestAdapter {
                 }
                 options = third;
             }
+            else if (third === undefined ||
+                isFunctionNode(second) ||
+                namedFunction(this.file, context.scopes, second) ||
+                this.file.values.resolve(third, context.scopes).ok) {
+                // With imported options and a body passed by name, either could be the body, so the third is no timeout.
+                timeout = third;
+            }
         }
         const fn = isFunctionNode(body) ? body : null;
         const read = this.readDeclarationOptions(options, context, problems);
+        if (timeout) {
+            const node = timeout;
+            const option = { node, resolved: this.file.values.resolve(node, context.scopes) };
+            const value = readCount(this.file, 'timeout', option, problems);
+            if (value !== null)
+                read.details.run.timeout = value;
+        }
         const chain = new Set(links.filter((link) => MODIFIERS[kind].has(link.name)).map((link) => link.name));
         const flags = new Set(chain);
         let conditions = links.filter((link) => CONDITIONS.has(link.name)).map((link) => this.linkCondition(link, context));
@@ -632,7 +691,14 @@ export class VitestAdapter {
             declared = { kind: 'describe', ...base, isShuffled: flags.has('shuffle'), passesDown };
         }
         else {
-            declared = { kind: 'test', ...base, testContext: skipNames(fn, table?.name === 'for' ? 1 : table ? null : 0) };
+            const index = table?.name === 'for' ? 1 : table ? null : 0;
+            declared = {
+                kind: 'test',
+                ...base,
+                testContext: contextNames(base.hashed, index),
+                fixtures: fixturesOf(base.hashed, index, this.file.version),
+                usesBench: atLeast(this.file.version, 5, 0) && destructuredNames(base.hashed, index).includes('bench'),
+            };
         }
         return refusal ? refused(call, refusal, context, () => declared) : declared;
     }
@@ -680,7 +746,7 @@ export class VitestAdapter {
         return fails;
     }
     readDeclarationOptions(node, context, problems) {
-        const details = { tags: [], annotations: [], locks: [], meta: null };
+        const details = { tags: [], annotations: [], locks: [], meta: null, run: {} };
         const result = {
             flags: new Map(),
             concurrent: null,
@@ -723,8 +789,46 @@ export class VitestAdapter {
         const meta = options.values.get('meta');
         if (meta)
             details.meta = this.meta(meta, context, problems);
+        for (const key of ['timeout', 'repeats']) {
+            const option = options.values.get(key);
+            const value = option ? readCount(this.file, key, option, problems) : null;
+            if (value !== null)
+                details.run[key] = value;
+        }
+        const retry = options.values.get('retry');
+        if (retry)
+            this.retry(retry, details, context, problems);
         return result;
     }
+    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`; the runner ignores an object before. */
+    retry(option, details, context, problems) {
+        const node = unwrap(option.node);
+        if (node.type !== 'ObjectExpression') {
+            const count = readCount(this.file, 'retry', option, problems);
+            if (count !== null)
+                details.run.retry = { count, delay: null, condition: null };
+            return;
+        }
+        if (!atLeast(this.file.version, 4, 1))
+            return;
+        const values = readOptions(this.file, context.scopes, node);
+        problems.push(...unresolvedOptions(this.file, values, 'the retry is not applied'));
+        const read = (key) => {
+            const value = values.values.get(key);
+            return value ? readCount(this.file, `retry.${key}`, value, problems) : undefined;
+        };
+        const count = read('count');
+        const delay = read('delay');
+        if (count === null)
+            return;
+        const condition = values.values.get('condition');
+        details.run.retry = {
+            // Vitest retries 0 times when the object has no count.
+            count: count ?? 0,
+            delay: delay ?? null,
+            condition: condition ? snippet(text(this.file, condition.node)) : null,
+        };
+    }
     meta(option, context, problems) {
         const entries = readOptions(this.file, context.scopes, option.node);
         problems.push(...unresolvedOptions(this.file, entries, 'its meta values are missing'));
@@ -781,19 +885,32 @@ function templateRows(template) {
 function isMetaValue(value) {
     return value !== undefined;
 }
-function skipNames(fn, index) {
+function contextNames(fn, index) {
     const parameter = index === null ? undefined : fn?.params[index];
     if (!parameter)
         return null;
-    const names = { objects: new Set(), functions: new Set() };
+    const names = { objects: new Set(), skip: new Set(), annotate: new Set() };
     if (parameter.type === 'Identifier')
         names.objects.add(parameter.name);
     if (parameter.type === 'ObjectPattern') {
         for (const property of parameter.properties) {
-            if (property.type === 'Property' && propertyKey(property) === 'skip' && property.value.type === 'Identifier') {
-                names.functions.add(property.value.name);
+            const key = property.type === 'Property' ? propertyKey(property) : null;
+            if ((key === 'skip' || key === 'annotate') &&
+                property.type === 'Property' &&
+                property.value.type === 'Identifier') {
+                names[key].add(property.value.name);
             }
         }
     }
     return names;
 }
+/** Whether a call is `name(...)` for a context function taken out of the context, or `context.name(...)`. */
+function callsContext(call, names, member) {
+    const callee = unwrap(call.callee);
+    return callee.type === 'Identifier'
+        ? names[member].has(callee.name)
+        : callee.type === 'MemberExpression' &&
+            propertyName(callee) === member &&
+            callee.object.type === 'Identifier' &&
+            names.objects.has(callee.object.name);
+}

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export { scanSource } from './scan-source.ts';
 export { filterInventory, pickTestFields } from './filter.ts';
 export type { InventoryFilter, PickedInventory } from './filter.ts';
 export type { CommentsMode, ScanOptions, ScanSourceOptions } from './options.ts';
-export type { Annotation, DeclaredAt, Diagnostic, DiagnosticCode, DiagnosticLevel, Framework, Inventory, InventoryLine, MetaValue, StateSource, SuiteRecord, Summary, TestRecord, TestState, Tool, } from './types.ts';
+export type { Annotation, DeclaredAt, Diagnostic, DiagnosticCode, DiagnosticLevel, FileRecord, Framework, HookCounts, Inventory, InventoryLine, MetaValue, StateSource, SuiteRecord, Summary, TestRecord, TestState, Tool, } from './types.ts';

package/dist/inventory.js

@@ -10,6 +10,7 @@ export function createInventory(framework, frameworkVersion, fileCount, files, p
         framework,
         frameworkVersion,
         summary: summarize(fileCount, suites, tests, diagnostics),
+        files: files.map((file) => file.file),
         suites,
         tests,
         diagnostics,

package/dist/json.js

@@ -48,6 +48,8 @@ export async function writeInventoryLines(inventory, write) {
     const line = (type, record) => emit(`${JSON.stringify({ type, ...record })}\n`);
     const { schemaVersion, tool, framework, frameworkVersion } = inventory;
     await line('inventory', { schemaVersion, tool, framework, frameworkVersion });
+    for (const file of inventory.files)
+        await line('file', file);
     for (const suite of inventory.suites)
         await line('suite', suite);
     for (const test of inventory.tests)

package/dist/model.d.ts

@@ -1,6 +1,6 @@
 import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { FunctionNode } from './ast.ts';
-import type { Annotation, DiagnosticCode, DiagnosticLevel, MetaValue } from './types.ts';
+import type { Annotation, DiagnosticCode, DiagnosticLevel, HookCounts, MetaValue } from './types.ts';
 export type State = 'skip' | 'fixme' | 'todo' | 'expectedToFail';
 export type Mode = 'parallel' | 'serial' | 'default';
 /** A state set by a declaration, a describe or a call such as `test.skip(condition)`. */
@@ -45,6 +45,22 @@ export interface Details {
     annotations: Annotation[];
     locks: string[];
     meta: Record<string, MetaValue> | null;
+    run: RunSettings;
+}
+/** Run settings written in one place; a key that is missing is not set there. */
+export interface RunSettings {
+    timeout?: number;
+    /** A retry setting replaces the whole `retry` of the describes around, delay and condition included. */
+    retry?: {
+        count: number;
+        delay: number | null;
+        condition: string | null;
+    };
+    repeats?: number;
+    /** Playwright `test.slow()`: the conditions of the calls, any of which makes the test slow; null when one always does. */
+    slow?: {
+        conditions: string[] | null;
+    };
 }
 interface Declaration {
     title: Title | null;
@@ -65,6 +81,10 @@ export interface TestDeclaration extends Declaration {
     title: Title;
     /** Framework-specific names through which the test body can change its own state, such as Vitest's `context.skip`. */
     testContext: unknown;
+    /** Names the test function takes from its context, without the framework's own keys. */
+    fixtures: string[];
+    /** Uses Vitest 5's `bench` fixture. */
+    usesBench: boolean;
 }
 export interface SuiteDeclaration extends Declaration {
     kind: 'describe';
@@ -85,16 +105,33 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     hasDynamicReason: boolean;
     problems: Problem[];
 }
-/** `test.describe.configure()`: a mode, locks (Playwright 1.64), or both. */
+/** `test.describe.configure()`: a mode, locks (Playwright 1.64), a timeout and retries. */
  | {
     kind: 'configure';
     mode: Mode | null;
     locks: string[];
+    run: RunSettings;
+    problems: Problem[];
+}
+/** Playwright `test.setTimeout()` or `test.slow()`, which apply where they are called. */
+ | {
+    kind: 'run';
+    settings: RunSettings;
+    /** Source text of the first argument. */ argument: string | null;
     problems: Problem[];
 } | {
     kind: 'hook';
+    name: keyof HookCounts;
     fn: FunctionNode | null;
     testContext: unknown;
+    fixtures: string[];
+}
+/** Playwright `test.step()` or `test.step.skip()`. */
+ | {
+    kind: 'step';
+    title: Title;
+    isSkipped: boolean;
+    fn: FunctionNode | null;
 } | {
     kind: 'annotations';
     items: Annotation[];

package/dist/records.d.ts

@@ -1,9 +1,10 @@
-import type { Extraction } from './extract.ts';
+import { type Extraction } from './extract.ts';
 import type { ParsedFile } from './parse.ts';
-import type { Diagnostic, Framework, SuiteRecord, TestRecord } from './types.ts';
+import type { Diagnostic, FileRecord, Framework, HookCounts, SuiteRecord, TestRecord } from './types.ts';
 /** @inline */
 export type CommentsMode = 'all' | 'non-active' | 'none';
 export interface FileRecords {
+    file: FileRecord;
     suites: SuiteRecord[];
     tests: TestRecord[];
     diagnostics: Diagnostic[];
@@ -13,7 +14,11 @@ interface RecordOptions {
     framework: Framework;
     comments: CommentsMode;
     isTypeTest: boolean;
+    /** A Vitest 5 benchmark file, such as `*.bench.ts`. */
+    isBenchmarkFile: boolean;
 }
+/** The record of a scanned file, from its records and the hooks at its top level. */
+export declare function fileRecord(relativeFilePath: string, hooks: HookCounts, records: Pick<FileRecords, 'suites' | 'tests'>): FileRecord;
 /** An error for each id used by more than one record. Ordinals keep ids apart, so only a hash collision causes one. */
 export declare function duplicateIdDiagnostics(records: readonly {
     id: string;

package/dist/records.js

@@ -1,4 +1,5 @@
 import { REJECTS_FILE, toDiagnostic } from "./diagnostics.js";
+import { anySlow, eitherCondition, noHooks, } from "./extract.js";
 import { problem } from "./frameworks/common.js";
 import { hashNodes, shortHash } from "./hash.js";
 /**
@@ -29,6 +30,47 @@ function bodyNodes(fn) {
     const body = fn.body;
     return body.type === 'BlockStatement' ? body.body : [body];
 }
+function addHooks(scopes) {
+    const total = noHooks();
+    for (const scope of scopes) {
+        for (const name of Object.keys(total))
+            total[name] += scope.hooks[name];
+    }
+    return total;
+}
+/**
+ * The run settings that apply, from the places that set them, nearest first: the first that sets a key wins, and any
+ * `test.slow()` makes the test slow.
+ */
+function runKeys(places) {
+    const first = (key) => places.find((place) => place[key] !== undefined)?.[key];
+    const retry = first('retry');
+    const slows = places.flatMap((place) => place.slow ?? []);
+    return {
+        timeout: first('timeout') ?? null,
+        isSlow: slows.length > 0,
+        slowCondition: eitherCondition(anySlow(slows).conditions ?? []) || null,
+        retries: retry?.count ?? null,
+        retryDelay: retry?.delay ?? null,
+        retryCondition: retry?.condition ?? null,
+        repeats: first('repeats') ?? null,
+    };
+}
+/** The record of a scanned file, from its records and the hooks at its top level. */
+export function fileRecord(relativeFilePath, hooks, records) {
+    return {
+        relativeFilePath,
+        fileName: relativeFilePath.slice(relativeFilePath.lastIndexOf('/') + 1),
+        hooks,
+        suiteCount: records.suites.length,
+        testCount: records.tests.length,
+    };
+}
+/** Whether a function's block holds no statements; comments are not statements. */
+function hasNoStatements(fn) {
+    const body = fn?.body;
+    return body?.type === 'BlockStatement' && body.body.length === 0;
+}
 /** The number of times the runner repeats a test: its own cases times those of each describe table around it. */
 function repetitions(counts) {
     let product = 1;
@@ -71,7 +113,12 @@ class RecordBuilder {
         this.diagnostics.push(...duplicateIdDiagnostics([...suites, ...tests], this.options.relativeFilePath));
         // Diagnostics for the whole file have no line, which sorts as 0, before the others.
         const diagnostics = this.diagnostics.sort((a, b) => Number(a.lineStart) - Number(b.lineStart) || Number(a.columnStart) - Number(b.columnStart));
-        return { suites, tests, diagnostics };
+        return {
+            file: fileRecord(this.options.relativeFilePath, extraction.hooks, { suites, tests }),
+            suites,
+            tests,
+            diagnostics,
+        };
     }
     diagnostic(item, testId = null) {
         return toDiagnostic(item, this.options.relativeFilePath, this.parsed.source, testId);
@@ -136,6 +183,8 @@ class RecordBuilder {
             annotations: scope.details.annotations,
             locks: unique(scope.details.locks),
             meta: scope.details.meta,
+            hooks: { ...scope.hooks },
+            ...runKeys([scope.details.run]),
         };
     }
     test(pending) {
@@ -172,6 +221,10 @@ class RecordBuilder {
         const tables = [declaration, ...describes.map((scope) => suiteOf(scope).declaration)].filter((item) => item.isParameterized);
         for (const item of pending.problems)
             this.diagnostics.push(this.diagnostic(item, id));
+        if (declaration.usesBench && !this.options.isBenchmarkFile) {
+            const message = 'The test uses the bench fixture, which Vitest only provides in benchmark files such as *.bench.ts; elsewhere the test fails.';
+            this.diagnostics.push(this.diagnostic(problem('bench-outside-benchmark-file', located, message), id));
+        }
         if (pending.isInLoop) {
             this.diagnostics.push(this.diagnostic(problem('test-in-loop', located, 'The test is declared in a loop; it is listed once, while the runner creates one test per iteration.'), id));
         }
@@ -221,6 +274,21 @@ class RecordBuilder {
                 ...declaration.details.locks,
             ]),
             meta: Object.keys(meta).length > 0 ? meta : null,
+            hooks: addHooks(scopes),
+            // Calls in the body and in `beforeEach` hooks run last, so they win over what the describes set.
+            ...runKeys([
+                pending.run,
+                ...scopes.map((scope) => scope.hookRun),
+                declaration.details.run,
+                ...scopes.map((scope) => scope.details.run),
+            ]),
+            fixtures: unique([...declaration.fixtures, ...[...scopes].reverse().flatMap((scope) => scope.hookFixtures)]),
+            expectCount: pending.expectCount,
+            expectedAssertions: pending.expectedAssertions,
+            expectsAssertions: pending.expectsAssertions,
+            hasEmptyBody: hasNoStatements(declaration.hashed),
+            steps: pending.steps,
+            isBenchmark: this.options.isBenchmarkFile || declaration.usesBench,
             isParameterized: tables.length > 0,
             caseCount: tables.length > 0 ? repetitions(tables.map((item) => item.caseCount)) : null,
             isInLoop: pending.isInLoop,