test-inventory 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # test-inventory
 
+## 0.5.0
+
+### Minor Changes
+
+- [#51](https://github.com/Huldoser/test-inventory/pull/51) [`acec7e7`](https://github.com/Huldoser/test-inventory/commit/acec7e7fd9bae8301ba3559c3986264ea35c3056) - Each file record has a new `config` key: the config the file uses, as the runner started at the root would pick it.
+  That is the outermost config at or above the file that runs it, and for Vitest `projects` the project that does,
+  read from Playwright's `testDir`, `testMatch`, `testIgnore` and `.gitignore` files, and from Vitest's `include`,
+  `exclude`, `includeSource`, `typecheck.include` and `benchmark.include` with each version's defaults. Before, the
+  nearest config was taken, which is wrong for a root config whose `include` covers packages that have their own
+  `vite.config.ts`. A file with tests that no config runs gets the new `file-not-run` warning.
+
+  The globals check follows the same choice, so a test in a folder project without a config of its own gets Vitest's
+  defaults, and a test the root config runs takes the root's `test.globals`. Files named by `benchmark.include` are
+  marked `isBenchmark`, in place of the default `*.bench.*` and `*.benchmark.*` names. The config reader now reads
+  regular expressions and paths built from `__dirname`, `__filename` or `import.meta` with `path.join()`,
+  `path.resolve()`, `path.dirname()`, `fileURLToPath()` and `new URL()`.
+
+- [#50](https://github.com/Huldoser/test-inventory/pull/50) [`3e55445`](https://github.com/Huldoser/test-inventory/commit/3e55445d0b195941813368b7beeea239ccf8792f) - The output lists the configs the scanned files use in a new top-level `configs` key, and as `config` lines in JSON
+  Lines. A file uses the nearest `playwright.config.*`, `vitest.config.*` or `vite.config.*` in its folder or a folder
+  above, up to the root, as the runner started in that folder would. A config is read as code, never run, and `extends`
+  lists the files it takes settings from through imports, such as a shared base config.
+
+  Vitest's globals now come from `test.globals` in the config a file uses, read through `defineConfig()`,
+  `mergeConfig()`, spreads, constants and imported base configs. Before, any `globals: true` in a Vitest or Vite config
+  in the file's folder or a folder above counted, also one Vitest doesn't read for the file, as in a `vite.config.ts`
+  next to a `vitest.config.ts`. So `globals-not-enabled` can now appear where it didn't, and go away where a base config
+  turns globals on. A `test.globals` the scan can't work out without running the config, and a config it can't read,
+  get the new `config-value-unknown` warning.
+
+- [#55](https://github.com/Huldoser/test-inventory/pull/55) [`a714612`](https://github.com/Huldoser/test-inventory/commit/a714612dcaf01eaa40d218bae44e7d27e68dbce6) - Run settings now come also from the config a file uses: Playwright's `timeout`, `retries` and `repeatEach`, and
+  Vitest's `testTimeout`, `retry` and `repeats`, where the file sets none. New `timeoutSource`, `retriesSource` and `repeatsSource`
+  keys say where each value comes from: `test`, `suite`, `file` or `config`, or `null` when nothing sets it. A test
+  takes the settings of the projects that run it, after their `grep`. When those projects disagree, the config sets the
+  value under a condition, as in `process.env.CI ? 2 : 0`, or the scan can't work out the projects, the value is `null`
+  with its source `config`. For a value under a condition, `timeoutConfigText`, `retriesConfigText` and
+  `repeatsConfigText` hold the config's text for it, so `retries: process.env.CI ? 2 : 0` reads as written. Playwright's `fullyParallel` and Vitest's `sequence.concurrent` make tests
+  `isParallel` where the file sets no mode, when every project that runs the test sets it.
+
+  A `.only` in a Playwright file whose config sets `forbidOnly` gets the new `forbidden-only` error, since the run then
+  fails before any test runs. When `forbidOnly` depends on a condition, as in `!!process.env.CI`, it is a warning that
+  quotes the condition.
+
+- [#59](https://github.com/Huldoser/test-inventory/pull/59) [`aeb3eb1`](https://github.com/Huldoser/test-inventory/commit/aeb3eb10896ba79b82fb34e5b3dd08cb601a251d) - Vitest tags the config defines in `test.tags` now apply to the tests that carry them, as Vitest applies them. Their
+  `skip`, `todo`, `fails` and `only` are merged with the test's own and those a describe passes down, and Vitest's order,
+  `only` over `skip` over `todo`, gives the state, with the new `stateSource` value `config` when a tag sets it. Their
+  `concurrent`, `timeout`, `retry`, `repeats` and `meta` set those keys where the test sets none: from Vitest 5 over a
+  describe's options, and in Vitest 4.1 under them. The lowest `priority` wins between tags, and a Vitest 5 project's
+  own `tags` replace those of the config it extends.
+
+  A tag the config doesn't define fails the file in Vitest unless `strictTags` is off, also when there is no config, so
+  it now gets the new `undefined-tag` error, and the file's tests are `notLoaded`; in a function or under a condition it
+  is a warning, as that code may not run. The `config-may-change-state` warning now shows only when
+  the scan can't work out the config's tags.
+
+- [#54](https://github.com/Huldoser/test-inventory/pull/54) [`c610789`](https://github.com/Huldoser/test-inventory/commit/c61078957ce5150fde089a45a444cf5bef41cfe5) - Each test record has a new `projects` key: the names of the projects that run the test, of the config its file uses.
+  For Playwright, those whose `testDir`, `testMatch` and `testIgnore` include the file, less those whose `grep` or
+  `grepInvert` leaves the test's title and tags out; for Vitest, those whose files include it, with each browser
+  instance as a project, named as Vitest names it, such as `unit (chromium)`. It is `[]` when no project runs the test,
+  and `null` without a config or when the scan can't tell. Config records list their projects in `projects`, each with
+  its `name`, `testDir` and Playwright's `dependencies`.
+
+- [#53](https://github.com/Huldoser/test-inventory/pull/53) [`b9471ec`](https://github.com/Huldoser/test-inventory/commit/b9471ecd36f9f6157c21b013c7fa6cc9584250cd) - Glob patterns are optional, in `scan()` and on the command line: without them, the test files are those the
+  Playwright or Vitest configs in the root and the folders below it run, each with the config it uses. A config whose
+  files the scan can't work out gets a `config-value-unknown` warning that says to give patterns, and a scan without
+  patterns and without a config says so in `no-files-matched`. An empty list of patterns is still an error.
+
+### Patch Changes
+
+- [#58](https://github.com/Huldoser/test-inventory/pull/58) [`1a34d74`](https://github.com/Huldoser/test-inventory/commit/1a34d74e76faead734afe87c0babc2a23fdbe4b7) - oxc-parser is updated from 0.154.0 to 0.156.0. The scan output doesn't change.
+
 ## 0.4.1
 
 ### Patch Changes

package/README.md

@@ -25,6 +25,8 @@ Node.js 22.12 or newer, on Linux, macOS or Windows. Playwright 1.42 or newer, Vi
 npx test-inventory "tests/**/*.spec.ts" --framework playwright --output inventory.json
 ```
 
+Without the glob, the test files are those the Playwright or Vitest configs in the project run.
+
 For this spec from a trading app's UI tests, `tests/alerts.spec.ts`:
 
 <!-- code: trading-web/tests/alerts.spec.ts -->
@@ -94,7 +96,8 @@ in Claude Code, Cursor, VS Code and other MCP clients ask it which tests a proje
 
 ## Limits
 
-- Config files are not read, so `grep`, projects and Vitest tag options in them do not change the output.
+- Config files are read as code, never run, and only in part: settings computed at run time, as from `process.env`,
+  can't be worked out, and settings such as `workers` or `use` are not read.
 - Values imported from other files are not worked out. A tag or title that comes from an import gets a diagnostic
   that names the module. A custom `test` object is followed through as many files as it takes, through relative
   paths, tsconfig path aliases, `#` imports in package.json and workspace packages; one that can't be followed gets

package/dist/ast.d.ts

@@ -11,10 +11,10 @@ export interface ReturnValue {
 }
 /**
  * The values a function returns; null when it may return no value, as with `return;` or no `return` at all, and for
- * an async function or a generator, which returns a promise or an iterator whatever its `return` says. A `return` in a
- * function inside it is that function's.
+ * an async function or a generator, which returns a promise or an iterator whatever its `return` says. With `awaited`,
+ * an async function's values are those its promise resolves to. A `return` in a function inside it is that function's.
  */
-export declare function returnValues(fn: FunctionNode): ReturnValue[] | null;
+export declare function returnValues(fn: FunctionNode, awaited?: boolean): ReturnValue[] | null;
 export declare function isStringLiteral(node: Node): node is StringLiteral;
 /** `import.meta.vitest`, which in-source Vitest tests read their functions from. */
 export declare function isImportMetaVitest(expression: Expression): boolean;

package/dist/ast.js

@@ -34,11 +34,11 @@ export function isFunctionNode(node) {
 }
 /**
  * The values a function returns; null when it may return no value, as with `return;` or no `return` at all, and for
- * an async function or a generator, which returns a promise or an iterator whatever its `return` says. A `return` in a
- * function inside it is that function's.
+ * an async function or a generator, which returns a promise or an iterator whatever its `return` says. With `awaited`,
+ * an async function's values are those its promise resolves to. A `return` in a function inside it is that function's.
  */
-export function returnValues(fn) {
-    if (fn.async || fn.generator)
+export function returnValues(fn, awaited = false) {
+    if ((fn.async && !awaited) || fn.generator)
         return null;
     // Only declarations of overloads have no body.
     const body = fn.body;

package/dist/cli.d.ts

@@ -4,6 +4,6 @@ export interface Io {
     stderr: Writable;
     cwd: string;
 }
-export declare const HELP = "Usage: test-inventory <glob...> --framework <playwright|vitest> [options]\n\nLists the tests in the matching files as JSON, read from the source code without running them.\n\nOptions:\n  --framework <name>           playwright or vitest (required)\n  --root <dir>                 project root; paths in the output are relative to it (default: current directory)\n  --ignore <glob>              leave out matching files; can be repeated (node_modules is always left out)\n  --framework-version <x.y.z>  apply the rules of this framework version instead of the one in the project\n  --comments <mode>            comments above tests: all, non-active or none (default: non-active)\n  --state <state>              keep tests in this state, such as skip or fixme; can be repeated\n  --tag <tag>                  keep tests with this tag, such as @smoke; can be repeated\n  --grep <regex>               keep tests whose full name matches, ignoring case\n  --only                       keep tests that use .only, or are inside a describe that does\n  --without-reason             keep tests that don't run and give no reason\n  --fields <keys>              write only these keys of each test, separated by commas; id is always kept\n  --format <format>            json or jsonl, one record per line (default: json)\n  -o, --output <file>          write to a file instead of standard output\n  --pretty                     indent the JSON\n  -h, --help                   show this help\n  -v, --version                show the version\n\nExit codes: 0 when the scan finishes, even with diagnostics; 2 for invalid arguments, an output that cannot be\nwritten, or a crash. 1 is reserved for a future release.\n\nExamples:\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --output inventory.json\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --state skip --fields fullName,reason\n";
+export declare const HELP = "Usage: test-inventory [glob...] --framework <playwright|vitest> [options]\n\nLists the tests in the matching files as JSON, read from the source code without running them. Without globs, the\ntest files are those the Playwright or Vitest configs in the root and the folders below it run.\n\nOptions:\n  --framework <name>           playwright or vitest (required)\n  --root <dir>                 project root; paths in the output are relative to it (default: current directory)\n  --ignore <glob>              leave out matching files; can be repeated (node_modules is always left out)\n  --framework-version <x.y.z>  apply the rules of this framework version instead of the one in the project\n  --comments <mode>            comments above tests: all, non-active or none (default: non-active)\n  --state <state>              keep tests in this state, such as skip or fixme; can be repeated\n  --tag <tag>                  keep tests with this tag, such as @smoke; can be repeated\n  --grep <regex>               keep tests whose full name matches, ignoring case\n  --only                       keep tests that use .only, or are inside a describe that does\n  --without-reason             keep tests that don't run and give no reason\n  --fields <keys>              write only these keys of each test, separated by commas; id is always kept\n  --format <format>            json or jsonl, one record per line (default: json)\n  -o, --output <file>          write to a file instead of standard output\n  --pretty                     indent the JSON\n  -h, --help                   show this help\n  -v, --version                show the version\n\nExit codes: 0 when the scan finishes, even with diagnostics; 2 for invalid arguments, an output that cannot be\nwritten, or a crash. 1 is reserved for a future release.\n\nExamples:\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --output inventory.json\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --state skip --fields fullName,reason\n";
 /** Runs the command line with the given arguments and streams. Resolves to the exit code. */
 export declare function run(argv: string[], io: Io): Promise<number>;

package/dist/cli.js

@@ -8,9 +8,10 @@ import { writeInventory, writeInventoryLines } from "./json.js";
 import { OptionsError } from "./options.js";
 import { scan } from "./scan.js";
 import { toolVersion } from "./version.js";
-export const HELP = `Usage: test-inventory <glob...> --framework <playwright|vitest> [options]
+export const HELP = `Usage: test-inventory [glob...] --framework <playwright|vitest> [options]
 
-Lists the tests in the matching files as JSON, read from the source code without running them.
+Lists the tests in the matching files as JSON, read from the source code without running them. Without globs, the
+test files are those the Playwright or Vitest configs in the root and the folders below it run.
 
 Options:
   --framework <name>           playwright or vitest (required)
@@ -129,8 +130,6 @@ export async function run(argv, io) {
         io.stdout.write(`${toolVersion}\n`);
         return FINISHED;
     }
-    if (positionals.length === 0)
-        return fail('give at least one glob pattern for the test files.');
     if (values.framework === undefined)
         return fail('--framework is required: playwright or vitest.');
     const format = values.format ?? 'json';
@@ -154,7 +153,7 @@ export async function run(argv, io) {
         if (fields !== undefined)
             checkFields(fields);
         inventory = await scan({
-            patterns: positionals,
+            patterns: positionals.length > 0 ? positionals : undefined,
             framework: values.framework,
             root: path.resolve(io.cwd, values.root ?? '.'),
             ignore: values.ignore ?? [],

package/dist/config-runs.d.ts

@@ -0,0 +1,97 @@
+import { type ConfigFile, type Configs, type Setting } from './config.ts';
+import type { FileConfig, VitestTags } from './records.ts';
+import type { Framework, ProjectRecord } from './types.ts';
+/** What makes a file run: as a test, or as a Vitest benchmark, which plain `vitest` doesn't run. */
+type Run = 'test' | 'benchmark';
+/**
+ * What the output says of a project: its name, the folder its test files are found from and Playwright's
+ * `dependencies`. `grep` is Playwright's filter of its test titles, which start from the path in `grepRoot`.
+ */
+export interface ProjectAbout {
+    name: string;
+    testDir: string;
+    dependencies: string[];
+    grep: ((title: string) => boolean) | null;
+    grepRoot: string;
+    defaults: ProjectDefaults;
+}
+/**
+ * The settings a project gives its tests, as written; null when unset. Playwright's `timeout`, `retries`, `repeatEach`
+ * and `fullyParallel`; Vitest's `testTimeout`, `retry`, `repeats` and `sequence.concurrent`, and the tags it defines.
+ */
+interface ProjectDefaults {
+    timeout: Setting | null;
+    retry: Setting | null;
+    repeatEach: Setting | null;
+    repeats: Setting | null;
+    parallel: Setting | null;
+    tags: VitestTags | null;
+}
+/** The config a file uses, the settings of its project, and how that config runs it. */
+export interface Placement {
+    config: ConfigFile | null;
+    settings: Setting | null;
+    /** False when no config runs the file; null when there is no config, or one can't tell. */
+    runs: Run | false | null;
+    /** The projects of the config that run the file, which a Playwright `grep` may narrow per test; null when unknown. */
+    projects: ProjectAbout[] | null;
+}
+/** Finds the configs a file is under and decides which one runs it, as the runner started at the root would. */
+export declare class ConfigRuns {
+    private readonly configs;
+    private readonly framework;
+    private readonly version;
+    /** Whether the configs find the test files, as in a scan without patterns, rather than the patterns. */
+    private readonly findsFiles;
+    private readonly projects;
+    private readonly ignoreRules;
+    private readonly folderStates;
+    /** The Vitest configs whose projects are being found, to stop at one whose projects name itself. */
+    private readonly expanding;
+    constructor(configs: Configs, framework: Framework, version: [number, number] | null, findsFiles: boolean);
+    /**
+     * The config a file uses, as the runner started at the root would: the outermost config at or above it that runs it,
+     * with the project that does; else the outermost one whose files the scan can't work out, reported then; else the
+     * nearest config.
+     */
+    placementOf(file: string): Placement;
+    /** The projects of a config the output lists; null when the scan can't work them out. */
+    projectsIn(config: ConfigFile): ProjectRecord[] | null;
+    private projectsOf;
+    /** Vitest's `retry`: before 4.1, which reads only a count, an object is one the scan can't work out. */
+    private vitestRetry;
+    /** A project whose files can't be worked out, because of `setting` under `key`: it may run any file. */
+    private unknownProject;
+    private playwrightProjects;
+    /** A Playwright project: its own settings, else the config's, else Playwright's defaults. */
+    private playwrightProject;
+    /**
+     * Whether `.gitignore` files in a project's test folder, and the folders below it on the way to the file, leave the
+     * file out, as Playwright reads them.
+     */
+    private isGitIgnored;
+    /** A folder's status and the rules inside it, worked out once per project folder however many files it holds. */
+    private folderState;
+    private rulesIn;
+    private vitestProjects;
+    /** A project written in `test.projects`, which inherits the root config as each version of Vitest decides. */
+    private vitestEntry;
+    /**
+     * The projects of a config file or folder `test.projects` names: the config's own, also the projects it lists in
+     * Vitest 5, or a project with Vitest's defaults for a folder without a config.
+     */
+    private vitestPath;
+    /**
+     * A Vitest project: its files are found from `test.dir`, else `test.root` or `root`, else its folder. With browser
+     * mode on, each of `browser.instances` is a project of its own, named as Vitest names it.
+     */
+    private vitestProject;
+    /** The files a Vitest project runs and its settings; `ownTags`, when set, in place of the tags in `settings`. */
+    private vitestFiles;
+}
+/**
+ * What the config a file uses gives it: Playwright's `forbidOnly`, read from the top level only, as Playwright reads
+ * it, and for each test, the projects that run it and what they set; null without a config.
+ */
+export declare function fileConfig(placement: Placement, framework: Framework, version: [number, number] | null, file: string): FileConfig | null;
+export {};