@flint.fyi/rule-tester 0.13.1 → 0.14.1

package/src/createReportSnapshot.ts

@@ -1,8 +1,8 @@
-import { formatReportPrimary, NormalizedRuleReport } from "@flint.fyi/core";
+import { formatReportPrimary, NormalizedReport } from "@flint.fyi/core";
 
 export function createReportSnapshot(
 	sourceText: string,
-	reports: NormalizedRuleReport[],
+	reports: NormalizedReport[],
 ) {
 	let result = sourceText;
 
@@ -13,10 +13,7 @@ export function createReportSnapshot(
 	return result;
 }
 
-function createReportSnapshotAt(
-	sourceText: string,
-	report: NormalizedRuleReport,
-) {
+function createReportSnapshotAt(sourceText: string, report: NormalizedReport) {
 	const range = report.range;
 
 	const lineEndIndex = ifNegative(
@@ -28,7 +25,7 @@ function createReportSnapshotAt(
 		0,
 	);
 
-	const column = ifNegative(range.begin.raw - lineStartIndex - 2, 0);
+	const column = ifNegative(range.begin.raw - lineStartIndex - 1, 0);
 	const width = range.end.raw - range.begin.raw;
 
 	const injectionPrefix = " ".repeat(column);

package/src/index.ts

@@ -1 +1,2 @@
 export { RuleTester } from "./RuleTester.js";
+export type * from "./types.js";

package/src/normalizeTestCase.ts

@@ -0,0 +1,14 @@
+import { TestCase } from "./types.js";
+
+export interface TestCaseNormalized extends TestCase {
+	fileName: string;
+}
+
+export function normalizeTestCase<T extends TestCase>(
+	testCase: T,
+): T & TestCaseNormalized {
+	return {
+		fileName: "file.ts",
+		...testCase,
+	};
+}

package/src/predicates.ts

@@ -0,0 +1,7 @@
+import { TestSuggestion, TestSuggestionForFiles } from "./types.js";
+
+export function isTestSuggestionForFiles(
+	suggestion: TestSuggestion,
+): suggestion is TestSuggestionForFiles {
+	return "files" in suggestion;
+}

package/src/resolveReportedSuggestions.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from "vitest";
+
+import { resolveReportedSuggestions } from "./resolveReportedSuggestions.js";
+
+const mockReport = {
+	message: { primary: "", secondary: [], suggestions: [] },
+	range: {
+		begin: { column: 0, line: 1, raw: 0 },
+		end: { column: 3, line: 1, raw: 3 },
+	},
+};
+
+const mockTestCaseNormalized = {
+	code: "xyz",
+	fileName: "file.ts",
+	snapshot: "",
+};
+
+describe("resolveReportedSuggestions", () => {
+	it("returns undefined when reports is empty", () => {
+		const result = resolveReportedSuggestions([], mockTestCaseNormalized);
+
+		expect(result).toEqual(undefined);
+	});
+
+	it("returns undefined when given one report with no suggestions", () => {
+		const report = {
+			...mockReport,
+			suggestions: [],
+		};
+
+		const result = resolveReportedSuggestions([report], mockTestCaseNormalized);
+
+		expect(result).toEqual(undefined);
+	});
+
+	it("returns id and updated text when given a single file suggestion", () => {
+		const suggestion = {
+			id: "suggestion",
+			range: { begin: 0, end: 3 },
+			text: "abc",
+		};
+		const report = {
+			...mockReport,
+			suggestions: [suggestion],
+		};
+
+		const result = resolveReportedSuggestions([report], mockTestCaseNormalized);
+
+		expect(result).toEqual([
+			{
+				id: suggestion.id,
+				updated: suggestion.text,
+			},
+		]);
+	});
+
+	it("throws when given a test case with no suggestions", () => {
+		const report = {
+			...mockReport,
+			suggestions: [
+				{
+					files: {
+						"file.ts": () => [{ range: { begin: 0, end: 3 }, text: "def" }],
+					},
+					id: "suggestion-report",
+				},
+			],
+		};
+
+		expect(() =>
+			resolveReportedSuggestions([report], {
+				...mockTestCaseNormalized,
+				suggestions: [
+					{
+						id: "suggestion-result",
+						updated: "...",
+					},
+				],
+			}),
+		).toThrowErrorMatchingInlineSnapshot(
+			`[Error: This test case describes suggestions across files, but the rule is only reporting changes to its own file.]`,
+		);
+	});
+
+	it("throws when given a test case that doesn't have cross-file suggestions", () => {
+		const report = {
+			...mockReport,
+			suggestions: [
+				{
+					files: {
+						"file.ts": () => [{ range: { begin: 0, end: 3 }, text: "def" }],
+					},
+					id: "suggestion-report",
+				},
+			],
+		};
+
+		expect(() =>
+			resolveReportedSuggestions([report], {
+				...mockTestCaseNormalized,
+				suggestions: [
+					{
+						id: "suggestion-result",
+						updated: "...",
+					},
+				],
+			}),
+		).toThrowErrorMatchingInlineSnapshot(
+			`[Error: This test case describes suggestions across files, but the rule is only reporting changes to its own file.]`,
+		);
+	});
+
+	it("returns id and a files object when given multi-file suggestions with a single file", () => {
+		const report = {
+			...mockReport,
+			suggestions: [
+				{
+					files: {
+						"file.ts": () => [{ range: { begin: 0, end: 3 }, text: "def" }],
+					},
+					id: "suggestion-report",
+				},
+			],
+		};
+
+		const result = resolveReportedSuggestions([report], {
+			...mockTestCaseNormalized,
+			suggestions: [
+				{
+					files: {
+						"file.ts": [{ original: "abc", updated: "def" }],
+					},
+					id: "suggestion-result",
+				},
+			],
+		});
+
+		expect(result).toEqual([
+			{
+				files: {
+					"file.ts": [
+						{
+							original: "abc",
+							updated: "def",
+						},
+					],
+				},
+				id: "suggestion-report",
+			},
+		]);
+	});
+
+	it("returns id and a files object when given multi-file suggestions with multiple file", () => {
+		const report = {
+			...mockReport,
+			suggestions: [
+				{
+					files: {
+						"fileA.ts": () => [{ range: { begin: 0, end: 5 }, text: "def-A" }],
+						"fileB.ts": () => [{ range: { begin: 0, end: 5 }, text: "def-B" }],
+					},
+					id: "suggestion-report",
+				},
+			],
+		};
+
+		const result = resolveReportedSuggestions([report], {
+			...mockTestCaseNormalized,
+			suggestions: [
+				{
+					files: {
+						"fileA.ts": [{ original: "abc-A", updated: "def-A" }],
+						"fileB.ts": [{ original: "abc-B", updated: "def-B" }],
+					},
+					id: "suggestion-result",
+				},
+			],
+		});
+
+		expect(result).toEqual([
+			{
+				files: {
+					"fileA.ts": [
+						{
+							original: "abc-A",
+							updated: "def-A",
+						},
+					],
+					"fileB.ts": [
+						{
+							original: "abc-B",
+							updated: "def-B",
+						},
+					],
+				},
+				id: "suggestion-report",
+			},
+		]);
+	});
+});

package/src/resolveReportedSuggestions.ts

@@ -0,0 +1,85 @@
+import {
+	applyChangesToText,
+	isSuggestionForFiles,
+	NormalizedReport,
+} from "@flint.fyi/core";
+import { SuggestionForFiles } from "@flint.fyi/core/src/types/changes.js";
+import { isTruthy } from "@flint.fyi/utils";
+
+import { TestCaseNormalized } from "./normalizeTestCase.js";
+import { isTestSuggestionForFiles } from "./predicates.js";
+import { InvalidTestCase, TestSuggestionFileCase } from "./types.js";
+
+export function resolveReportedSuggestions(
+	reports: NormalizedReport[],
+	testCaseNormalized: InvalidTestCase & TestCaseNormalized,
+) {
+	const suggestionsReported = reports
+		.flatMap((report) => report.suggestions)
+		.filter(isTruthy);
+
+	if (!suggestionsReported.length) {
+		return undefined;
+	}
+
+	return suggestionsReported.map((suggestionReported) =>
+		isSuggestionForFiles(suggestionReported)
+			? {
+					files: resolveReportedSuggestionForFiles(
+						suggestionReported,
+						testCaseNormalized,
+					),
+					id: suggestionReported.id,
+				}
+			: {
+					id: suggestionReported.id,
+					updated: applyChangesToText(
+						[suggestionReported],
+						testCaseNormalized.code,
+					),
+				},
+	);
+}
+
+function resolveReportedSuggestionForFiles(
+	suggestionReported: SuggestionForFiles,
+	testCaseNormalized: InvalidTestCase & 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
+			.map((suggestionExpected): [string, TestSuggestionFileCase[]][] => {
+				return Object.entries(suggestionExpected.files).map(
+					([filePath, suggestionCasesExpected]) => {
+						return [
+							filePath,
+							suggestionCasesExpected.map((suggestionCaseExpected) => {
+								const changes = suggestionReported.files[filePath]?.(
+									suggestionCaseExpected.original,
+								);
+								return {
+									original: suggestionCaseExpected.original,
+									updated: changes
+										? applyChangesToText(
+												changes,
+												suggestionCaseExpected.original,
+											)
+										: suggestionCaseExpected.original,
+								};
+							}),
+						];
+					},
+				);
+			})
+			.flat(),
+	);
+}

package/src/runTestCaseRule.ts

@@ -8,10 +8,7 @@ import {
 } from "@flint.fyi/core";
 import { CachedFactory } from "cached-factory";
 
-export interface NormalizedTestCase {
-	code: string;
-	fileName?: string;
-}
+import { TestCaseNormalized } from "./normalizeTestCase.js";
 
 export interface TestCaseRuleConfiguration<
 	OptionsSchema extends AnyOptionalSchema | undefined,
@@ -25,14 +22,14 @@ export function runTestCaseRule<
 >(
 	fileFactories: CachedFactory<AnyLanguage, LanguageFileFactory>,
 	{ options, rule }: Required<TestCaseRuleConfiguration<OptionsSchema>>,
-	{ code, fileName = "file.ts" }: NormalizedTestCase,
+	{ code, fileName }: TestCaseNormalized,
 ) {
 	using file = fileFactories
 		// TODO: How to make types more permissive around assignability?
 		// See AnyRule's any
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
 		.get(rule.language)
-		.prepareFileVirtually(fileName, code);
+		.prepareFromVirtual(fileName, code).file;
 
 	return file.runRule(rule, options as InferredObject<OptionsSchema>);
 }

package/src/types.ts

@@ -0,0 +1,54 @@
+export interface InvalidTestCase<
+	Options extends object | undefined = object | undefined,
+> extends TestCase<Options> {
+	output?: string;
+	snapshot: string;
+	suggestions?: TestSuggestion[];
+}
+
+export interface TestCase<
+	Options extends object | undefined = object | undefined,
+> {
+	code: string;
+	fileName?: string;
+
+	/**
+	 * Run only this test case. Useful for debugging.
+	 *
+	 * Do not commit code with this flag set.
+	 */
+	only?: boolean;
+
+	options?: Options;
+
+	/**
+	 * Skip running this test case. Useful for work-in-progress tests.
+	 *
+	 * Do not commit code with this flag set.
+	 */
+	skip?: boolean;
+}
+
+export type TestSuggestion = TestSuggestionForFile | TestSuggestionForFiles;
+
+export interface TestSuggestionFileCase {
+	original: string;
+	updated: string;
+}
+
+export interface TestSuggestionForFile {
+	id: string;
+	updated: string;
+}
+
+export interface TestSuggestionForFiles {
+	files: Record<string, TestSuggestionFileCase[]>;
+	id: string;
+}
+
+export type ValidTestCase<Options extends object | undefined> =
+	| string
+	| ValidTestCaseObject<Options>;
+
+export type ValidTestCaseObject<Options extends object | undefined> =
+	TestCase<Options>;

package/tsconfig.json

@@ -5,5 +5,5 @@
 	},
 	"extends": "../../tsconfig.base.json",
 	"include": ["src"],
-	"references": [{ "path": "../core" }]
+	"references": [{ "path": "../core" }, { "path": "../utils" }]
 }