test-inventory 0.5.0 → 0.6.1

package/dist/records.d.ts

@@ -1,4 +1,5 @@
-import { type Extraction } from './extract.ts';
+import { type Extraction, type PendingTest } from './extract.ts';
+import type { Dependencies } from './dependency-hash.ts';
 import type { RunSettings } from './model.ts';
 import type { ParsedFile } from './parse.ts';
 import type { Diagnostic, FileRecord, Framework, HookCounts, MetaValue, SuiteRecord, TestRecord } from './types.ts';
@@ -60,6 +61,8 @@ export interface FileConfig {
     };
     /** Vitest's tags; null when the scan can't work them out, or the projects that run the file define different ones. */
     tags: VitestTags | null;
+    /** The tags Playwright's config `tag` gives every test, before the test's own. */
+    configTags: string[];
 }
 interface RecordOptions {
     relativeFilePath: string;
@@ -69,6 +72,8 @@ interface RecordOptions {
     /** A Vitest 5 benchmark file, such as `*.bench.ts`. */
     isBenchmarkFile: boolean;
     config: FileConfig | null;
+    /** What a test runs, for its `dependencyHash`. */
+    dependencies: (test: PendingTest) => Dependencies;
 }
 /** 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;

package/dist/records.js

@@ -314,7 +314,7 @@ class RecordBuilder {
         };
     }
     /** What the config's Vitest tags set on a test with `tags`, merged as Vitest merges them; null when none applies. */
-    tagOptions(tags) {
+    tagOptions(tags, ownStateOptions) {
         const definitions = this.options.config?.tags?.definitions ?? [];
         const applied = tags.flatMap((name) => definitions.filter((definition) => definition.name === name));
         if (applied.length === 0)
@@ -330,10 +330,14 @@ class RecordBuilder {
             if (meta)
                 merged.meta = { ...merged.meta, ...meta };
         }
+        // Vitest merges the test's own options over its tags', so `skip: false` runs a test whose tag skips it.
+        for (const option of ownStateOptions)
+            merged[option] = undefined;
         return merged;
     }
     test(pending, suites) {
         const { declaration } = pending;
+        const dependencies = this.options.dependencies(pending);
         // A test from an imported helper is placed at the call in this file that registers it.
         const located = pending.site ?? pending.call;
         const scopes = outward(pending.scope);
@@ -342,11 +346,12 @@ class RecordBuilder {
         const id = this.id([this.describeTitles(describes), title.withoutTags]);
         const fileScope = scopes[scopes.length - 1];
         const tags = unique([
+            ...(this.options.config?.configTags ?? []),
             ...fileScope.details.tags,
             ...describes.flatMap((scope) => scope.details.tags),
             ...declaration.details.tags,
         ]);
-        const fromTags = this.tagOptions(tags);
+        const fromTags = this.tagOptions(tags, declaration.ownStateOptions ?? []);
         // In Vitest 5 the options of a test's tags win over those the describes pass down; before, the describes' win.
         const tagsFirst = this.options.config?.tags?.beatsDescribes ?? true;
         const tagged = (own, tag, around) => tagsFirst ? [...own, ...tag, ...around] : [...own, ...around, ...tag];
@@ -396,6 +401,9 @@ class RecordBuilder {
         const record = {
             id,
             bodyHash: declaration.hashed ? hashNodes([declaration.hashed]) : null,
+            dependencyHash: dependencies.hash,
+            dependencies: dependencies.files,
+            hasUnfollowedDependencies: !dependencies.isComplete,
             suiteId: describes.length > 0 ? this.suiteIds.get(describes[describes.length - 1]) : null,
             suitePath,
             relativeFilePath: this.options.relativeFilePath,

package/dist/resolve.js

@@ -1,3 +1,4 @@
+import { isUtf8 } from 'node:buffer';
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { globSync } from 'tinyglobby';
@@ -8,7 +9,7 @@ function isFile(file) {
 }
 /** The file a path refers to, found the way TypeScript and Node do: as is, with an extension, or a folder's index. */
 function findFile(base) {
-    const stripped = base.replace(/\.[cm]?js$/, '');
+    const stripped = base.replace(/\.(?:[cm]?js|jsx)$/, '');
     const candidates = [
         base,
         ...EXTENSIONS.map((extension) => stripped + extension),
@@ -42,6 +43,16 @@ function readText(file) {
         return null;
     }
 }
+/** A file's text, with its bytes too when it isn't UTF-8 text, as an image isn't; null when it can't be read. */
+function readContent(file) {
+    try {
+        const bytes = readFileSync(file);
+        return isUtf8(bytes) ? { code: bytes.toString('utf8') } : { code: bytes.toString('utf8'), bytes };
+    }
+    catch {
+        return null;
+    }
+}
 function readJson(file) {
     const text = isFile(file) ? readText(file) : null;
     return text === null ? null : record(parseJsonc(text));
@@ -362,17 +373,24 @@ export function moduleResolver(root) {
         }
         else {
             const options = optionsFor(directory);
-            const aliased = options ? aliasFiles(specifier, options) : null;
+            const targets = options ? aliasFiles(specifier, options) : null;
+            const aliased = targets?.find((file) => findFile(file) !== null);
             if (aliased) {
-                candidates = aliased;
+                candidates = [aliased];
             }
             else {
-                // `baseUrl` turns any name into a path, so a name not found there may still be a workspace package.
+                // TypeScript goes on to the usual lookup when no file of a matching alias exists. `baseUrl` turns any name
+                // into a path, so a name not found there may still be a workspace package.
                 const fromBaseUrl = options?.baseUrl ? findFile(path.resolve(options.baseUrl, specifier)) : null;
                 const workspace = fromBaseUrl ? null : workspaceSource(specifier, directory, packagesOf);
                 if (workspace && 'reason' in workspace)
                     return workspace;
                 const file = fromBaseUrl ?? workspace?.file;
+                // No package name starts with `@/` or `~/`, so these are aliases, as Vite's `resolve.alias` sets them; any
+                // other name with no file may still be a package or a built-in module, as TypeScript takes it to be.
+                if (!file && /^[@~]\//.test(specifier)) {
+                    return { reason: targets ? 'could not be read' : 'is a path alias that no tsconfig paths define' };
+                }
                 if (!file)
                     return { reason: 'is not a local file, a path alias or a workspace package' };
                 candidates = [file];
@@ -382,10 +400,12 @@ export function moduleResolver(root) {
         if (!found)
             return { reason: 'could not be read' };
         if (!modules.has(found)) {
-            const code = readText(found);
-            modules.set(found, code === null
-                ? null
-                : { code, relativeFilePath: path.relative(root, found).replaceAll('\\', '/'), readModule: reader(found) });
+            const content = readContent(found);
+            modules.set(found, content && {
+                ...content,
+                relativeFilePath: path.relative(root, found).replaceAll('\\', '/'),
+                readModule: reader(found),
+            });
         }
         return modules.get(found) ?? { reason: 'could not be read' };
     };

package/dist/scan-file.d.ts

@@ -1,3 +1,5 @@
+import type { RunsWith } from './config-dependencies.ts';
+import { DependencyGraph, type SnapshotFiles } from './dependency-hash.ts';
 import type { ModuleReader } from './model.ts';
 import { type CommentsMode, type FileConfig, type FileRecords } from './records.ts';
 import type { Framework } from './types.ts';
@@ -13,6 +15,12 @@ export interface FileSettings {
     isBenchmarkFile?: boolean | null;
     /** What the config the file uses sets for its tests; null without a config. */
     config?: FileConfig | null;
+    /** Shared by the files of one scan, so that code many tests reach is read once. */
+    graph?: DependencyGraph;
+    /** What the file's config runs with each of its tests: the config, setup files and setup projects. */
+    runsWith?: RunsWith;
+    /** Reads the snapshot files tests compare against; none when one file's code is scanned. */
+    snapshotFiles?: SnapshotFiles;
 }
 export interface FileResult extends FileRecords {
     usesGlobals: boolean;

package/dist/scan-file.js

@@ -1,3 +1,4 @@
+import { DependencyGraph, fileDependencies } from "./dependency-hash.js";
 import { fileDiagnostic, toDiagnostic } from "./diagnostics.js";
 import { extract, noHooks } from "./extract.js";
 import { parseModule } from "./frameworks/bindings.js";
@@ -39,20 +40,28 @@ export function scanFile(code, relativeFilePath, settings) {
             const helper = parseModule(module);
             return helper.error ? null : frame(helper, module.relativeFilePath, settings, module.readModule);
         });
+        const isTypeTest = settings.framework === 'vitest' && TYPE_TEST.test(relativeFilePath);
+        const unfollowed = [];
+        const dependencies = fileDependencies(settings.graph ?? new DependencyGraph(), main, extraction, isTypeTest, (place) => unfollowed.push(place), settings.runsWith, settings.snapshotFiles);
         const records = buildRecords(extraction, parsed, {
             relativeFilePath,
             framework: settings.framework,
             comments: settings.comments,
-            isTypeTest: settings.framework === 'vitest' && TYPE_TEST.test(relativeFilePath),
+            isTypeTest,
             // Vitest 5's default `benchmark.include`, when no config says.
             isBenchmarkFile: settings.framework === 'vitest' &&
                 atLeast(settings.version, 5, 0) &&
                 (settings.isBenchmarkFile ?? BENCHMARK.test(relativeFilePath)),
             config: settings.config ?? null,
+            dependencies,
         });
         return {
             ...records,
-            diagnostics: [...diagnostics, ...records.diagnostics],
+            diagnostics: [
+                ...diagnostics,
+                ...records.diagnostics,
+                ...unfollowed.map((place) => toDiagnostic(place.problem, place.relativeFilePath, place.source)),
+            ],
             usesGlobals: extraction.usesGlobals,
         };
     }

package/dist/scan.js

@@ -1,13 +1,16 @@
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
+import { glob } from 'tinyglobby';
+import { ConfigDependencies } from "./config-dependencies.js";
 import { ConfigRuns, fileConfig } from "./config-runs.js";
 import { Configs } from "./config.js";
+import { DependencyGraph } from "./dependency-hash.js";
 import { fileDiagnostic } from "./diagnostics.js";
 import { findFiles, normalizePattern, readFailure } from "./files.js";
 import { detectFrameworkVersion, OLDEST } from "./framework-version.js";
 import { createInventory } from "./inventory.js";
-import { checkComments, checkFramework, checkObject, checkStrings, checkVersion, invalid, majorMinor, } from "./options.js";
+import { checkComments, checkFramework, checkObject, checkStrings, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
 import { moduleResolver } from "./resolve.js";
 import { noRecords, scanFile } from "./scan-file.js";
 import { globalsCheck } from "./vitest-config.js";
@@ -50,6 +53,43 @@ function folderHint(root, patterns, framework) {
 }
 /** The JavaScript and TypeScript files the runners read, which the configs choose the test files from. */
 const SCRIPT_FILES = '**/*.{js,jsx,ts,tsx,mjs,mjsx,mts,mtsx,cjs,cjsx,cts,ctsx}';
+/** Whether an error says a file or folder isn't there, as a snapshot isn't before a test first writes it. */
+function isMissing(error) {
+    return error.code === 'ENOENT';
+}
+/**
+ * The files in a folder of the project and the folders in it, linked files too, as paths in the folder with `/`;
+ * none for no folder.
+ */
+function filesIn(root, folder) {
+    const base = path.join(root, folder);
+    try {
+        return readdirSync(base, { recursive: true, withFileTypes: true })
+            .filter((entry) => entry.isFile() || (entry.isSymbolicLink() && isFile(path.join(entry.parentPath, entry.name))))
+            .map((entry) => toPosixPath(path.relative(base, path.join(entry.parentPath, entry.name))))
+            .sort();
+    }
+    catch (error) {
+        return isMissing(error) ? [] : 'unreadable';
+    }
+}
+function isFile(file) {
+    try {
+        return statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** A file's bytes, from the project root; null when there is none. */
+function bytesOf(root, file) {
+    try {
+        return readFileSync(path.join(root, file));
+    }
+    catch (error) {
+        return isMissing(error) ? null : 'unreadable';
+    }
+}
 /** Why a scan found no test files: what the patterns matched, or whether there is a config to find them from. */
 function noFiles(root, patterns, framework, placements) {
     if (patterns) {
@@ -94,10 +134,37 @@ export async function scan(options) {
     const found = await findFiles(root, patterns ?? [SCRIPT_FILES], ignore, framework);
     projectDiagnostics.push(...found.diagnostics);
     const readerFor = moduleResolver(root);
+    const graph = new DependencyGraph();
     const configs = new Configs(root, framework, readerFor, rules);
     const runs = new ConfigRuns(configs, framework, rules, patterns === null);
     const placements = new Map(found.files.map((file) => [file.absolutePath, runs.placementOf(file.absolutePath)]));
     const files = patterns ? found.files : found.files.filter((file) => placements.get(file.absolutePath)?.runs);
+    // A setup project's files may be outside the patterns, or ignored for the scan, so they are looked for in its testDir.
+    const setupDirs = new Set();
+    for (const { config, projects } of placements.values()) {
+        const seen = new Set();
+        const names = (projects ?? []).flatMap((project) => project.dependencies);
+        for (let name = names.pop(); config && name !== undefined; name = names.pop()) {
+            const project = seen.has(name) ? null : runs.projectNamed(config, name);
+            seen.add(name);
+            if (!project)
+                continue;
+            setupDirs.add(project.about.testDir);
+            names.push(...project.about.dependencies);
+        }
+    }
+    // Searched from the folder itself, as a folder named like `(auth)` would be read as a glob in a pattern.
+    const setupFiles = await Promise.all([...setupDirs].map((folder) => glob(SCRIPT_FILES, { cwd: folder, absolute: true, ignore: ['**/node_modules/**'] })));
+    const candidates = setupFiles.flat().map((file) => path.resolve(file));
+    const configDependencies = new ConfigDependencies(framework, runs, readerFor, candidates);
+    // Many tests of a file compare against one folder, so each is listed once.
+    const listed = new Map();
+    const list = (folder) => {
+        if (!listed.has(folder))
+            listed.set(folder, filesIn(root, folder));
+        return listed.get(folder);
+    };
+    const snapshotFiles = { framework, list, read: (file) => bytesOf(root, file) };
     const notRun = [];
     const results = [];
     const globalsFiles = [];
@@ -121,6 +188,7 @@ export async function scan(options) {
             });
             continue;
         }
+        const runsWith = configDependencies.of(placement);
         const result = scanFile(code, relativeFilePath, {
             framework,
             version: rules,
@@ -129,6 +197,9 @@ export async function scan(options) {
             root,
             isBenchmarkFile: placement.runs === null ? null : placement.runs === 'benchmark',
             config: fileConfig(placement, framework, rules, absolutePath),
+            graph,
+            runsWith,
+            snapshotFiles: { ...snapshotFiles, moved: runsWith.moved },
         });
         if (result.usesGlobals)
             globalsFiles.push({ absolutePath, relativeFilePath });

package/dist/types.d.ts

@@ -38,7 +38,7 @@ export type SettingSource = 'test' | 'suite' | 'file' | 'config';
  * @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' | 'undefined-tag' | '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' | 'empty-title' | 'bench-outside-benchmark-file' | 'config-value-unknown' | 'file-not-run' | 'forbidden-only';
+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' | 'undefined-tag' | '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' | 'empty-title' | 'bench-outside-benchmark-file' | 'config-value-unknown' | 'file-not-run' | 'forbidden-only' | 'dependency-not-followed';
 export type MetaValue = string | number | boolean | null | MetaValue[] | {
     [key: string]: MetaValue;
 };
@@ -250,6 +250,16 @@ export interface TestRecord {
     id: Hash;
     /** Hash of the test body, ignoring whitespace and comments; null when the test has no body. */
     bodyHash: Hash | null;
+    /**
+     * Hash of everything the test runs in the project: its call, the hooks, options and code of the file and of every
+     * describe around it, and the functions, classes, constants and modules these use, followed through imports. Ignores
+     * whitespace and comments. Installed packages are not in it.
+     */
+    dependencyHash: Hash;
+    /** The files that went into `dependencyHash`, the test's own included, sorted, with `/` separators. */
+    dependencies: string[];
+    /** Something the test reaches couldn't be followed, so a change there doesn't change `dependencyHash`. */
+    hasUnfollowedDependencies: boolean;
     /** The nearest describe; null outside any describe. */
     suiteId: Hash | null;
     /** Titles of the describes around the test, outermost first. */

package/package.json

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

package/schema/v1.json

@@ -754,6 +754,22 @@
           ],
           "description": "Hash of the test body, ignoring whitespace and comments; null when the test has no body."
         },
+        "dependencyHash": {
+          "type": "string",
+          "pattern": "^[0-9a-f]{16}$",
+          "description": "Hash of everything the test runs in the project: its call, the hooks, options and code of the file and of every describe around it, and the functions, classes, constants and modules these use, followed through imports. Ignores whitespace and comments. Installed packages are not in it."
+        },
+        "dependencies": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The files that went into `dependencyHash`, the test's own included, sorted, with `/` separators."
+        },
+        "hasUnfollowedDependencies": {
+          "type": "boolean",
+          "description": "Something the test reaches couldn't be followed, so a change there doesn't change `dependencyHash`."
+        },
         "suiteId": {
           "anyOf": [
             {
@@ -1160,6 +1176,9 @@
       "required": [
         "id",
         "bodyHash",
+        "dependencyHash",
+        "dependencies",
+        "hasUnfollowedDependencies",
         "suiteId",
         "suitePath",
         "relativeFilePath",
@@ -1426,7 +1445,8 @@
             "bench-outside-benchmark-file",
             "config-value-unknown",
             "file-not-run",
-            "forbidden-only"
+            "forbidden-only",
+            "dependency-not-followed"
           ]
         },
         {