@flint.fyi/rule-tester 0.14.3 → 0.16.1

package/lib/types.d.ts

@@ -1,37 +1,43 @@
-export interface InvalidTestCase<Options extends object | undefined = object | undefined> extends TestCase<Options> {
-    output?: string;
-    snapshot: string;
-    suggestions?: TestSuggestion[];
+//#region src/types.d.ts
+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;
+interface TestCase<Options extends object | undefined = object | undefined> {
+  code: string;
+  fileName?: string | undefined;
+  files?: Record<string, string> | undefined;
+  name?: string | undefined;
+  /**
+   * Run only this test case. Useful for debugging.
+   *
+   * Do not commit code with this flag set.
+   */
+  only?: boolean;
+  options?: Options | undefined;
+  /**
+   * 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;
+type TestSuggestion = TestSuggestionForFile | TestSuggestionForFiles;
+interface TestSuggestionFileCase {
+  original: string;
+  updated: string;
 }
-export interface TestSuggestionForFile {
-    id: string;
-    updated: string;
+interface TestSuggestionForFile {
+  id: string;
+  updated: string;
 }
-export interface TestSuggestionForFiles {
-    files: Record<string, TestSuggestionFileCase[]>;
-    id: string;
+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>;
+type ValidTestCase<Options extends object | undefined> = string | ValidTestCaseObject<Options>;
+type ValidTestCaseObject<Options extends object | undefined> = TestCase<Options>;
+//#endregion
+export { InvalidTestCase, TestCase, TestSuggestion, TestSuggestionFileCase, TestSuggestionForFile, TestSuggestionForFiles, ValidTestCase, ValidTestCaseObject };
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@flint.fyi/rule-tester",
-  "version": "0.14.3",
+  "version": "0.16.1",
   "description": "[Experimental] Rule unit tests for Flint.",
+  "homepage": "https://flint.fyi",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JoshuaKGoldberg/flint",
+    "url": "git+https://github.com/flint-fyi/flint.git",
     "directory": "packages/rule-tester"
   },
   "license": "MIT",
@@ -12,18 +13,31 @@
     "name": "JoshuaKGoldberg",
     "email": "npm@joshuakgoldberg.com"
   },
+  "sideEffects": false,
   "type": "module",
-  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map"
+  ],
   "dependencies": {
-    "@flint.fyi/core": "",
-    "@flint.fyi/utils": "",
-    "cached-factory": "^0.1.0"
+    "cached-factory": "^0.1.0",
+    "@flint.fyi/core": "^0.21.0",
+    "@flint.fyi/utils": "^0.14.1"
+  },
+  "devDependencies": {
+    "tsdown": "0.21.0",
+    "vitest": "4.1.0"
   },
   "engines": {
     "node": ">=24.0.0"
   },
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest --project rule-tester"
   }
 }

package/CHANGELOG.md

@@ -1,53 +0,0 @@
-# @flint/rule-tester
-
-## 0.14.3
-
-### Patch Changes
-
-- 738fe36: fix: support multiline error ranges in RuleTester
-
-## 0.14.2
-
-### Patch Changes
-
-- a3f9043: fix: respect \`only\` and \`skip\` options in valid RuleTester cases
-- Updated dependencies [3d19082]
-  - @flint.fyi/core@0.15.1
-
-## 0.14.1
-
-### Patch Changes
-
-- b58d145: corrected logic and types for current-file suggestions
-
-## 0.14.0
-
-### Minor Changes
-
-- 7d0d873: add // flint-\* comment directives
-
-### Patch Changes
-
-- Updated dependencies [b48f4a9]
-- Updated dependencies [7d0d873]
-- Updated dependencies [79f15da]
-  - @flint.fyi/core@0.15.0
-
-## 0.13.1
-
-### Patch Changes
-
-- 9909b48: add README.md
-- Updated dependencies [9909b48]
-  - @flint.fyi/core@0.13.1
-
-## 0.13.0
-
-### Minor Changes
-
-- 72ed00b: feat: split into a monorepo
-
-### Patch Changes
-
-- Updated dependencies [72ed00b]
-  - @flint/core@0.13.0

package/lib/resolveReportedSuggestions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/resolveReportedSuggestions.test.js

@@ -1,172 +0,0 @@
-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/lib/types.js

@@ -1 +0,0 @@
-export {};

package/src/RuleTester.ts

@@ -1,186 +0,0 @@
-import {
-	AnyLanguage,
-	AnyOptionalSchema,
-	AnyRule,
-	InferredObject,
-	LanguageFileFactory,
-	RuleAbout,
-} from "@flint.fyi/core";
-import { CachedFactory } from "cached-factory";
-import assert from "node:assert";
-
-import { createReportSnapshot } from "./createReportSnapshot.js";
-import { normalizeTestCase } from "./normalizeTestCase.js";
-import { resolveReportedSuggestions } from "./resolveReportedSuggestions.js";
-import { runTestCaseRule } from "./runTestCaseRule.js";
-import { InvalidTestCase, TestCase, ValidTestCase } from "./types.js";
-
-export interface RuleTesterOptions {
-	describe?: TesterSetupDescribe;
-	it?: TesterSetupIt;
-	only?: TesterSetupIt;
-	scope?: Record<string, unknown>;
-	skip?: TesterSetupIt;
-}
-
-export interface TestCases<Options extends object | undefined> {
-	invalid: InvalidTestCase<Options>[];
-	valid: ValidTestCase<Options>[];
-}
-
-export type TesterSetupDescribe = (
-	description: string,
-	setup: () => void,
-) => void;
-
-export type TesterSetupIt = (
-	description: string,
-	setup: () => Promise<void>,
-) => void;
-
-export class RuleTester {
-	#fileFactories: CachedFactory<AnyLanguage, LanguageFileFactory>;
-	#testerOptions: Required<RuleTesterOptions>;
-
-	constructor({
-		describe,
-		it,
-		only,
-		scope = globalThis,
-		skip,
-	}: RuleTesterOptions = {}) {
-		this.#fileFactories = new CachedFactory((language: AnyLanguage) =>
-			language.prepare(),
-		);
-
-		it = defaultTo(it, scope, "it");
-
-		if (!skip && "skip" in it && typeof it.skip === "function") {
-			skip = it.skip as TesterSetupIt;
-		}
-		if (!only && "only" in it && typeof it.only === "function") {
-			only = it.only as TesterSetupIt;
-		}
-		if (!skip) {
-			throw new TypeError("RuleTester needs a `skip` function");
-		}
-		if (!only) {
-			throw new TypeError("RuleTester needs a `only` function");
-		}
-
-		this.#testerOptions = {
-			describe: defaultTo(describe, scope, "describe"),
-			it,
-			only,
-			scope,
-			skip,
-		};
-	}
-
-	describe<OptionsSchema extends AnyOptionalSchema | undefined>(
-		rule: AnyRule<RuleAbout, OptionsSchema>,
-		{ invalid, valid }: TestCases<InferredObject<OptionsSchema>>,
-	) {
-		this.#testerOptions.describe(rule.about.id, () => {
-			this.#testerOptions.describe("invalid", () => {
-				for (const testCase of invalid) {
-					this.#itInvalidCase(rule, testCase);
-				}
-			});
-
-			this.#testerOptions.describe("valid", () => {
-				for (const testCase of valid) {
-					this.#itValidCase(rule, testCase);
-				}
-			});
-		});
-	}
-
-	#itInvalidCase<OptionsSchema extends AnyOptionalSchema | undefined>(
-		rule: AnyRule<RuleAbout, OptionsSchema>,
-		testCase: InvalidTestCase<InferredObject<OptionsSchema>>,
-	) {
-		const testCaseNormalized = normalizeTestCase(testCase);
-
-		this.#itTestCase(testCaseNormalized, async () => {
-			const reports = await runTestCaseRule(
-				this.#fileFactories,
-				{
-					// TODO: Figure out a way around the type assertion...
-					options: testCase.options ?? ({} as InferredObject<OptionsSchema>),
-					rule,
-				},
-				testCaseNormalized,
-			);
-			const actualSnapshot = createReportSnapshot(testCase.code, reports);
-
-			assert.equal(actualSnapshot, testCase.snapshot);
-
-			const actualSuggestions = resolveReportedSuggestions(
-				reports,
-				testCaseNormalized,
-			);
-			assert.deepStrictEqual(actualSuggestions, testCase.suggestions);
-		});
-	}
-
-	#itTestCase(testCase: TestCase, setup: () => Promise<void>) {
-		let test = testCase.only
-			? this.#testerOptions.only
-			: this.#testerOptions.it;
-
-		if (testCase.skip) {
-			if ("skip" in test && typeof test.skip === "function") {
-				test = test.skip as TesterSetupIt;
-			} else {
-				test = this.#testerOptions.skip;
-			}
-		}
-
-		test(testCase.code, setup);
-	}
-
-	#itValidCase<OptionsSchema extends AnyOptionalSchema | undefined>(
-		rule: AnyRule<RuleAbout, OptionsSchema>,
-		testCaseRaw: ValidTestCase<InferredObject<OptionsSchema>>,
-	) {
-		const testCase =
-			typeof testCaseRaw === "string" ? { code: testCaseRaw } : testCaseRaw;
-		const testCaseNormalized = normalizeTestCase(testCase);
-
-		this.#itTestCase(testCaseNormalized, async () => {
-			const reports = await runTestCaseRule(
-				this.#fileFactories,
-				{
-					// TODO: Figure out a way around the type assertion...
-					options: (testCase.options ?? {}) as InferredObject<OptionsSchema>,
-					rule,
-				},
-				testCaseNormalized,
-			);
-
-			if (reports.length) {
-				assert.deepStrictEqual(
-					createReportSnapshot(testCaseNormalized.code, reports),
-					testCaseNormalized.code,
-				);
-			}
-		});
-	}
-}
-
-function defaultTo<TesterSetup extends TesterSetupDescribe | TesterSetupIt>(
-	provided: TesterSetup | undefined,
-	scope: Record<string, unknown>,
-	scopeKey: string,
-): TesterSetup {
-	if (provided) {
-		return provided;
-	}
-
-	if (scopeKey in scope && typeof scope[scopeKey] === "function") {
-		return scope[scopeKey] as TesterSetup;
-	}
-
-	throw new Error(`No ${scopeKey} function found`);
-}

package/src/createReportSnapshot.ts

@@ -1,50 +0,0 @@
-import { formatReportPrimary, NormalizedReport } from "@flint.fyi/core";
-
-export function createReportSnapshot(
-	sourceText: string,
-	reports: NormalizedReport[],
-) {
-	let result = sourceText;
-
-	for (const report of reports.toReversed()) {
-		result = createReportSnapshotAt(result, report);
-	}
-
-	return result;
-}
-
-function createReportSnapshotAt(sourceText: string, report: NormalizedReport) {
-	const { begin, end } = report.range;
-	const lineStartIndex = sourceText.lastIndexOf("\n", begin.raw) + 1;
-	let lineEndIndex = sourceText.indexOf("\n", end.raw);
-	if (lineEndIndex < 0) {
-		lineEndIndex = sourceText.length;
-	}
-	const lines = sourceText.slice(lineStartIndex, lineEndIndex).split("\n");
-	const output: string[] = [];
-
-	for (let i = begin.line; i <= end.line; i++) {
-		const line = lines[i - begin.line];
-		output.push(line);
-
-		const prevLineIndent = /^[\t ]*/.exec(line)?.[0] ?? "";
-
-		if (i === begin.line) {
-			const indent = prevLineIndent.padEnd(begin.column, " ");
-			const squiggleEnd = begin.line === end.line ? end.column : line.length;
-			output.push(indent.padEnd(squiggleEnd, "~"));
-			for (const errorMessageLine of formatReportPrimary(report).split("\n")) {
-				output.push(indent + errorMessageLine);
-			}
-		} else {
-			const squiggleEnd = i === end.line ? end.column : line.length;
-			output.push(prevLineIndent.padEnd(squiggleEnd, "~"));
-		}
-	}
-
-	return (
-		sourceText.slice(0, lineStartIndex) +
-		output.join("\n") +
-		sourceText.slice(lineEndIndex)
-	);
-}

package/src/index.ts

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

package/src/normalizeTestCase.ts

@@ -1,14 +0,0 @@
-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

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