test-inventory 0.6.1 → 0.8.0

package/dist/dependency-hash.d.ts

@@ -3,7 +3,7 @@ import type { ConfigGap, RunsWith } from './config-dependencies.ts';
 import type { Extraction, Frame, PendingTest } from './extract.ts';
 import type { ModuleReader, ModuleSource, Problem, Span } from './model.ts';
 import { type ParsedFile } from './parse.ts';
-import { type SourceText } from './source.ts';
+import { SourceText } from './source.ts';
 import type { Framework } from './types.ts';
 import { Values } from './values.ts';
 /** A file whose code a test can run: the scanned file, a module it imports, or a data file such as JSON. */
@@ -96,6 +96,14 @@ interface Reach {
     asks: string[] | null;
     snapshots: SnapshotUse[];
 }
+/** What several reaches cover together, by file. */
+interface Merged {
+    files: string[];
+    /** Each file's hashes, sorted. */
+    byFile: Map<string, string[]>;
+    /** Each file's part of the text the dependency hash is taken of. */
+    parts: Map<string, string>;
+}
 /** A fixture one `extend()` call defines, and the fixtures it asks for; null when it takes them whole. */
 interface Fixture {
     unit: Unit;
@@ -145,11 +153,11 @@ export declare class DependencyGraph {
     /** The units a set of roots reaches, leaving out those `skip` reached, with their hashes by file. */
     reach(roots: Unit[], skip?: Reach[]): Reach;
     /**
-     * Everything a test's roots reach on top of `base`, the code its file runs when loaded, which all its tests share,
-     * with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
-     * followed.
+     * Everything a test's roots reach on top of `bases`, such as the code its file runs when loaded, which all its tests
+     * share, with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
+     * followed. `shared` is what the bases cover, put together once for the many tests that share them.
      */
-    dependencies(roots: Unit[], bases: Reach[], needs: FixtureNeeds, snapshots: (uses: SnapshotUse[]) => Unit[], report: (place: Place) => void): Dependencies;
+    dependencies(roots: Unit[], bases: Reach[], shared: Merged, needs: FixtureNeeds, snapshots: (uses: SnapshotUse[]) => Unit[], report: (place: Place) => void): Dependencies;
     private newModule;
     private newUnit;
     private hashOf;

package/dist/dependency-hash.js

@@ -5,8 +5,9 @@ import { exportName, parseModule } from "./frameworks/bindings.js";
 import { destructuredNames, problem, takesWhole } from "./frameworks/common.js";
 import { shortHash, hashNodes } from "./hash.js";
 import { parseFile } from "./parse.js";
-import { snippet } from "./source.js";
+import { snippet, SourceText } from "./source.js";
 import { bindingNames, isScopeNode, Values } from "./values.js";
+const NOTHING_MERGED = { files: [], byFile: new Map(), parts: new Map() };
 /** Statements that only declare something, unless code in them runs while they are evaluated. */
 const DECLARATIONS = new Set([
     'ImportDeclaration',
@@ -386,11 +387,11 @@ export class DependencyGraph {
         return { units, byFile, places, fixtures, asks, snapshots };
     }
     /**
-     * Everything a test's roots reach on top of `base`, the code its file runs when loaded, which all its tests share,
-     * with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
-     * followed.
+     * Everything a test's roots reach on top of `bases`, such as the code its file runs when loaded, which all its tests
+     * share, with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
+     * followed. `shared` is what the bases cover, put together once for the many tests that share them.
      */
-    dependencies(roots, bases, needs, snapshots, report) {
+    dependencies(roots, bases, shared, needs, snapshots, report) {
         const reached = [...bases, this.reach(roots, bases)];
         // A fixture can ask for one an object it extends defines, or use another test object, so names are shared by
         // every test object reached, and each name and object is read once.
@@ -476,11 +477,13 @@ export class DependencyGraph {
             this.reported.add(key);
             report(place);
         }
-        const files = [...new Set(reached.flatMap((item) => [...item.byFile.keys()]))].sort();
+        const added = hashesByFile(reached.slice(bases.length));
+        const files = [...new Set([...shared.files, ...added.keys()])].sort();
         const parts = files.map((file) => {
-            return [file, reached.flatMap((item) => item.byFile.get(file) ?? []).sort()];
+            const own = added.get(file);
+            return own ? part(file, [...(shared.byFile.get(file) ?? []), ...own]) : shared.parts.get(file);
         });
-        return { hash: shortHash(JSON.stringify(parts)), files, isComplete: places.length === 0 };
+        return { hash: shortHash(`[${parts.join(',')}]`), files, isComplete: places.length === 0 };
     }
     newModule(relativeFilePath, parsed, text, values, readModule) {
         return {
@@ -632,7 +635,8 @@ export class DependencyGraph {
     }
     /** A place in a module the scan can't follow, as a unit that marks the tests that reach it. */
     placeUnit(module, at, message, isQuiet = false) {
-        const { source } = module.parsed;
+        // A JSON config, such as Jest's package.json, is taken by its text.
+        const source = module.parsed?.source ?? new SourceText(module.text);
         const unit = this.newUnit(module, [], new Map(), false);
         unit.edges = new Set();
         const text = snippet(source.slice(at.start, at.end)) || null;
@@ -665,7 +669,11 @@ export class DependencyGraph {
         if ('module' in gap) {
             const module = this.moduleOf(gap.module);
             // The path a setup key names, where the config writes it.
-            const at = gap.text === null ? null : literalIn(module.parsed.program, gap.text);
+            let at = null;
+            if (gap.text !== null && module.parsed)
+                at = literalIn(module.parsed.program, gap.text);
+            else if (gap.text !== null)
+                at = jsonStringIn(module.text, gap.text);
             return this.placeUnit(module, at ?? { start: 0, end: 0 }, gap.message, gap.isQuiet);
         }
         const module = this.newModule(gap.relativeFilePath, null, null, new Values(), null);
@@ -1300,6 +1308,33 @@ export class DependencyGraph {
         return edges;
     }
 }
+/** The hashes of several reaches by file, in the order the reaches come. */
+function hashesByFile(reaches) {
+    const byFile = new Map();
+    for (const item of reaches) {
+        for (const [file, hashes] of item.byFile)
+            byFile.set(file, [...(byFile.get(file) ?? []), ...hashes]);
+    }
+    return byFile;
+}
+/** A file and its hashes, sorted, as text: the hash is taken of these parts, in the order of the files. */
+function part(file, hashes) {
+    return JSON.stringify([file, hashes.sort()]);
+}
+/** What `merged` covers with what one more reach adds, the parts of the files it adds hashes to written again. */
+function combine(merged, reach) {
+    if (reach.byFile.size === 0)
+        return merged;
+    const byFile = new Map(merged.byFile);
+    const parts = new Map(merged.parts);
+    for (const [file, hashes] of reach.byFile) {
+        const all = [...(merged.byFile.get(file) ?? []), ...hashes];
+        parts.set(file, part(file, all));
+        byFile.set(file, all);
+    }
+    const files = [...new Set([...merged.files, ...reach.byFile.keys()])].sort();
+    return { files, byFile, parts };
+}
 /** Whether an identifier refers to a binding, rather than naming a property, a label or a member. */
 function isReference(key, parent) {
     switch (parent?.type) {
@@ -1360,6 +1395,12 @@ function literalIn(node, value) {
     }
     return null;
 }
+/** Where a JSON file writes a string, as `"./setup.js"`; null when it doesn't. */
+function jsonStringIn(text, value) {
+    const written = JSON.stringify(value);
+    const start = text.indexOf(written);
+    return start === -1 ? null : { start, end: start + written.length };
+}
 /**
  * The snapshot files the matchers of a test compare against, from the project root, at the runners' default places:
  * Vitest's `__snapshots__/<file>.snap`, paths given to `toMatchFileSnapshot()`, and browser screenshots in
@@ -1468,6 +1509,7 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
         ...runsWith.gaps.map((gap) => graph.gapUnit(gap)),
     ];
     const base = graph.reach([load, ...config]);
+    const baseMerged = combine(NOTHING_MERGED, base);
     // The describes around a test and the helper call that registers it are shared by the tests there, often thousands
     // for one helper call, so what they reach is walked once for all of them.
     const contexts = new Map();
@@ -1481,7 +1523,8 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
                 if (around.suite)
                     roots.push(...suiteUnit(around.suite));
             }
-            context = graph.reach(roots, [base]);
+            const reach = graph.reach(roots, [base]);
+            context = { reach, merged: combine(baseMerged, reach) };
             byCall.set(registeredBy, context);
         }
         return context;
@@ -1528,6 +1571,7 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
             needs.names.push(...scope.setupFixtures);
             needs.all ||= scope.takesAllFixtures;
         }
-        return graph.dependencies(roots, [base, contextOf(test.scope, test.registeredBy)], needs, snapshots, report);
+        const context = contextOf(test.scope, test.registeredBy);
+        return graph.dependencies(roots, [base, context.reach], context.merged, needs, snapshots, report);
     };
 }

package/dist/diagnostics.js

@@ -7,6 +7,7 @@ export const LEVELS = {
     'unresolved-tag': 'warning',
     'unresolved-annotation': 'warning',
     'unresolved-cases': 'warning',
+    'cases-not-expanded': 'warning',
     'test-in-loop': 'warning',
     'dynamic-title': 'warning',
     'duplicate-title': 'warning',
@@ -17,6 +18,7 @@ export const LEVELS = {
     'test-without-body': 'error',
     'describe-not-called': 'error',
     'async-describe': 'error',
+    'describe-throws': 'error',
     'nested-test': 'warning',
     'tag-without-at': 'error',
     'removed-api': 'error',
@@ -50,6 +52,7 @@ export const LEVELS = {
 export const REJECTS_FILE = {
     playwright: new Set(['test-without-body', 'tag-without-at', 'invalid-chain', 'duplicate-title']),
     vitest: new Set(['invalid-chain', 'removed-api', 'undefined-tag']),
+    jest: new Set(['invalid-chain', 'test-without-body', 'async-describe', 'describe-throws']),
 };
 export function toDiagnostic(problem, relativeFilePath, source, testId = null) {
     const position = problem.node && source ? source.position(problem.node.start) : null;

package/dist/extract.d.ts

@@ -48,6 +48,8 @@ export interface PendingSuite {
     /** Declared under a condition, or in a function: it may not run while the file loads. */
     isInCondition: boolean;
     isInFunction: boolean;
+    /** With `expandCases`, the index of the case of a table or pass of a loop this describe is; null otherwise. */
+    caseIndex: number | null;
 }
 export interface PendingTest {
     scope: Scope;
@@ -66,8 +68,17 @@ export interface PendingTest {
     states: StateSetting[];
     annotations: Annotation[];
     isInLoop: boolean;
+    /**
+     * How many times each loop around the test registers it, outermost first; null for a loop the scan can't count, or
+     * one that registers it under a condition.
+     */
+    loops: (number | null)[];
+    /** How many passes each loop around the test makes, whether or not it registers the test on each. */
+    passes: (number | null)[];
     isInCondition: boolean;
     isInFunction: boolean;
+    /** With `expandCases`, the index of the case of a table or pass of a loop this test is; null otherwise. */
+    caseIndex: number | null;
     comments: string[];
     /** Run settings from calls in the body, which win over everything around the test. */
     run: RunSettings;
@@ -85,6 +96,13 @@ export interface Frame {
     readModule: ModuleReader | null;
     relativeFilePath: string;
 }
+/** How the walk lists tables and loops. */
+export interface ExtractOptions {
+    /** One test or describe per case of a table and per pass of a loop whose values the scan can work out. */
+    expandCases: boolean;
+    /** Vitest's `[major, minor]`, whose rules give each case its title; null for the newest rules. */
+    version: readonly [number, number] | null;
+}
 /** Reads a module a helper is imported from as a frame; null when it can't be parsed. */
 export type OpenModule = (module: ModuleSource) => Frame | null;
 export interface Extraction {
@@ -112,4 +130,4 @@ export declare function anySlow(slows: NonNullable<RunSettings['slow']>[]): NonN
 export declare function eitherCondition(parts: string[]): string;
 export declare function noHooks(): HookCounts;
 /** Walks the scanned file; `openModule` reads the modules of imported helpers that the file calls. */
-export declare function extract(main: Frame, openModule: OpenModule): Extraction;
+export declare function extract(main: Frame, openModule: OpenModule, options?: ExtractOptions): Extraction;