@joshuafolkken/kit 1.3092.0 → 1.3099.0

package/scripts/test/test-pinned-cache-logic.ts

@@ -17,13 +17,14 @@ import type { RedProbe, RedVerdict } from './test-red-logic'
 // failed before the revert reads red too — and a red kept past any of those, or past an edit to the test
 // that failed, would pass an unpinned hunk. A test added or edited elsewhere cannot make that test
 // pass, so it keeps the red. A red with no failed file recorded holds only while no test file changed either.
-// **A `green` or `no-test` one holds while no test file's path or content changed** (`test_contents`):
-// it is only rechecked when a test could have come to reach it, and a stale one stops a lane rather
-// than passing it.
+// **A `green` or `no-test` one holds while no test file's path or content changed, nor the test
+// runner's configuration** (`test_contents`, joshuafolkken/kit#7521 — a widened `include` runs a test
+// that never ran): it is only rechecked when a test could have come to reach it, and a stale one stops a
+// lane rather than passing it.
 // **Past those tree-wide digests, a verdict also holds while its own `basis` is the same**
 // (joshuafolkken/kit#4873): for a `red`, the base commit, the changed non-code and whole-suite files,
 // and each failed test's import closure; for any other, the tests whose imports reach the hunk's file,
-// with their content. An edit outside them keeps the verdict; with no basis — no import graph, no
+// with their content, and the test runner's configuration. An edit outside them keeps the verdict; with no basis — no import graph, no
 // failed file recorded — only the tree-wide digests hold it, as before.
 // **A `red` verdict also holds while `pruned` reads the same** (joshuafolkken/kit#5004): the code
 // change since differs only by lines removed from `green` hunks (`test-pinned-prune-logic.ts`).
@@ -219,11 +220,16 @@ function fresh_verdict(
 	return { verdict: entry.verdict, failed: Object.keys(entry.tests) }
 }
 
-// A `green` or `no-test` verdict's basis: each test whose imports reach the hunk's file, with its content.
-function related_basis(tests: ReadonlyArray<string>, digests: ReadonlyMap<string, string>): Basis {
+// A `green` or `no-test` verdict's basis: each test whose imports reach the hunk's file, with its content,
+// and `config`, the test runner's configuration — which of those tests a run collects.
+function related_basis(
+	tests: ReadonlyArray<string>,
+	digests: ReadonlyMap<string, string>,
+	config: string,
+): Basis {
 	const pairs = sorted(tests).map((file) => [file, digests.get(file) ?? ''] as const)
 
-	return { digest: digest_of(JSON.stringify(pairs)), related: Object.fromEntries(pairs) }
+	return { digest: digest_of(JSON.stringify([config, pairs])), related: Object.fromEntries(pairs) }
 }
 
 // The tests added or edited since `before` was read; `undefined` once one of its tests is gone or no

package/scripts/test/test-pinned-cache.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'
+import { config_fingerprint } from '#eslint/config-fingerprint.js'
 import { changed_paths } from '#scripts/git/changed-paths'
 import { git_spawn } from '#scripts/git/git-spawn'
 import { run_record_path } from '#scripts/josh/run-record-path'
@@ -18,6 +19,7 @@ import type { Hunk } from './test-pinned-logic'
 import { test_pinned_prune_logic, type CodeChange } from './test-pinned-prune-logic'
 import { test_pinned_reach, type Reach } from './test-pinned-reach'
 import type { RedProbe } from './test-red-logic'
+import { test_runner_config } from './test-runner-config'
 
 // The reads and writes of `josh test:pinned`'s verdict cache (joshuafolkken/kit#4706); what a key is and
 // when an entry holds is `test-pinned-cache-logic.ts`. `josh run:review` calls the same `test_pinned.run`,
@@ -31,9 +33,11 @@ const LINE_BREAK = '\n'
 // Peels a ref or tag to the commit it names, so a branch name and its SHA key the same change.
 const AS_COMMIT = '^{commit}'
 
+// `config` is one digest over the test runner's configuration files, which `test_contents` covers too.
 interface TreeRead {
 	test_digests: ReadonlyMap<string, string>
 	code: CodeChange
+	config: string
 	test_contents: string
 	change: string
 }
@@ -45,6 +49,7 @@ interface LoadedCache extends VerdictCache {
 	base: string
 	freshness: Freshness
 	test_digests: ReadonlyMap<string, string>
+	config: string
 	reach: Reach
 	code: CodeChange
 	hunks: ReadonlyArray<Hunk>
@@ -79,11 +84,11 @@ async function contents_of(files: ReadonlyArray<string>): Promise<Map<string, st
 	return new Map(existing.map((file, index) => [file, texts[index] ?? '']))
 }
 
-// Every test file in the work tree, tracked or untracked but not ignored.
-async function test_files(): Promise<Array<string>> {
+// Every file in the work tree `is_kept` accepts, tracked or untracked but not ignored.
+async function work_tree_files(is_kept: (file: string) => boolean): Promise<Array<string>> {
 	const listed = await test_pinned_reach.work_tree_files()
 
-	return listed.filter((file) => test_declared_logic.is_test_file(file))
+	return listed.filter((file) => is_kept(file))
 }
 
 // The digest of each named file the work tree still holds.
@@ -95,9 +100,20 @@ async function digests_of(files: ReadonlyArray<string>): Promise<Map<string, str
 	)
 }
 
-// Each test file's content digest, keyed by its path.
-async function test_digests_of(): Promise<Map<string, string>> {
-	return await digests_of(await test_files())
+// Each work tree file's content digest `is_kept` accepts, keyed by its path.
+async function kept_digests_of(is_kept: (file: string) => boolean): Promise<Map<string, string>> {
+	return await digests_of(await work_tree_files(is_kept))
+}
+
+// Each test runner configuration file and every local module it imports — where an `include` list may
+// sit, as `tools/test/vitest-include-globs.ts` does here — with its content digest.
+async function config_digests_of(): Promise<Map<string, string>> {
+	const configs = await work_tree_files((file) => test_runner_config.is_config(file))
+	const reached = config_fingerprint.list_reachable_modules(
+		configs.map((file) => path.resolve(file)),
+	)
+
+	return await digests_of([...reached].map((file) => path.relative(process.cwd(), file)))
 }
 
 // One digest over every test file's path and content.
@@ -123,13 +139,19 @@ async function code_change(base: string): Promise<CodeChange> {
 	return { commit: commit.trim(), code, digests: await digests_of(code) }
 }
 
-// The work tree's tree-wide digests, with what they were read off.
+// The work tree's tree-wide digests, with what they were read off. A test runner configuration change
+// can make a test run that never ran, so it moves `test_contents` as a test file would
+// (joshuafolkken/kit#7521).
 async function read_tree(base: string): Promise<TreeRead> {
-	const [test_digests, code] = await Promise.all([test_digests_of(), code_change(base)])
-	const test_contents = contents_digest(test_digests)
+	const [test_digests, configs, code] = await Promise.all([
+		kept_digests_of((file) => test_declared_logic.is_test_file(file)),
+		config_digests_of(),
+		code_change(base),
+	])
+	const test_contents = contents_digest(new Map([...test_digests, ...configs]))
 	const change = test_pinned_cache_logic.change_of(code.commit, code.code, code.digests)
 
-	return { test_digests, code, test_contents, change }
+	return { test_digests, code, config: contents_digest(configs), test_contents, change }
 }
 
 // The cache file's text and what the work tree holds now, with the files `hunks` and the recorded
@@ -176,7 +198,7 @@ async function basis_of(
 	if (probe.verdict !== 'red') {
 		const tests = await cache.reach.related(file)
 
-		return tests && test_pinned_cache_logic.related_basis(tests, cache.test_digests)
+		return tests && test_pinned_cache_logic.related_basis(tests, cache.test_digests, cache.config)
 	}
 
 	const digest = await cache.reach.failed(probe.failed)

package/scripts/test/test-runner-config.ts

@@ -0,0 +1,19 @@
+import path from 'node:path'
+
+// The test runner's configuration files (joshuafolkken/kit#7521): which tests a run collects is theirs
+// to decide (`include`, projects), so a change to one can make a test run that never ran before. A
+// leaf module, so `verification-inputs.ts` and `josh test:pinned`'s verdict cache share the names.
+
+// A file name starting with one of these configures vitest.
+const PREFIXES: ReadonlyArray<string> = ['vitest.config.', 'vitest.workspace.', 'vite.config.']
+
+// A configuration vitest reads from the repository root; one nested deeper is a fixture or a package's own.
+function is_config(relative: string): boolean {
+	if (path.dirname(relative) !== '.') return false
+
+	return PREFIXES.some((prefix) => relative.startsWith(prefix))
+}
+
+const test_runner_config = { is_config, PREFIXES }
+
+export { test_runner_config }