test-inventory 0.5.0 → 0.6.0

package/dist/diagnostics.js

@@ -26,6 +26,7 @@ export const LEVELS = {
     'config-value-unknown': 'warning',
     'file-not-run': 'warning',
     'forbidden-only': 'error',
+    'dependency-not-followed': 'warning',
     'symlink-ignored': 'warning',
     'invalid-import': 'error',
     'globals-not-enabled': 'warning',

package/dist/extract.d.ts

@@ -18,6 +18,10 @@ export interface Scope {
     hookRun: RunSettings;
     /** Fixtures of the hooks in the scope that run around each test. */
     hookFixtures: string[];
+    /** Fixtures of every hook in the scope, `beforeAll` and `afterAll` too, which set up what its tests run. */
+    setupFixtures: string[];
+    /** A hook in the scope takes its fixtures whole, so it may use any. */
+    takesAllFixtures: boolean;
     suite: PendingSuite | null;
 }
 /** Where a test or describe registered through an imported helper is written, in the helper's module. */
@@ -33,6 +37,10 @@ export interface PendingSuite {
     /** For a describe declared in an imported helper, the call in the scanned file that registers it; null otherwise. */
     site: Span | null;
     declaredAt: DeclaredAt | null;
+    /** The file the describe is written in. */
+    frame: Frame;
+    /** The outermost helper call in the scanned file that declares the describe; null when the file declares it. */
+    registeredBy: CallExpression | null;
     /** Where the scanned file registers the describe: its own call, or the outermost helper call that declares it. */
     order: number;
     /** Statements of the tests and describes directly inside, left out of the describe's body hash. */
@@ -48,6 +56,10 @@ export interface PendingTest {
     /** For a test declared in an imported helper, the call in the scanned file that registers it; null otherwise. */
     site: Span | null;
     declaredAt: DeclaredAt | null;
+    /** The file the test is written in. */
+    frame: Frame;
+    /** The outermost helper call in the scanned file that declares the test; null when the file declares it. */
+    registeredBy: CallExpression | null;
     /** Where the scanned file registers the test: its own call, or the outermost helper call that declares it. */
     order: number;
     /** States from the declaration, then from calls in the body such as `test.skip(condition)`. */

package/dist/extract.js

@@ -140,6 +140,8 @@ class Walker {
             hooks: noHooks(),
             hookRun: {},
             hookFixtures: [],
+            setupFixtures: [],
+            takesAllFixtures: false,
             suite: null,
         };
     }
@@ -158,7 +160,7 @@ class Walker {
             helper: null,
             declaredIn: null,
             quiet: false,
-            registeredAt: null,
+            registeredBy: null,
         });
         // Functions defined inside these are deferred in turn; the loop reaches them too, as they are added to the end.
         for (const entry of this.deferred)
@@ -418,6 +420,8 @@ class Walker {
                     context.scope.hooks[api.name] += 1;
                     if (EACH_HOOKS.has(api.name))
                         context.scope.hookFixtures.push(...api.fixtures);
+                    context.scope.setupFixtures.push(...api.fixtures);
+                    context.scope.takesAllFixtures ||= api.takesAllFixtures;
                 }
                 if (api.fn) {
                     if (!call.arguments.includes(api.fn))
@@ -628,7 +632,7 @@ class Walker {
                 ...context,
                 isInFunction: true,
                 declaredIn: null,
-                registeredAt: context.registeredAt ?? call.start,
+                registeredBy: context.registeredBy ?? call,
             });
         });
         this.callStack.pop();
@@ -926,7 +930,9 @@ class Walker {
             call,
             site: this.site,
             declaredAt: this.declaredAt(call),
-            order: context.registeredAt ?? call.start,
+            frame: this.frame,
+            registeredBy: context.registeredBy,
+            order: (context.registeredBy ?? call).start,
             states: [...declaration.states],
             annotations: [...declaration.details.annotations],
             isInLoop: context.isInLoop,
@@ -976,6 +982,8 @@ class Walker {
             hooks: noHooks(),
             hookRun: {},
             hookFixtures: [],
+            setupFixtures: [],
+            takesAllFixtures: false,
             suite: null,
         };
         const suite = {
@@ -984,7 +992,9 @@ class Walker {
             call,
             site: this.site,
             declaredAt: this.declaredAt(call),
-            order: context.registeredAt ?? call.start,
+            frame: this.frame,
+            registeredBy: context.registeredBy,
+            order: (context.registeredBy ?? call).start,
             cuts: [],
             isInCondition: context.isInCondition,
             isInFunction: context.isInFunction,

package/dist/filter.d.ts

@@ -11,6 +11,12 @@ export interface InventoryFilter {
     only?: boolean;
     /** Keeps tests that don't run and give no reason. Tests in a file the runner refuses are left out. */
     withoutReason?: boolean;
+    /**
+     * Keeps the tests a change to one of these files can affect: those whose `dependencies` include it, and those that
+     * reach code the scan can't follow (`hasUnfollowedDependencies`). Paths are from the project root, as
+     * `dependencies` writes them. An empty list keeps only the tests the scan can't follow.
+     */
+    related?: string[];
 }
 /** An inventory whose test records have only `id` and the keys picked with `pickTestFields()`. */
 export type PickedInventory<K extends keyof TestRecord> = Omit<Inventory, 'tests'> & {

package/dist/filter.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { checkObject, OptionsError } from "./options.js";
 import { summarize } from "./summary.js";
 const STATES = ['active', 'skip', 'fixme', 'todo', 'expectedToFail', 'notLoaded'];
@@ -7,11 +8,15 @@ const FILTER_KEYS = [
     'grep',
     'only',
     'withoutReason',
+    'related',
 ];
 // Typed as a record of every key, so a key added to TestRecord fails to compile until it is listed here.
 const TEST_KEYS = Object.keys({
     id: true,
     bodyHash: true,
+    dependencyHash: true,
+    dependencies: true,
+    hasUnfollowedDependencies: true,
     suiteId: true,
     suitePath: true,
     relativeFilePath: true,
@@ -117,11 +122,16 @@ export function matcher(filter) {
     const grep = pattern(checked.grep);
     const only = flag(checked.only, 'filter.only');
     const withoutReason = flag(checked.withoutReason, 'filter.withoutReason');
+    // Written as a shell or Windows may write them, as `./pages/order-ticket.ts` or `pages\\order-ticket.ts`.
+    const related = checked.related === undefined
+        ? null
+        : new Set(list(checked.related, 'filter.related', null).map((file) => path.posix.normalize(file.replaceAll('\\', '/'))));
     return (test) => (states.length === 0 || states.includes(test.state)) &&
         (tags.length === 0 || test.tags.some((tag) => tags.includes(tag))) &&
         (grep === null || grep.test(test.fullName)) &&
         (!only || test.isOnly) &&
-        (!withoutReason || (!test.isActive && !test.isNotLoaded && test.reason === null));
+        (!withoutReason || (!test.isActive && !test.isNotLoaded && test.reason === null)) &&
+        (related === null || test.hasUnfollowedDependencies || test.dependencies.some((file) => related.has(file)));
 }
 /**
  * Keeps the tests that pass every condition of the filter; a list keeps a test that has any of its values. The

package/dist/frameworks/common.d.ts

@@ -116,6 +116,11 @@ export declare function readOptions(file: FileContext, scopes: readonly Node[],
 export declare function unresolvedOptions(file: FileContext, options: Options, result: string): Problem[];
 /** The names a function takes from the object pattern of one of its parameters, in source order. */
 export declare function destructuredNames(fn: FunctionNode | null, index: number | null): string[];
+/**
+ * Whether a function takes one of its parameters whole, as in `(fixtures) => ...`, or keeps the rest of its object
+ * pattern, so that any key of it may be used.
+ */
+export declare function takesWhole(fn: FunctionNode | null, index: number | null): boolean;
 /** A whole number, such as a timeout in milliseconds; null, with a warning, when it can't be worked out. */
 export declare function readCount(file: FileContext, name: string, option: OptionValue, problems: Problem[]): number | null;
 /** A warning for one option whose value could not be worked out. */

package/dist/frameworks/common.js

@@ -287,6 +287,17 @@ export function destructuredNames(fn, index) {
     const names = parameter.properties.map((property) => (property.type === 'Property' ? propertyKey(property) : null));
     return names.filter((name) => name !== null);
 }
+/**
+ * Whether a function takes one of its parameters whole, as in `(fixtures) => ...`, or keeps the rest of its object
+ * pattern, so that any key of it may be used.
+ */
+export function takesWhole(fn, index) {
+    const parameter = index === null ? undefined : fn?.params[index];
+    if (!parameter)
+        return false;
+    return (parameter.type !== 'ObjectPattern' ||
+        parameter.properties.some((property) => property.type === 'RestElement' || property.computed));
+}
 /** A whole number, such as a timeout in milliseconds; null, with a warning, when it can't be worked out. */
 export function readCount(file, name, option, problems) {
     const { node, resolved } = option;

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, 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";
+import { atLeast, findFunction, hookFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, takesWhole, 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([
@@ -259,7 +259,14 @@ export class PlaywrightAdapter {
             return this.configure(call, context);
         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) };
+            return {
+                kind: 'hook',
+                name: key,
+                fn,
+                testContext: null,
+                fixtures: destructuredNames(fn, 0),
+                takesAllFixtures: takesWhole(fn, 0),
+            };
         }
         if (RUN_MEMBERS.has(key))
             return this.runSetting(call, key, context);
@@ -475,6 +482,7 @@ export class PlaywrightAdapter {
             caseCount: null,
             testContext: null,
             fixtures: destructuredNames(hashed, 0),
+            takesAllFixtures: takesWhole(hashed, 0),
             usesBench: false,
             problems,
         };

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, 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";
+import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, takesWhole, 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)
@@ -528,6 +528,7 @@ export class VitestAdapter {
             fn,
             testContext: index === null ? null : contextNames(fn, index),
             fixtures: fixturesOf(fn, index, this.file.version),
+            takesAllFixtures: takesWhole(fn, index),
         };
     }
     contextSkip(call, context) {
@@ -701,6 +702,7 @@ export class VitestAdapter {
                 ...base,
                 testContext: contextNames(base.hashed, index),
                 fixtures: fixturesOf(base.hashed, index, this.file.version),
+                takesAllFixtures: takesWhole(base.hashed, index),
                 usesBench: atLeast(this.file.version, 5, 0) && destructuredNames(base.hashed, index).includes('bench'),
             };
         }

package/dist/hash.d.ts

@@ -1,6 +1,6 @@
 import type { Node } from 'oxc-parser';
 import type { Span } from './model.ts';
-export declare function shortHash(input: string): string;
+export declare function shortHash(input: string | Uint8Array): string;
 /**
  * Hashes code by its syntax tree, so formatting, comments, quote style, trailing commas and line endings don't change
  * the hash. Nodes at the `cut` spans, such as the tests inside a describe, are left out. Returns null when no code is

package/dist/model.d.ts

@@ -86,6 +86,8 @@ export interface TestDeclaration extends Declaration {
     testContext: unknown;
     /** Names the test function takes from its context, without the framework's own keys. */
     fixtures: string[];
+    /** The test function takes its fixtures whole, or keeps the rest of them, so it may use any. */
+    takesAllFixtures: boolean;
     /** Uses Vitest 5's `bench` fixture. */
     usesBench: boolean;
 }
@@ -128,6 +130,7 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     fn: FunctionNode | null;
     testContext: unknown;
     fixtures: string[];
+    takesAllFixtures: boolean;
 }
 /** Playwright `test.step()` or `test.step.skip()`. */
  | {

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';
@@ -69,6 +70,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

@@ -334,6 +334,7 @@ class RecordBuilder {
     }
     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);
@@ -396,6 +397,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/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.0",
   "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"
           ]
         },
         {