@flint.fyi/rule-tester 0.14.0 → 0.14.2

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

@@ -7,6 +7,7 @@ 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(
@@ -21,19 +22,23 @@ export function resolveReportedSuggestions(
 		return undefined;
 	}
 
-	return suggestionsReported.map((suggestionReported) => ({
-		files: isSuggestionForFiles(suggestionReported)
-			? resolveReportedSuggestionForFiles(
-					suggestionReported,
-					testCaseNormalized,
-				)
-			: [
-					{
-						[testCaseNormalized.fileName]: suggestionReported,
-					},
-				],
-		id: suggestionReported.id,
-	}));
+	return suggestionsReported.map((suggestionReported) =>
+		isSuggestionForFiles(suggestionReported)
+			? {
+					files: resolveReportedSuggestionForFiles(
+						suggestionReported,
+						testCaseNormalized,
+					),
+					id: suggestionReported.id,
+				}
+			: {
+					id: suggestionReported.id,
+					updated: applyChangesToText(
+						[suggestionReported],
+						testCaseNormalized.code,
+					),
+				},
+	);
 }
 
 function resolveReportedSuggestionForFiles(
@@ -44,6 +49,12 @@ function resolveReportedSuggestionForFiles(
 		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[]][] => {

package/src/runTestCaseRule.ts

@@ -2,9 +2,9 @@ import {
 	AnyLanguage,
 	AnyOptionalSchema,
 	AnyRule,
-	BaseAbout,
 	InferredObject,
 	LanguageFileFactory,
+	RuleAbout,
 } from "@flint.fyi/core";
 import { CachedFactory } from "cached-factory";
 
@@ -14,7 +14,7 @@ export interface TestCaseRuleConfiguration<
 	OptionsSchema extends AnyOptionalSchema | undefined,
 > {
 	options?: InferredObject<OptionsSchema>;
-	rule: AnyRule<BaseAbout, OptionsSchema>;
+	rule: AnyRule<RuleAbout, OptionsSchema>;
 }
 
 export function runTestCaseRule<

package/src/types.ts

@@ -11,19 +11,41 @@ export interface TestCase<
 > {
 	code: string;
 	fileName?: string;
+
+	/**
+	 * Run only this test case. Useful for debugging.
+	 *
+	 * Do not commit code with this flag set.
+	 */
+	only?: boolean;
+
 	options?: Options;
-}
 
-export interface TestSuggestion {
-	files: Record<string, TestSuggestionFileCase[]>;
-	id: string;
+	/**
+	 * 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>;