test-inventory 0.8.0 → 0.9.0

package/dist/config.d.ts

@@ -39,6 +39,8 @@ export interface ObjectSetting {
     kind: 'object';
     keys: Map<string, Setting>;
     rest: Unknown | null;
+    /** Where the object is written; absent for one the scan builds, as by merging two. */
+    where?: Site;
 }
 /** The source text of a setting the scan can't work out; null for one of a config it couldn't read at all. */
 export declare function unknownText(setting: Unknown): string | null;
@@ -65,6 +67,7 @@ export declare class Configs {
     private readonly readerFor;
     private readonly inFolders;
     private readonly files;
+    private mocha;
     private readonly used;
     private readonly reported;
     private readonly version;
@@ -84,8 +87,29 @@ export declare class Configs {
     records(projectsOf: (config: ConfigFile) => ProjectRecord[] | null): ConfigRecord[];
     /** Reports a setting the scan reads but can't work out, once; `key` names it, and `effect` says what the scan does. */
     reportUnknown(setting: Unknown, key: string, effect: string): void;
+    /**
+     * Reports, once, a setting the runner mishandles, where it is written, or on its config when the scan built it from
+     * several places; `key` names it.
+     */
+    reportSetting(setting: ObjectSetting, config: ConfigFile, key: string, message: string): void;
+    private reportAt;
     /** Reports, once, a config the runner reads in a way the scan doesn't follow, or refuses. */
     reportConfig(config: ConfigFile, message: string): void;
+    /**
+     * The config Mocha runs with, started in the root: the first `.mocharc` file from the root up, joined with the `mocha`
+     * key of the nearest package.json. Null without either.
+     */
+    mochaConfig(): ConfigFile | null;
+    /**
+     * The config the jasmine command reads, started in the root: the first of `spec/support/jasmine.mjs` (from Jasmine
+     * 5), `.json` and `.js` there; null without one.
+     */
+    jasmineConfig(): ConfigFile | null;
+    /**
+     * The config `cypress run` or `wdio` reads, started in the root without a config named: the first of its config
+     * files there; null without one.
+     */
+    rootConfig(): ConfigFile | null;
     /** The config the runner started in a folder would use; null when the folder has none. */
     inFolder(folder: string): ConfigFile | null;
     /** Config file names, in the order the runner looks for them; Jest reads `.cts` from 30.0 and `.mts` from 30.4. */

package/dist/config.js

@@ -4,17 +4,28 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { childNodes, isFunctionNode, propertyKey, propertyName, returnValues, unwrap, } from "./ast.js";
 import { fileDiagnostic, toDiagnostic } from "./diagnostics.js";
 import { readFailure } from "./files.js";
-import { exportName, moduleExportsValue, ownExport, parseModule, requiredModule, starReexport, } from "./frameworks/bindings.js";
+import { folders } from "./framework-version.js";
+import { commonJsExport, exportName, moduleExportsValue, ownExport, parseModule, requiredModule, starReexport, } from "./frameworks/bindings.js";
 import { atLeast, problem } from "./frameworks/common.js";
 import { parseFile } from "./parse.js";
 import { snippet } from "./source.js";
 import { isKey, isScopeNode, Values } from "./values.js";
 import { VITEST_INCLUDE, VITEST_TYPECHECK_INCLUDE, vitestExclude } from "./vitest-defaults.js";
+import { readToml, TomlError } from "./toml.js";
+import { readYaml, YamlError } from "./yaml.js";
 /** Config file names in the order each runner looks for them in a folder. */
 const CONFIG_FILES = {
     playwright: ['.ts', '.js', '.mts', '.mjs', '.cts', '.cjs'].map((extension) => `playwright.config${extension}`),
     vitest: ['vitest.config', 'vite.config'].flatMap((name) => ['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'].map((extension) => name + extension)),
     jest: ['.js', '.ts', '.mjs', '.mts', '.cjs', '.cts', '.json'].map((extension) => `jest.config${extension}`),
+    mocha: ['.cjs', '.js', '.mjs', '.yaml', '.yml', '.jsonc', '.json'].map((extension) => `.mocharc${extension}`),
+    // From the root, which the jasmine command runs in; `.mjs` from Jasmine 5.
+    jasmine: ['.mjs', '.json', '.js'].map((extension) => `spec/support/jasmine${extension}`),
+    cypress: ['.ts', '.js', '.mjs', '.cjs', '.mts', '.cts'].map((extension) => `cypress.config${extension}`),
+    // The files `wdio run` takes without a config named, in its order.
+    webdriverio: ['.js', '.ts', '.mjs', '.mts', '.cjs', '.cts'].map((extension) => `wdio.conf${extension}`),
+    node: [],
+    bun: ['bunfig.toml'],
 };
 /** Methods that change the object or list they are called on. */
 const CHANGING_METHODS = new Set([
@@ -280,6 +291,10 @@ class ConfigCode {
             const commonJs = program.body.map(moduleExportsValue).find((value) => value !== null);
             return commonJs ? this.config(commonJs, frame, [program]) : null;
         }
+        // A name a CommonJS module exports, as WebdriverIO's `exports.config = { ... }`.
+        const commonJs = commonJsExport(program, name);
+        if (commonJs)
+            return this.config(commonJs, frame, [program]);
         for (const statement of program.body) {
             const source = starReexport(statement);
             const found = source === null ? null : this.fromModule(frame, source, name, site);
@@ -485,7 +500,7 @@ class ConfigCode {
             // A method or getter is a function, which the scan can't work out.
             object.keys.set(String(key.value), this.evaluate(property.value, frame, scopes));
         }
-        return object;
+        return { ...object, where: { frame, node } };
     }
     /**
      * `{ ...object, ...argument }`, also for an argument that picks between two objects, as in
@@ -645,6 +660,7 @@ export class Configs {
     readerFor;
     inFolders = new Map();
     files = new Map();
+    mocha;
     used = new Set();
     reported = new Set();
     version;
@@ -696,14 +712,27 @@ export class Configs {
     }
     /** Reports a setting the scan reads but can't work out, once; `key` names it, and `effect` says what the scan does. */
     reportUnknown(setting, key, effect) {
-        if (setting.where === null)
+        const message = `The config's ${key} could not be worked out without running the config, so ${effect}.`;
+        this.reportAt(setting.where, key, message);
+    }
+    /**
+     * Reports, once, a setting the runner mishandles, where it is written, or on its config when the scan built it from
+     * several places; `key` names it.
+     */
+    reportSetting(setting, config, key, message) {
+        if (setting.where)
+            this.reportAt(setting.where, key, message);
+        else
+            this.reportConfig(config, message);
+    }
+    reportAt(where, key, message) {
+        if (where === null)
             return;
-        const { frame, node } = setting.where;
+        const { frame, node } = where;
         const id = `${frame.relativeFilePath}\0${node.start}\0${key}`;
         if (this.reported.has(id))
             return;
         this.reported.add(id);
-        const message = `The config's ${key} could not be worked out without running the config, so ${effect}.`;
         const code = snippet(frame.parsed.source.text.slice(node.start, node.end));
         const found = problem('config-value-unknown', node, message, code);
         this.diagnostics.push(toDiagnostic(found, frame.relativeFilePath, frame.parsed.source));
@@ -716,6 +745,45 @@ export class Configs {
         this.reported.add(id);
         this.diagnostics.push(fileDiagnostic('config-value-unknown', config.record.relativeFilePath, message));
     }
+    /**
+     * The config Mocha runs with, started in the root: the first `.mocharc` file from the root up, joined with the `mocha`
+     * key of the nearest package.json. Null without either.
+     */
+    mochaConfig() {
+        if (this.mocha !== undefined)
+            return this.mocha;
+        let rc = null;
+        let manifest = null;
+        for (const folder of folders(this.root)) {
+            const name = rc ? undefined : CONFIG_FILES.mocha.find((item) => existsSync(path.join(folder, item)));
+            if (name)
+                rc = this.at(path.join(folder, name));
+            if (manifest === null && existsSync(path.join(folder, 'package.json')))
+                manifest = path.join(folder, 'package.json');
+            if (rc && manifest)
+                break;
+        }
+        const key = manifest && manifestKey(manifest, 'mocha') !== undefined ? this.at(manifest) : null;
+        this.mocha = rc && key ? joinMochaConfigs(rc, key) : (rc ?? key);
+        return this.mocha;
+    }
+    /**
+     * The config the jasmine command reads, started in the root: the first of `spec/support/jasmine.mjs` (from Jasmine
+     * 5), `.json` and `.js` there; null without one.
+     */
+    jasmineConfig() {
+        const names = CONFIG_FILES.jasmine.filter((name) => !name.endsWith('.mjs') || atLeast(this.version, 5, 0));
+        const name = names.find((item) => existsSync(path.join(this.root, item)));
+        return name ? this.at(path.join(this.root, name)) : null;
+    }
+    /**
+     * The config `cypress run` or `wdio` reads, started in the root without a config named: the first of its config
+     * files there; null without one.
+     */
+    rootConfig() {
+        const name = CONFIG_FILES[this.framework].find((item) => existsSync(path.join(this.root, item)));
+        return name ? this.at(path.join(this.root, name)) : null;
+    }
     /** The config the runner started in a folder would use; null when the folder has none. */
     inFolder(folder) {
         let config = this.inFolders.get(folder);
@@ -748,7 +816,7 @@ export class Configs {
     jestConfigIn(folder, anyManifest = false) {
         const names = this.names().filter((item) => existsSync(path.join(folder, item)));
         const manifest = path.join(folder, 'package.json');
-        const key = existsSync(manifest) ? jestKey(manifest) : undefined;
+        const key = existsSync(manifest) ? manifestKey(manifest) : undefined;
         const KEY = 'the jest key in package.json';
         if (key !== undefined)
             names.push(KEY);
@@ -795,17 +863,24 @@ export class Configs {
             const message = `The config could not be read: ${readFailure(error)}, ${none}`;
             return unreadable(fileDiagnostic('config-value-unknown', relativeFilePath, message));
         }
-        if (file.endsWith('.json')) {
+        if (/\.(jsonc?|ya?ml|toml)$/.test(file)) {
             let value;
             try {
-                value = JSON.parse(code);
+                // Mocha reads `.mocharc.json` with comments too.
+                const comments = file.endsWith('.jsonc') || path.basename(file).startsWith('.mocharc');
+                value = /\.ya?ml$/.test(file)
+                    ? readYaml(code)
+                    : file.endsWith('.toml')
+                        ? readToml(code)
+                        : JSON.parse(comments ? withoutJsonComments(code) : code);
             }
             catch (error) {
-                const message = `The config could not be parsed: ${error.message}, ${none}`;
+                const at = error instanceof YamlError || error instanceof TomlError ? ` on line ${error.line}` : '';
+                const message = `The config could not be parsed${at}: ${error.message}, ${none}`;
                 return unreadable(fileDiagnostic('config-value-unknown', relativeFilePath, message));
             }
-            // Jest reads a package.json without a `jest` key as an empty config.
-            const settings = path.basename(file) === 'package.json' ? jestKeyOf(value) : value;
+            // Jest reads a package.json without a `jest` key as an empty config, and Mocha one without a `mocha` key.
+            const settings = path.basename(file) === 'package.json' ? manifestKeyOf(value, this.framework) : value;
             return { file, record: { relativeFilePath, extends: [] }, settings: fromValue(settings ?? {}) };
         }
         const parsed = parseFile(relativeFilePath, code);
@@ -818,7 +893,9 @@ export class Configs {
         const config = new ConfigCode(frame, this.framework, this.root, this.version);
         let settings;
         try {
-            settings = config.exported(frame, 'default', { frame, node: parsed.program });
+            // WebdriverIO's config is the module's `config` export.
+            const name = this.framework === 'webdriverio' ? 'config' : 'default';
+            settings = config.exported(frame, name, { frame, node: parsed.program });
         }
         catch (error) {
             // The scan runs none of the project's code, so what fails here is its own and throws an Error.
@@ -827,28 +904,71 @@ export class Configs {
             return unreadable(fileDiagnostic('internal-error', relativeFilePath, message));
         }
         if (settings === null) {
-            const message = `The config has no default export the scan can find, ${none}`;
+            const message = `The config has no ${this.framework === 'webdriverio' ? '`config`' : 'default'} export the scan can find, ${none}`;
             return unreadable(fileDiagnostic('config-value-unknown', relativeFilePath, message));
         }
         return { file, record: { relativeFilePath, extends: config.followed }, settings };
     }
 }
-/** The `jest` key of a package.json; undefined when it has none, or can't be read. */
-function jestKey(file) {
+/** The `jest` or `mocha` key of a package.json; undefined when it has none, or can't be read. */
+function manifestKey(file, framework = 'jest') {
     try {
-        return jestKeyOf(JSON.parse(readFileSync(file, 'utf8')));
+        return manifestKeyOf(JSON.parse(readFileSync(file, 'utf8')), framework);
     }
     catch {
         return undefined;
     }
 }
-/** The `jest` key of a parsed package.json; undefined for a value Jest reads as no config, as `false` or `""` are. */
-function jestKeyOf(packageJson) {
-    const key = packageJson?.jest;
+/** Mocha's options that take a list, which it joins across a `.mocharc` file and package.json. */
+const MOCHA_LISTS = new Set([
+    'extension',
+    'file',
+    'global',
+    'ignore',
+    'exclude',
+    'node-option',
+    'reporter-option',
+    'require',
+    'spec',
+    'watch-files',
+    'watch-ignore',
+]);
+/**
+ * A `.mocharc` file and the `mocha` key of a package.json as Mocha joins them: a list option is the file's items and
+ * then the package.json's, a single value counting as a list of one; for any other key the file's value wins (checked
+ * with Mocha 10.8.2, 11.7.5 and 12.0.3).
+ */
+function joinMochaConfigs(rc, key) {
+    const record = { ...rc.record, extends: [...rc.record.extends, key.record.relativeFilePath] };
+    if (rc.settings.kind !== 'object' || key.settings.kind !== 'object')
+        return { ...rc, record };
+    const keys = new Map([...key.settings.keys, ...rc.settings.keys]);
+    for (const name of MOCHA_LISTS) {
+        const [first, second] = [rc.settings.keys.get(name), key.settings.keys.get(name)];
+        if (!first || !second)
+            continue;
+        const items = (setting) => (setting.kind === 'list' ? setting.items : [setting]);
+        keys.set(name, { kind: 'list', items: [...items(first), ...items(second)] });
+    }
+    return { ...rc, record, settings: { kind: 'object', keys, rest: rc.settings.rest } };
+}
+/**
+ * The `jest` or `mocha` key of a parsed package.json, by the framework; undefined for a value the runner reads as no
+ * config, as `false` or `""` are.
+ */
+function manifestKeyOf(packageJson, framework = 'jest') {
+    const key = packageJson?.[framework === 'mocha' ? 'mocha' : 'jest'];
     if (!key)
         return undefined;
     return key;
 }
+/**
+ * JSON text without `//` and `/* *\/` comments outside strings, as Mocha reads `.mocharc.jsonc`; a comment becomes
+ * spaces, so the parser's positions stay right.
+ */
+function withoutJsonComments(text) {
+    return text.replaceAll(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (match, string) => string ?? match.replaceAll(/[^\n]/g, ' '));
+}
 /** A JSON text's value; null when it isn't JSON. */
 function attemptJson(text) {
     try {

package/dist/diagnostics.js

@@ -22,6 +22,7 @@ export const LEVELS = {
     'nested-test': 'warning',
     'tag-without-at': 'error',
     'removed-api': 'error',
+    'invalid-fixture-argument': 'error',
     'only-in-skipped-describe': 'warning',
     'config-may-change-state': 'warning',
     'undefined-tag': 'error',
@@ -50,9 +51,21 @@ export const LEVELS = {
  * calls that throw while the file is collected.
  */
 export const REJECTS_FILE = {
-    playwright: new Set(['test-without-body', 'tag-without-at', 'invalid-chain', 'duplicate-title']),
+    playwright: new Set([
+        'test-without-body',
+        'tag-without-at',
+        'invalid-chain',
+        'duplicate-title',
+        'invalid-fixture-argument',
+    ]),
     vitest: new Set(['invalid-chain', 'removed-api', 'undefined-tag']),
     jest: new Set(['invalid-chain', 'test-without-body', 'async-describe', 'describe-throws']),
+    mocha: new Set(['invalid-chain', 'test-without-body']),
+    jasmine: new Set(['invalid-chain', 'test-without-body', 'async-describe', 'describe-throws']),
+    cypress: new Set(['invalid-chain', 'test-without-body', 'describe-throws']),
+    webdriverio: new Set(['invalid-chain', 'test-without-body', 'async-describe', 'describe-throws']),
+    node: new Set(['invalid-chain']),
+    bun: new Set(['invalid-chain', 'test-without-body']),
 };
 export function toDiagnostic(problem, relativeFilePath, source, testId = null) {
     const position = problem.node && source ? source.position(problem.node.start) : null;

package/dist/extract.d.ts

@@ -53,6 +53,8 @@ export interface PendingSuite {
 }
 export interface PendingTest {
     scope: Scope;
+    /** The test whose body declares this one as a subtest; null for a test declared in the file or a describe. */
+    parent: PendingTest | null;
     declaration: TestDeclaration;
     call: CallExpression;
     /** For a test declared in an imported helper, the call in the scanned file that registers it; null otherwise. */

package/dist/extract.js

@@ -717,11 +717,7 @@ class Walker {
         return this.functionIn(this.frame, name, scopes);
     }
     functionIn(frame, name, scopes) {
-        const declaration = frame.values.declarationOf(name, scopes);
-        if (declaration?.type === 'FunctionDeclaration')
-            return declaration;
-        const init = declaration?.type === 'VariableDeclarator' && declaration.init ? unwrap(declaration.init) : null;
-        return init?.type === 'ArrowFunctionExpression' || init?.type === 'FunctionExpression' ? init : null;
+        return frame.values.functionOf(name, scopes);
     }
     /**
      * Records a call to a function declared in the file. A call from the file or a describe returns the function, to be
@@ -1045,7 +1041,7 @@ class Walker {
     expectCall(call, test) {
         const callee = unwrap(call.callee);
         const [root, member] = callee.type === 'MemberExpression' ? [unwrap(callee.object), propertyName(callee)] : [callee, 'call'];
-        if (root.type !== 'Identifier' || root.name !== 'expect')
+        if (!this.isExpect(root))
             return;
         if (member === 'call' || member === 'soft' || member === 'poll' || member === 'element')
             test.expectCount += 1;
@@ -1060,6 +1056,20 @@ class Walker {
             test.problems.push(...problems.map((item) => this.here(item)));
         }
     }
+    /**
+     * Whether an expression is `expect`, or Playwright's `expect.configure(...)`, which gives an `expect` with other
+     * defaults, written in place or kept in a variable.
+     */
+    isExpect(expression) {
+        const node = unwrap(expression);
+        if (node.type === 'Identifier') {
+            if (node.name === 'expect')
+                return true;
+            const declaration = this.frame.values.declarationOf(node.name, this.scopes);
+            return declaration?.type === 'VariableDeclarator' && declaration.init !== null && isConfigured(declaration.init);
+        }
+        return isConfigured(node);
+    }
     /** Reports a problem not tied to a test, once, however many times a function with it is walked. */
     report(found) {
         const item = this.here(found);
@@ -1201,14 +1211,20 @@ class Walker {
             test.problems.push(problem('test-in-function', test.call, `The test is declared in a function, and ${why}. The runner registers the test at each call of the function, in the describe around the call; it is listed once, where it is written.`));
         }
     }
-    nested(call, context) {
+    nested(call, context, isTest) {
         if (!context.test && !context.hookScope)
             return false;
-        this.report(problem('nested-test', call, 'A test or describe declared inside a test or hook body is not collected by the runner, so it is not listed.', snippet(this.frame.parsed.source.slice(call.start, call.end))));
+        const inTest = context.test !== null && !context.hookScope && this.frame.adapter.nestsTests === true;
+        if (isTest && inTest)
+            return false;
+        const message = inTest
+            ? 'A describe declared inside a test body runs as a nested describe of the test, but the scan does not list it or its tests.'
+            : 'A test or describe declared inside a test or hook body is not collected by the runner, so it is not listed.';
+        this.report(problem('nested-test', call, message, snippet(this.frame.parsed.source.slice(call.start, call.end))));
         return true;
     }
     declareTest(call, declaration, context) {
-        if (context.quiet || this.nested(call, context))
+        if (context.quiet || this.nested(call, context, true))
             return;
         for (const item of this.cases(declaration, call, context))
             this.declareCase(call, item, context);
@@ -1254,6 +1270,7 @@ class Walker {
         const empty = emptyTitle(declaration, call);
         const test = {
             scope: context.scope,
+            parent: context.test,
             declaration,
             call,
             site: this.site,
@@ -1309,7 +1326,7 @@ class Walker {
             walk();
     }
     declareSuite(call, declaration, context) {
-        if (context.quiet || this.nested(call, context))
+        if (context.quiet || this.nested(call, context, false))
             return;
         for (const item of this.cases(declaration, call, context))
             this.declareSuiteCase(call, item, context);
@@ -1404,3 +1421,12 @@ class Walker {
 export function extract(main, openModule, options = { expandCases: false, version: null }) {
     return new Walker(main, openModule, options).run();
 }
+/** Whether an expression is a call of `expect.configure()`. */
+function isConfigured(expression) {
+    const node = unwrap(expression);
+    const callee = node.type === 'CallExpression' ? unwrap(node.callee) : null;
+    if (callee?.type !== 'MemberExpression' || propertyName(callee) !== 'configure')
+        return false;
+    const object = unwrap(callee.object);
+    return object.type === 'Identifier' && object.name === 'expect';
+}

package/dist/files.js

@@ -82,7 +82,8 @@ export async function findFiles(root, patterns, ignore, framework, platform = pr
         const absolutePath = path.resolve(root, match);
         const realPath = realpathSync(absolutePath);
         const linked = realPath !== path.join(realRoot, match);
-        if (linked && framework !== 'vitest') {
+        // Vitest and Mocha load a file through a link; Node.js loads it once, by its real path.
+        if (linked && framework !== 'vitest' && framework !== 'mocha') {
             const name = framework === 'jest' ? 'Jest' : 'Playwright';
             diagnostics.push(fileDiagnostic('symlink-ignored', match, `The file is reached through a symbolic link, which ${name} does not follow.`));
             continue;

package/dist/filter.js

@@ -18,6 +18,7 @@ const TEST_KEYS = Object.keys({
     dependencies: true,
     hasUnfollowedDependencies: true,
     suiteId: true,
+    parentTestId: true,
     suitePath: true,
     relativeFilePath: true,
     fileName: true,

package/dist/framework-version.d.ts

@@ -1,8 +1,8 @@
 import type { Framework } from './types.ts';
 /** Each framework's name in messages. */
 export declare const FRAMEWORK_NAMES: Record<Framework, string>;
-/** Oldest supported version of each framework. */
-export declare const OLDEST: Record<Framework, [number, number]>;
+/** Oldest supported version of each framework, as major, minor and for Bun, whose 1.2.23 changed how it runs tests, patch. */
+export declare const OLDEST: Record<Framework, number[]>;
 /** Where the framework version came from. */
 export interface DetectedVersion {
     version: string;
@@ -11,6 +11,8 @@ export interface DetectedVersion {
     /** Only a range is known, such as `^4.0.0`; `version` is its lowest version. */
     range: string | null;
 }
+/** The root, then each folder above it, as a monorepo package's dependencies may be installed or locked higher up. */
+export declare function folders(root: string): string[];
 /**
  * The framework version from the installed package, then a lockfile, then package.json, each looked for in the root
  * and the folders above it. A version range, as in `^4.0.0`, is used only when nothing else is found. When none of