test-inventory 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # test-inventory
 
+## 0.1.2
+
+### Patch Changes
+
+- [#13](https://github.com/Huldoser/test-inventory/pull/13) [`89a029f`](https://github.com/Huldoser/test-inventory/commit/89a029f9e45c2aaa57b5f907717bb8f00829e335) - Locks set with `test.describe.configure({ lock })`, new in Playwright 1.64, are added to every test in the file or describe where the call is made. They were dropped before.
+
+- [#13](https://github.com/Huldoser/test-inventory/pull/13) [`89a029f`](https://github.com/Huldoser/test-inventory/commit/89a029f9e45c2aaa57b5f907717bb8f00829e335) - From Vitest 5, a file that calls `vi.mock`, `vi.unmock` or `vi.hoisted` anywhere but its top level gets a `removed-api` error at the call, and its tests are `notLoaded`, as Vitest refuses the file. Files with in-source tests are not checked, as in Vitest.
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/extract.js

@@ -12,6 +12,12 @@ function calledWhereWritten(call, written) {
         !call.inBody);
 }
 const LOOP_METHODS = new Set(['forEach', 'map']);
+/** What `test.describe.configure()` sets on the describe or file it is called in: the last mode wins, locks add up. */
+function configure(scope, settings) {
+    if (settings.mode)
+        scope.mode = settings.mode;
+    scope.details.locks.push(...settings.locks);
+}
 /** Joins conditions with `&&`, adding parentheses where a part could otherwise be read differently. */
 function joinConditions(parts) {
     if (parts.length <= 1)
@@ -251,11 +257,14 @@ class Walker {
                     (context.test ?? context.hookScope ?? context.scope).states.push(setting);
                 return true;
             }
-            case 'mode':
-                if (context.helper)
-                    this.effectsOf(context.helper).push({ kind: 'mode', mode: api.mode, call });
-                else if (!context.test && !context.hookScope)
-                    context.scope.mode = api.mode;
+            case 'configure':
+                this.problems.push(...api.problems);
+                if (context.helper) {
+                    this.effectsOf(context.helper).push({ kind: 'configure', mode: api.mode, locks: api.locks, call });
+                }
+                else if (!context.test && !context.hookScope) {
+                    configure(context.scope, api);
+                }
                 return true;
             case 'hook':
                 if (context.test)
@@ -355,7 +364,7 @@ class Walker {
             return (this.effects.get(fn) ?? []).flatMap((effect) => {
                 if (effect.kind === 'call')
                     return expand(effect.fn, [...guards, ...effect.guards], new Set([...path, fn]));
-                if (effect.kind === 'mode')
+                if (effect.kind === 'configure')
                     return [effect];
                 const condition = joinConditions([...guards, ...(effect.setting.condition ? [effect.setting.condition] : [])]);
                 return [{ ...effect, setting: { ...effect.setting, condition } }];
@@ -366,7 +375,7 @@ class Walker {
                 if (effect.kind === 'state')
                     call.target.states.push(effect.setting);
                 else if (call.scope)
-                    call.scope.mode = effect.mode;
+                    configure(call.scope, effect);
             }
         }
         for (const [fn, effects] of this.effects) {

package/dist/frameworks/playwright.js

@@ -429,17 +429,31 @@ export class PlaywrightAdapter {
     }
     configure(call, context) {
         const options = call.arguments[0] ? readOptions(this.file, context.scopes, call.arguments[0]) : null;
-        const mode = options?.values.get('mode');
-        if (mode?.resolved.ok && ['parallel', 'serial', 'default'].includes(mode.resolved.value)) {
-            return { kind: 'mode', mode: mode.resolved.value };
+        const option = options?.values.get('mode');
+        const mode = option?.resolved.ok && ['parallel', 'serial', 'default'].includes(option.resolved.value)
+            ? option.resolved.value
+            : null;
+        const problems = mode
+            ? []
+            : [
+                ...(options ? unresolvedOptions(this.file, options, 'the mode is unknown') : []),
+                ...(option && !option.resolved.ok
+                    ? [unresolvedOption(this.file, 'mode', option.node, option.resolved.importedFrom, 'the mode is unknown')]
+                    : []),
+            ];
+        const locks = [];
+        const lock = options?.values.get('lock');
+        if (lock && atLeast(this.file.version, 1, 64)) {
+            const strings = readStrings(this.file, context.scopes, lock);
+            locks.push(...strings.values);
+            for (const { node: unresolved, importedFrom } of strings.unresolved) {
+                problems.push(unresolvedOption(this.file, 'lock', unresolved, importedFrom, 'the lock is missing'));
+            }
+        }
+        if (!mode && locks.length === 0) {
+            return problems.length > 0 ? { kind: 'invalid', problem: problems[0] } : { kind: 'other' };
         }
-        const problems = [
-            ...(options ? unresolvedOptions(this.file, options, 'the mode is unknown') : []),
-            ...(mode && !mode.resolved.ok
-                ? [unresolvedOption(this.file, 'mode', mode.node, mode.resolved.importedFrom, 'the mode is unknown')]
-                : []),
-        ];
-        return problems.length > 0 ? { kind: 'invalid', problem: problems[0] } : { kind: 'other' };
+        return { kind: 'configure', mode, locks, problems };
     }
     /** `test.info().annotations.push(...)` inside a test body. */
     annotationsPush(call, links, context) {

package/dist/frameworks/vitest.js

@@ -1,4 +1,4 @@
-import { isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap } from "../ast.js";
+import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
 import { allDeclarators, bindAll, exportName, followImport, 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";
@@ -28,6 +28,56 @@ const HOOKS = new Map([
 ]);
 /** First members that show a name imported from a local file is used as Vitest's `test`. */
 const TEST_MEMBERS = new Set([...MODIFIERS.test, ...MODIFIERS.describe, ...TABLES, ...CONDITIONS, ...KINDS.keys()]);
+/** Calls Vitest moves to the top of the file before running it: `vi.mock`, `vi.unmock` and `vi.hoisted`. */
+const HOISTED_OBJECTS = new Set(['vi', 'vitest']);
+const HOISTED_METHODS = new Set(['mock', 'unmock', 'hoisted']);
+/**
+ * The hoisted calls that are not written at the top level of the file, where Vitest moves them. Vitest 5 fails such a
+ * file while it loads it. As in Vitest, `const value = vi.hoisted(...)` and `await vi.hoisted(...)` count as top
+ * level, and a file with in-source tests is never checked.
+ */
+function nestedHoistedCalls(program) {
+    if (hasInSourceTests(program))
+        return [];
+    const topLevel = new Set(program.body);
+    for (const statement of program.body) {
+        if (statement.type === 'ExpressionStatement')
+            topLevel.add(statement.expression);
+    }
+    const found = [];
+    const parents = [];
+    const visit = (node) => {
+        if (node.type === 'CallExpression' && node.callee.type === 'MemberExpression') {
+            const { object, property } = node.callee;
+            const method = !node.callee.computed && property.type === 'Identifier' ? property.name : '';
+            if (object.type === 'Identifier' && HOISTED_OBJECTS.has(object.name) && HOISTED_METHODS.has(method)) {
+                if (!topLevel.has(method === 'hoisted' ? hoistedValue(node, parents) : node))
+                    found.push(node);
+            }
+        }
+        parents.push(node);
+        for (const child of childNodes(node))
+            visit(child);
+        parents.pop();
+    };
+    visit(program);
+    return found;
+}
+/** Whether the file has in-source tests, which read `import.meta.vitest`. */
+function hasInSourceTests(node) {
+    return (node.type === 'MemberExpression' && isImportMetaVitest(node)) || childNodes(node).some(hasInSourceTests);
+}
+/** What Vitest moves for a `vi.hoisted` call: the declaration it initializes, the `await` around it, or the call. */
+function hoistedValue(call, parents) {
+    const declaration = parents.findLast((node) => node.type === 'VariableDeclaration');
+    const init = declaration?.type === 'VariableDeclaration' ? declaration.declarations[0]?.init : null;
+    const value = init ? unwrap(init) : null;
+    if (declaration && (value === call || (value?.type === 'AwaitExpression' && unwrap(value.argument) === call))) {
+        return declaration;
+    }
+    const parent = parents.at(-1);
+    return parent?.type === 'AwaitExpression' ? parent : call;
+}
 /** The names a file binds to Vitest's `test`, `describe`, hooks and namespace. */
 class VitestBindings {
     kinds = new Map();
@@ -158,6 +208,12 @@ export class VitestAdapter {
         this.readModule = readModule;
         this.bindings = new VitestBindings(parsed.program, file.version);
         this.problems = [...this.bindings.problems];
+        if (atLeast(file.version, 5, 0)) {
+            for (const call of nestedHoistedCalls(parsed.program)) {
+                const callee = snippet(text(this.file, call.callee));
+                this.problems.push(problem('removed-api', call, `Vitest 5 fails a file that calls ${callee}(...) anywhere but its top level, because the call is hoisted there.`, callee));
+            }
+        }
         this.imports = moduleImports(parsed.program, (source) => source === 'vitest' || MISMATCHED_SOURCES.has(source));
         if (atLeast(file.version, 4, 1)) {
             // Vitest's own pattern, over the whole text as Vitest reads it, so the same tags come out.

package/dist/model.d.ts

@@ -77,9 +77,13 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     reason: string | null;
     hasDynamicReason: boolean;
     problems: Problem[];
-} | {
-    kind: 'mode';
-    mode: Mode;
+}
+/** `test.describe.configure()`: a mode, locks (Playwright 1.64), or both. */
+ | {
+    kind: 'configure';
+    mode: Mode | null;
+    locks: string[];
+    problems: Problem[];
 } | {
     kind: 'hook';
     fn: FunctionNode | null;

package/dist/options.d.ts

@@ -1,6 +1,7 @@
 import type { CommentsMode } from './records.ts';
 import type { Framework } from './types.ts';
 export type { CommentsMode };
+/** @inline */
 export interface ScanOptions {
     /** Glob patterns for the test files, relative to `root`. */
     patterns: string[];
@@ -14,6 +15,7 @@ export interface ScanOptions {
     /** Which tests get the comments above them. Defaults to `non-active`. */
     comments?: CommentsMode;
 }
+/** @inline */
 export interface ScanSourceOptions {
     code: string;
     /** Path of the file from the project root, used in the output and in ids. */

package/dist/records.d.ts

@@ -1,6 +1,7 @@
 import type { Extraction } from './extract.ts';
 import type { ParsedFile } from './parse.ts';
 import type { Diagnostic, Framework, SuiteRecord, TestRecord } from './types.ts';
+/** @inline */
 export type CommentsMode = 'all' | 'non-active' | 'none';
 export interface FileRecords {
     suites: SuiteRecord[];

package/dist/records.js

@@ -203,7 +203,11 @@ class RecordBuilder {
             ]),
             annotations: [...describes.flatMap((scope) => scope.details.annotations), ...pending.annotations],
             comments,
-            locks: unique([...describes.flatMap((scope) => scope.details.locks), ...declaration.details.locks]),
+            locks: unique([
+                ...fileScope.details.locks,
+                ...describes.flatMap((scope) => scope.details.locks),
+                ...declaration.details.locks,
+            ]),
             meta: Object.keys(meta).length > 0 ? meta : null,
             isParameterized: tables.length > 0,
             caseCount: tables.length > 0 ? repetitions(tables.map((item) => item.caseCount)) : null,

package/dist/types.d.ts

@@ -10,15 +10,26 @@ type Count = number;
 type Position = number;
 /** @pattern ^[0-9a-f]{16}$ */
 type Hash = string;
+/** @inline */
 export type Framework = 'playwright' | 'vitest';
 /**
  * The state the runner applies to a test, after describes and file-level calls are taken into account. `notLoaded`:
  * the runner refuses to load the file, so none of its tests run.
+ *
+ * @inline
  */
 export type TestState = 'active' | 'skip' | 'fixme' | 'todo' | 'expectedToFail' | 'notLoaded';
-/** Where a test's state is set: on the test, on a describe around it, or at file level. */
+/**
+ * Where a test's state is set: on the test, on a describe around it, or at file level.
+ *
+ * @inline
+ */
 export type StateSource = 'test' | 'suite' | 'file';
-/** `error`: tests may be missing from the output. `warning`: a value is missing or approximate. */
+/**
+ * `error`: tests may be missing from the output. `warning`: a value is missing or approximate.
+ *
+ * @inline
+ */
 export type DiagnosticLevel = 'error' | 'warning';
 export type DiagnosticCode = 'unresolved-test-import' | 'parse-error' | 'read-error' | 'framework-mismatch' | 'unresolved-tag' | 'unresolved-annotation' | 'unresolved-cases' | 'test-in-loop' | 'dynamic-title' | 'duplicate-title' | 'duplicate-id' | 'internal-error' | 'invalid-chain' | 'skip-without-body' | 'test-without-body' | 'describe-not-called' | 'async-describe' | 'nested-test' | 'tag-without-at' | 'removed-api' | 'only-in-skipped-describe' | 'config-may-change-state' | 'symlink-ignored' | 'invalid-import' | 'globals-not-enabled' | 'unknown-framework-version' | 'unsupported-framework-version' | 'local-test-object' | 'state-in-helper' | 'unresolved-option' | 'dynamic-reason' | 'no-files-matched' | 'unsupported-file' | 'approximate-framework-version' | 'test-in-function';
 export type MetaValue = string | number | boolean | null | MetaValue[] | {
@@ -38,6 +49,7 @@ export interface Inventory {
     tests: TestRecord[];
     diagnostics: Diagnostic[];
 }
+/** @inline */
 export interface Tool {
     name: 'test-inventory';
     /** Version of test-inventory that produced the output. */
@@ -184,7 +196,7 @@ export interface TestRecord {
     annotations: Annotation[];
     /** Comment lines directly above the test. By default only filled for tests that are not active. */
     comments: string[];
-    /** From the test and its describes. Playwright only. */
+    /** From the test, its describes and the `test.describe.configure()` calls around it. Playwright only. */
     locks: string[];
     /** Merged from the describes and the test. Vitest only; literal values only. */
     meta: Record<string, MetaValue> | null;
@@ -202,6 +214,7 @@ export interface TestRecord {
     /** Declared inside a plain function. */
     isInFunction: boolean;
 }
+/** @inline */
 export interface Annotation {
     type: string;
     description: string | null;

package/package.json

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

package/schema/v1.json

@@ -646,7 +646,7 @@
           "items": {
             "type": "string"
           },
-          "description": "From the test and its describes. Playwright only."
+          "description": "From the test, its describes and the `test.describe.configure()` calls around it. Playwright only."
         },
         "meta": {
           "anyOf": [