test: automatically test if outputs are valid inputs

Author: merceyz

tests/rules/rule-tester.ts

@@ -1,9 +1,33 @@
-import { RuleTester } from "@typescript-eslint/rule-tester";
+import { RuleTester, RunTests } from "@typescript-eslint/rule-tester";
+import { RuleModule } from "@typescript-eslint/utils/ts-eslint";
 import * as vitest from "vitest";
 
 RuleTester.afterAll = vitest.afterAll;
 RuleTester.it = vitest.it;
 RuleTester.itOnly = vitest.it.only;
 RuleTester.describe = vitest.describe;
 
-export const ruleTester = new RuleTester();
+/**
+ * RuleTester extended to check if the output of invalid cases are valid inputs
+ */
+class InternalRuleTester extends RuleTester {
+	override run<MessageIds extends string, Options extends readonly unknown[]>(
+		ruleName: string,
+		rule: RuleModule<MessageIds, Options>,
+		test: RunTests<MessageIds, Options>,
+	): void {
+		super.run(ruleName, rule, {
+			...test,
+			valid: [
+				...test.valid,
+				...new Set(
+					test.invalid
+						.flatMap((test) => test.output)
+						.filter((output) => output != undefined),
+				),
+			],
+		});
+	}
+}
+
+export const ruleTester = new InternalRuleTester();

tests/rules/typed-input.test.ts

@@ -14,23 +14,6 @@ ruleTester.run("typed-input", typedInputRule, {
 		'db.prepare("SELECT * FROM 42")',
 		// Identifier is allowed as a name
 		'db.prepare<{id: unknown}>("SELECT * FROM users WHERE id = $id")',
-		// Test that no errors are reported for the outputs from the invalid cases
-		'db.prepare<[]>("SELECT * FROM users")',
-		'db.prepare<[unknown]>("SELECT * FROM users WHERE id = ?")',
-		'db.prepare<[unknown, unknown]>("SELECT * FROM users WHERE id = ? and name = ?")',
-		'db.prepare<{"id": unknown}>("SELECT * FROM users WHERE id = $id")',
-		'db.prepare<{"id": unknown, "name": unknown}>("SELECT * FROM users WHERE id = $id and name = @name")',
-		'db.prepare<[unknown, {"id": unknown}]>("SELECT * FROM users WHERE id = $id and name = ?")',
-		'db.prepare<{"id": unknown, "name": unknown}>("SELECT * FROM users WHERE id = :id and name = :name")',
-		'db.prepare<[unknown, {"id": unknown, "name": unknown}]>("SELECT * FROM users WHERE id = :id or id = ? and name = :name")',
-		'db.prepare<[unknown, {"id": unknown}]>("SELECT * FROM users WHERE id = :id or id = ?")',
-		'db.prepare<{"userID": unknown}>("SELECT * FROM users WHERE id = :userID")',
-		'db.prepare<[unknown, {"userID": unknown}]>("SELECT * FROM users WHERE id = :userID or name = ?")',
-		'db.prepare<[unknown, {"userID": string}]>("SELECT * FROM users WHERE id = :userID or name = ?")',
-		'db.prepare<{"userID": string}>("SELECT * FROM users WHERE id = :userID")',
-		'db.prepare<[unknown]>(`SELECT * FROM users WHERE id IN (${foo.map(() => "?").join(",")})`)',
-		'this.prepare<[unknown]>("SELECT * FROM users WHERE id = ?")',
-		'super.prepare<[unknown]>("SELECT * FROM users WHERE id = ?")',
 	],
 	invalid: [
 		// No parameters

tests/rules/typed-result.test.ts

@@ -31,16 +31,10 @@ ruleTester.run("typed-result", rule, {
 		"db.prepare(undefined)",
 		"db.prepare(1n)",
 		"db.prepare(foo)",
-		// Valid query
-		`db.prepare<[], {"id": number, "name": string}>("SELECT * FROM users")`,
 		// Order of columns doesn't matter
 		`db.prepare<[], {"name": string, "id": number}>("SELECT * FROM users")`,
 		// Identifier as column names
 		`db.prepare<[], {name: string, id: number}>("SELECT * FROM users")`,
-		// Column with unknown type
-		`db.prepare<[], {"random()": unknown}>("SELECT random();")`,
-		// Column with Buffer type
-		`db.prepare<[], {"data": Buffer}>("SELECT data FROM blobData")`,
 		// Should ignore invalid queries
 		`db.prepare("SELECT * FROM 42")`,
 		// Should pass the correct name to getDatabase
@@ -51,18 +45,6 @@ ruleTester.run("typed-result", rule, {
 		"db.prepare<[]>('DELETE FROM foo')",
 		// Should allow the user to set another type for unknown
 		`db.prepare<[], {"random()": (number | null)}>("SELECT random();")`,
-		// Test that no errors are reported for the outputs from the invalid cases
-		`db.prepare<[], {"id": number}>("SELECT id FROM users")`,
-		'db.prepare<[], {"id": number}>(`SELECT id FROM users`)',
-		`const query = 'SELECT id FROM users';db.prepare<[], {"id": number}>(query);`,
-		`db.prepare<[], {"id": number | null}>("SELECT * FROM foo")`,
-		`db.prepare<[], {"id": number | string | Buffer}>("SELECT id FROM test")`,
-		`db.prepare<[], {"name": number | string | Buffer | null}>("SELECT name FROM test")`,
-		`db.prepare<[]>("DELETE FROM foo")`,
-		`db.prepare<[], {"random()": (foo | number), "id": number}>("SELECT random(), id FROM users")`,
-		'db.prepare<[], {"name": string}>(`SELECT name FROM users WHERE id IN (${foo.map(() => "?").join(",")})`)',
-		'this.prepare<[], {"name": string}>(`SELECT name FROM users`)',
-		'super.prepare<[], {"name": string}>(`SELECT name FROM users`)',
 	],
 	invalid: [
 		// Query as string Literal

tests/rules/valid-query.test.ts

@@ -32,8 +32,6 @@ ruleTester.run("valid-query", rule, {
 		"db_users.prepare(`SELECT * FROM users WHERE ${ids.map(() => 'NAME LIKE ? || \\'%\\'').join(' OR ')}`);",
 		"const query = `SELECT * FROM users WHERE ${ids.map(() => 'NAME LIKE ? || \\'%\\'').join(' OR ')}`;db_users.prepare(query);",
 		"db_users.prepare(`SELECT * FROM users WHERE id IN (${ids.map(() => '?').join()})`);",
-		'this.prepare("SELECT * FROM foo")',
-		'super.prepare("SELECT * FROM foo")',
 	],
 	invalid: [
 		{