@flint.fyi/rule-tester 0.19.1 → 0.20.1

package/dist/index.d.mts

@@ -61,10 +61,10 @@ interface TestCases<Options extends object | undefined> {
 }
 type TesterSetupDescribe = (description: string, setup: () => void) => void;
 type TesterSetupIt = (description: string, setup: () => Promise<void>) => void;
-declare class RuleTester {
+export declare class RuleTester {
   #private;
   constructor({ assertNoLanguageReports, defaults, describe, diskBackedFSRoot, it, only, scope, skip }?: RuleTesterOptions);
   describe<OptionsSchema extends AnyOptionalSchema | undefined>(rule: AnyRule<RuleAbout, OptionsSchema>, { invalid, valid }: TestCases<InferredInputObject<OptionsSchema>>): void;
 }
 //#endregion
-export { type InvalidTestCase, RuleTester, type TestCase, type TestSuggestion, type TestSuggestionFileCase, type TestSuggestionForFile, type TestSuggestionForFiles, type ValidTestCase, type ValidTestCaseObject };
+export type { InvalidTestCase, TestCase, TestSuggestion, TestSuggestionFileCase, TestSuggestionForFile, TestSuggestionForFiles, ValidTestCase, ValidTestCaseObject };

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import assert from "node:assert/strict";
-import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import { CachedFactory } from "cached-factory";
-import { applyChangesToText, createDiskBackedLinterHost, createEphemeralLinterHost, createVFSLinterHost, formatReport, getPositionOfColumnAndLine, isSuggestionForFiles, parseOptions, processRuleReport } from "@flint.fyi/core";
+import { resolve } from "pathe";
+import { applyChangesToText, createDiskBackedLinterHost, createEphemeralLinterHost, createVFSLinterHost, formatReport, getPositionOfColumnAndLine, isFileSystemCaseSensitive, isSuggestionForFiles, parseOptions, processRuleReport, withRepositoryRoot } from "@flint.fyi/core";
 import { isTruthy, normalizePath, nullThrows, pathKey } from "@flint.fyi/utils";
 //#region src/createOutput.ts
 function createOutput(reports, testCaseNormalized) {
@@ -98,38 +99,41 @@ function isTestSuggestionForFiles(suggestion) {
 function resolveReportedSuggestions(reports, testCaseNormalized) {
 	const suggestionsReported = reports.flatMap((report) => report.suggestions).filter(isTruthy);
 	if (!suggestionsReported.length) return;
-	return suggestionsReported.map((suggestionReported) => isSuggestionForFiles(suggestionReported) ? {
-		files: resolveReportedSuggestionForFiles(suggestionReported, testCaseNormalized),
-		id: suggestionReported.id
-	} : {
-		id: suggestionReported.id,
-		updated: applyChangesToText([suggestionReported], testCaseNormalized.code)
+	return suggestionsReported.map((suggestionReported, index) => {
+		const suggestionExpected = testCaseNormalized.suggestions?.[index];
+		if (isSuggestionForFiles(suggestionReported)) return {
+			files: resolveReportedSuggestionForFiles(suggestionReported, suggestionExpected),
+			id: suggestionReported.id
+		};
+		if (suggestionExpected && isTestSuggestionForFiles(suggestionExpected)) throw new Error("This test case describes a suggestion across files, but the rule is only reporting changes to its own file.");
+		return {
+			id: suggestionReported.id,
+			updated: applyChangesToText([suggestionReported], testCaseNormalized.code)
+		};
 	});
 }
-function resolveReportedSuggestionForFiles(suggestionReported, testCaseNormalized) {
-	if (!testCaseNormalized.suggestions) return {};
-	if (!testCaseNormalized.suggestions.every(isTestSuggestionForFiles)) throw new Error("This test case describes suggestions across files, but the rule is only reporting changes to its own file.");
-	return Object.fromEntries(testCaseNormalized.suggestions.flatMap((suggestionExpected) => {
-		return Object.entries(suggestionExpected.files).map(([filePath, suggestionCasesExpected]) => {
-			return [filePath, suggestionCasesExpected.map((suggestionCaseExpected) => {
-				const changes = suggestionReported.files[filePath];
-				return {
-					original: suggestionCaseExpected.original,
-					updated: changes ? applyChangesToText(changes, suggestionCaseExpected.original) : suggestionCaseExpected.original
-				};
-			})];
-		});
+function resolveReportedSuggestionForFiles(suggestionReported, suggestionExpected) {
+	if (!suggestionExpected) return {};
+	if (!isTestSuggestionForFiles(suggestionExpected)) throw new Error("This test case describes a suggestion to its own file, but the rule is reporting changes across files.");
+	assert.deepStrictEqual(Object.keys(suggestionReported.files).toSorted(), Object.keys(suggestionExpected.files).toSorted(), "Reported suggestion target paths must exactly match expected target paths.");
+	return Object.fromEntries(Object.entries(suggestionExpected.files).map(([filePath, suggestionCasesExpected]) => {
+		const changes = suggestionReported.files[filePath];
+		assert.ok(changes, `Expected reported suggestion "${suggestionReported.id}" to provide changes for target "${filePath}".`);
+		return [filePath, suggestionCasesExpected.map((suggestionCaseExpected) => ({
+			original: suggestionCaseExpected.original,
+			updated: applyChangesToText(changes, suggestionCaseExpected.original)
+		}))];
 	}));
 }
 //#endregion
 //#region src/runTestCaseRule.ts
 async function runTestCaseRule(fileFactories, linterHost, { options, rule }, { code, fileName, files }, { collectLanguageReports = false } = {}) {
-	const filePathAbsolute = normalizePath(path.resolve(linterHost.getCurrentDirectory(), fileName));
+	const filePathAbsolute = normalizePath(resolve(linterHost.getCurrentDirectory(), fileName));
 	const caseSensitive = linterHost.isCaseSensitiveFS();
 	const targetKey = pathKey(filePathAbsolute, caseSensitive);
 	for (const oldFile of linterHost.vfsListFiles().keys()) if (pathKey(oldFile, caseSensitive) !== targetKey) linterHost.vfsDeleteFile(oldFile);
 	for (const [name, content] of Object.entries(files ?? {})) {
-		const filePath = normalizePath(path.resolve(linterHost.getCurrentDirectory(), name));
+		const filePath = normalizePath(resolve(linterHost.getCurrentDirectory(), name));
 		assert.notEqual(filePath, filePathAbsolute, `Expected 'files' not to shadow '${fileName}'`);
 		linterHost.vfsUpsertFile(filePath, content);
 	}
@@ -149,11 +153,17 @@ async function runTestCaseRule(fileFactories, linterHost, { options, rule }, { c
 		}
 	});
 	if (ruleRuntime) {
-		rule.language.runFileVisitors(file, options, ruleRuntime);
+		if (ruleRuntime.visitors) rule.language.runFileVisitors(file, [{
+			services: {
+				options,
+				...file.services
+			},
+			visitors: ruleRuntime.visitors
+		}]);
 		await ruleRuntime.teardown?.();
 	}
 	return {
-		languageReports: collectLanguageReports ? rule.language.getLanguageReports?.(file) ?? [] : [],
+		languageReports: collectLanguageReports ? rule.language.getLanguageReports?.(file, linterHost) ?? [] : [],
 		reports: reports.toSorted((a, b) => a.range.begin.raw - b.range.begin.raw || a.range.end.raw - b.range.end.raw)
 	};
 }
@@ -164,17 +174,24 @@ var RuleTester = class {
 	#linterHost;
 	#testerOptions;
 	constructor({ assertNoLanguageReports = true, defaults = {}, describe, diskBackedFSRoot, it, only, scope = globalThis, skip } = {}) {
-		let baseHost = diskBackedFSRoot != null ? createEphemeralLinterHost(createDiskBackedLinterHost(path.resolve(process.cwd(), diskBackedFSRoot, "_flint-rule-tester-virtual"))) : void 0;
+		const virtualRoot = diskBackedFSRoot == null ? void 0 : resolve(process.cwd(), diskBackedFSRoot, "_flint-rule-tester-virtual");
+		let baseHost = virtualRoot == null ? void 0 : createEphemeralLinterHost(withRepositoryRoot(createDiskBackedLinterHost(virtualRoot), virtualRoot));
 		const { files: defaultFiles = {} } = defaults;
 		if (Object.keys(defaultFiles).length) {
-			const vfs = createVFSLinterHost(baseHost == null ? { cwd: process.cwd() } : { baseHost });
+			const vfs = createVFSLinterHost(baseHost == null ? {
+				caseSensitive: isFileSystemCaseSensitive(),
+				cwd: process.cwd()
+			} : { baseHost });
 			for (const [name, content] of Object.entries(defaultFiles)) {
-				const filePath = path.resolve(vfs.getCurrentDirectory(), name);
+				const filePath = resolve(vfs.getCurrentDirectory(), name);
 				vfs.vfsUpsertFile(filePath, content);
 			}
 			baseHost = vfs;
 		}
-		this.#linterHost = createVFSLinterHost(baseHost == null ? { cwd: process.cwd() } : { baseHost });
+		this.#linterHost = createVFSLinterHost(baseHost == null ? {
+			caseSensitive: isFileSystemCaseSensitive(),
+			cwd: process.cwd()
+		} : { baseHost });
 		this.#fileFactories = new CachedFactory((language) => language.createFileFactory(this.#linterHost));
 		it = defaultTo(it, scope, "it");
 		if (!skip && "skip" in it && typeof it.skip === "function") skip = it.skip;
@@ -194,16 +211,18 @@ var RuleTester = class {
 	describe(rule, { invalid, valid }) {
 		this.#testerOptions.describe(rule.about.id, () => {
 			this.#testerOptions.describe("invalid", () => {
-				for (const testCase of invalid) this.#itInvalidCase(rule, testCase);
+				const seenTestCases = [];
+				for (const testCase of invalid) this.#itInvalidCase(rule, testCase, seenTestCases);
 			});
 			this.#testerOptions.describe("valid", () => {
-				for (const testCase of valid) this.#itValidCase(rule, testCase);
+				const seenTestCases = [];
+				for (const testCase of valid) this.#itValidCase(rule, testCase, seenTestCases);
 			});
 		});
 	}
-	#itInvalidCase(rule, testCase) {
+	#itInvalidCase(rule, testCase, seenTestCases) {
 		const testCaseNormalized = normalizeTestCase(testCase, this.#testerOptions.defaults.fileName);
-		this.#itTestCase(testCaseNormalized, async () => {
+		this.#itTestCase(testCaseNormalized, seenTestCases, async () => {
 			const { languageReports, reports } = await runTestCaseRule(this.#fileFactories, this.#linterHost, {
 				options: parseOptions(rule.options, testCase.options),
 				rule
@@ -217,24 +236,22 @@ var RuleTester = class {
 			assert.deepStrictEqual(actualSuggestions, testCase.suggestions);
 		});
 	}
-	#itTestCase(testCase, setup) {
+	#itTestCase(testCase, seenTestCases, setup) {
 		let test = testCase.only ? this.#testerOptions.only : this.#testerOptions.it;
-		if (testCase.skip) {
-			if ("skip" in test && typeof test.skip === "function") test = test.skip;
-			else test = this.#testerOptions.skip;
-		}
+		if (testCase.skip) test = "skip" in test && typeof test.skip === "function" ? test.skip : this.#testerOptions.skip;
 		test(testCase.name ?? ("files" in testCase ? JSON.stringify({
 			[testCase.fileName]: testCase.code,
 			...testCase.files
 		}, null, 2) : testCase.code), () => {
+			assertNoDuplicateTestCase(testCase, seenTestCases);
 			if (testCase.files != null) assert.notEqual(Object.keys(testCase.files).length, 0, `'files' must have at least one file`);
 			return setup();
 		});
 	}
-	#itValidCase(rule, testCaseRaw) {
+	#itValidCase(rule, testCaseRaw, seenTestCases) {
 		const testCase = typeof testCaseRaw === "string" ? { code: testCaseRaw } : testCaseRaw;
 		const testCaseNormalized = normalizeTestCase(testCase, this.#testerOptions.defaults.fileName);
-		this.#itTestCase(testCaseNormalized, async () => {
+		this.#itTestCase(testCaseNormalized, seenTestCases, async () => {
 			const { languageReports, reports } = await runTestCaseRule(this.#fileFactories, this.#linterHost, {
 				options: parseOptions(rule.options, testCase.options),
 				rule
@@ -244,6 +261,16 @@ var RuleTester = class {
 		});
 	}
 };
+function assertNoDuplicateTestCase(testCase, seenTestCases) {
+	const duplicateProperties = {
+		code: testCase.code,
+		fileName: testCase.fileName,
+		files: testCase.files,
+		options: testCase.options
+	};
+	if (seenTestCases.some((seenTestCase) => isDeepStrictEqual(seenTestCase, duplicateProperties))) assert.fail("Expected no duplicate test cases, but an earlier test case has the same code, fileName, files, and options.");
+	seenTestCases.push(duplicateProperties);
+}
 function assertNoLanguageReports(languageReports) {
 	if (languageReports.length) assert.fail([`Expected no language reports, but found ${languageReports.length}:`, ...languageReports.map((languageReport) => languageReport.text)].join("\n\n"));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/rule-tester",
-  "version": "0.19.1",
+  "version": "0.20.1",
   "description": "[Experimental] Rule unit tests for Flint.",
   "homepage": "https://flint.fyi",
   "repository": {
@@ -16,20 +16,22 @@
   "sideEffects": false,
   "type": "module",
   "exports": {
-    ".": "./dist/index.mjs"
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
   },
   "files": [
     "dist/"
   ],
   "dependencies": {
-    "@flint.fyi/core": "^0.26.0",
-    "@flint.fyi/utils": "^0.16.0",
-    "cached-factory": "^0.3.0"
+    "@flint.fyi/core": "^0.28.0",
+    "@flint.fyi/utils": "^0.16.1",
+    "cached-factory": "^0.3.0",
+    "pathe": "^2.0.3"
   },
   "devDependencies": {
     "@flint.fyi/build": "^0.1.0",
-    "tsdown": "0.22.14",
-    "vitest": "4.1.11"
+    "tsdown": "0.23.0",
+    "vitest": "5.0.1"
   },
   "engines": {
     "node": ">=26.1.0"