@shivaedev/quality 0.7.2 → 0.8.0

package/src/rules/suppressions/biome-overrides.ts

@@ -1,8 +1,8 @@
 import { Effect, Schema } from "effect";
-import { defineRule, type Finding } from "../../rule.ts";
-import { biomeConfigs, type Chain } from "./biome/configs.ts";
-import { Declaration, matches, type Scoped, scoped, scopeText } from "./biome/declarations.ts";
-import { type Weakening, weakeningsOf } from "./biome/weakenings.ts";
+import { defineRule, type Finding } from "#rule.ts";
+import { biomeConfigs, type Chain } from "#rules/suppressions/biome/configs.ts";
+import { Declaration, matches, type Scoped, scoped, scopeText } from "#rules/suppressions/biome/declarations.ts";
+import { type Weakening, weakeningsOf } from "#rules/suppressions/biome/weakenings.ts";
 
 const BiomeOverridesOptions = Schema.Struct({
 	declared: Schema.Array(Declaration).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),

package/src/rules/suppressions/directives.ts

@@ -1,4 +1,4 @@
-import type { SourceComment } from "../comments/scan.ts";
+import type { SourceComment } from "#rules/comments/scan.ts";
 
 export const SUPPRESSIONS: readonly RegExp[] = [
 	/^biome-ignore(?:-all|-start)?(?![\w-])/u,

package/src/rules/suppressions/no-double-cast.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
-import { defineRule, type Finding, type SourceFile } from "../../rule.ts";
-import { parse } from "../syntax.ts";
+import { defineRule, type Finding, type SourceFile } from "#rule.ts";
+import { parse } from "#rules/syntax.ts";
 
 const BRIDGES: ReadonlyMap<ts.SyntaxKind, string> = new Map([
 	[ts.SyntaxKind.UnknownKeyword, "unknown"],

package/src/rules/suppressions/no-inline.ts

@@ -1,5 +1,5 @@
-import { defineRule, type Finding, type RuleInputs } from "../../rule.ts";
-import { type SourceComment, scanComments } from "../comments/scan.ts";
+import { defineRule, type Finding, type RuleInputs } from "#rule.ts";
+import { type SourceComment, scanComments } from "#rules/comments/scan.ts";
 import { suppressionIn } from "./directives.ts";
 import { STYLESHEET, stylesheetComments } from "./stylesheet-comments.ts";
 

package/src/rules/suppressions/stylesheet-comments.ts

@@ -1,4 +1,4 @@
-import { bodyOf, type SourceComment } from "../comments/scan.ts";
+import { bodyOf, type SourceComment } from "#rules/comments/scan.ts";
 
 export const STYLESHEET = /\.(?:css|scss|less)$/u;
 

package/src/rules/syntax.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import type { SourceFile } from "../rule.ts";
+import type { SourceFile } from "#rule.ts";
 
 const SCRIPT_KINDS: ReadonlyArray<readonly [RegExp, ts.ScriptKind]> = [
 	[/\.[cm]?ts$/u, ts.ScriptKind.TS],

package/src/rules/test-names/colocated.ts

@@ -0,0 +1,34 @@
+import { Effect, Schema } from "effect";
+import ignore from "ignore";
+import { testName } from "#naming/testName.ts";
+import { defineRule, type Finding } from "#rule.ts";
+
+const MIRROR_FOLDERS: ReadonlySet<string> = new Set(["__tests__", "spec", "test", "tests"]);
+
+const TestsColocatedOptions = Schema.Struct({
+	suites: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
+
+function findingOf(path: string): readonly Finding[] {
+	const name = testName(path);
+	const mirror = name?.folder.split("/").find((folder) => MIRROR_FOLDERS.has(folder));
+	if (name === undefined || mirror === undefined) {
+		return [];
+	}
+	return [
+		{
+			file: path,
+			message: `Sits in the test folder "${mirror}/". A test sits beside the file it covers, as ${name.stem}.test${name.extension} beside ${name.stem}.ts, or as a <behaviour>.spec${name.extension} in the folder it covers. A folder of tests that cover several packages is a suite in the "suites" option.`,
+		},
+	];
+}
+
+export const testsColocated = defineRule({
+	check: ({ files, options }) => {
+		const suites = ignore().add([...options.suites]);
+		return files.filter((path) => !suites.ignores(path)).flatMap(findingOf);
+	},
+	description: "A test sits beside the code it covers, not in a test, tests, __tests__ or spec folder, unless that folder is a declared suite.",
+	id: "tests/colocated",
+	options: Schema.toStandardSchemaV1(TestsColocatedOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+});

package/src/rules/test-names/follow.ts

@@ -0,0 +1,78 @@
+import { posix } from "node:path";
+import { Effect, Schema } from "effect";
+import ignore from "ignore";
+import { ENVIRONMENTS, type TestName, testName } from "#naming/testName.ts";
+import { CAMEL } from "#naming/words.ts";
+import { defineRule, type Finding, type SourceFile } from "#rule.ts";
+import { usesDom } from "#rules/test-names/usesDom.ts";
+
+const ENVIRONMENT_NAMES: ReadonlySet<string> = new Set(ENVIRONMENTS);
+
+const FIXTURE_SUFFIXES: ReadonlySet<string> = new Set(["integration", "postgres"]);
+
+const CODE = /\.[cm]?[jt]sx?$/u;
+
+const GRAMMAR =
+	"A test file is <file>[.<environment>].test.ts beside its file or <behaviour>[.<environment>].spec.ts in the folder it covers, with at most one environment of dom, slow and typecheck.";
+
+const TestsFollowOptions = Schema.Struct({
+	suites: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
+
+function siblingsIn(files: readonly string[]): ReadonlySet<string> {
+	return new Set(files.filter((file) => CODE.test(file) && testName(file) === undefined).map((file) => file.replace(CODE, "")));
+}
+
+function suffixMessage(file: string, name: TestName): string | undefined {
+	const [first, ...rest] = name.modifiers;
+	if (first === undefined || (rest.length === 0 && ENVIRONMENT_NAMES.has(first))) {
+		return undefined;
+	}
+	const fixture = name.modifiers.find((modifier) => FIXTURE_SUFFIXES.has(modifier));
+	if (fixture !== undefined) {
+		return `".${fixture}" is not a test environment. A test that needs a database or a running app takes it from the app's test fixture and is named like any other test. ${GRAMMAR}`;
+	}
+	return `"${file}" has the suffixes ".${name.modifiers.join(".")}". ${GRAMMAR} An aspect of a module gets its own file in the module's folder, or a .spec.`;
+}
+
+function placeMessage(file: string, name: TestName, siblings: ReadonlySet<string>): string | undefined {
+	const covered = siblings.has(`${name.folder}/${name.stem}`);
+	if (name.kind === "test") {
+		return covered
+			? undefined
+			: `"${file}" follows no file: ${name.stem}.test${name.extension} sits beside ${name.stem}.ts in the same folder. A test that covers the folder as a whole is a <behaviour>.spec${name.extension}, such as checkoutFlow.spec${name.extension}.`;
+	}
+	if (covered) {
+		return `"${file}" shares its name with ${name.stem}.ts. A .spec names a behaviour of its folder, such as checkoutFlow.spec${name.extension}; a test of ${name.stem}.ts is ${name.stem}.test${name.extension}.`;
+	}
+	return CAMEL.test(name.stem) ? undefined : `"${file}" names its behaviour in camelCase, such as checkoutFlow.spec${name.extension}.`;
+}
+
+function environmentMessage(file: string, name: TestName, source: SourceFile): string | undefined {
+	if (name.modifiers.includes("dom") || name.modifiers.includes("typecheck") || !usesDom(source)) {
+		return undefined;
+	}
+	return `"${file}" uses the DOM, so it is ${name.stem}.dom.${name.kind}${name.extension} and runs in the dom project.`;
+}
+
+function findingsOf(source: SourceFile, siblings: ReadonlySet<string>): readonly Finding[] {
+	const name = testName(source.path);
+	if (name === undefined) {
+		return [];
+	}
+	const file = posix.basename(source.path);
+	const messages = [suffixMessage(file, name), placeMessage(file, name, siblings), environmentMessage(file, name, source)];
+	return messages.flatMap((message) => (message === undefined ? [] : [{ file: source.path, message }]));
+}
+
+export const testsFollow = defineRule({
+	check: ({ files, options, sources }) => {
+		const suites = ignore().add([...options.suites]);
+		const siblings = siblingsIn(files);
+		return sources.filter((source) => !suites.ignores(source.path)).flatMap((source) => findingsOf(source, siblings));
+	},
+	description:
+		"A .test file follows the file beside it, a .spec names a behaviour of its folder, the only suffix is one environment of dom, slow and typecheck, and a test that uses the DOM is a .dom test.",
+	id: "tests/follow",
+	options: Schema.toStandardSchemaV1(TestsFollowOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+});

package/src/rules/test-names/usesDom.ts

@@ -0,0 +1,22 @@
+import ts from "typescript";
+import type { SourceFile } from "#rule.ts";
+import { parse } from "#rules/syntax.ts";
+
+const DOM_GLOBALS: ReadonlySet<string> = new Set(["document", "window"]);
+
+const TESTING_LIBRARY = "@testing-library/";
+
+function touchesDom(node: ts.Node): boolean {
+	if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+		return node.moduleSpecifier.text.startsWith(TESTING_LIBRARY);
+	}
+	if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && DOM_GLOBALS.has(node.expression.text)) {
+		return true;
+	}
+	return ts.forEachChild(node, touchesDom) ?? false;
+}
+
+export function usesDom(file: SourceFile): boolean {
+	const source = parse(file);
+	return source === undefined ? false : touchesDom(source);
+}

package/src/vitest.ts

@@ -1,22 +1,25 @@
 import { defaultExclude, type TestUserConfig } from "vitest/config";
+import type { Environment } from "#naming/testName.ts";
 
-const TEST = "**/*.test.?(c|m)[jt]s?(x)";
-const DOM = "**/*.dom.test.?(c|m)[jt]s?(x)";
-const SLOW = "**/*.slow.test.?(c|m)[jt]s?(x)";
-const TYPECHECK = "**/*.typecheck.test.?(c|m)[jt]s?(x)";
-const TYPECHECK_ALONE = "**/typecheck.test.?(c|m)[jt]s?(x)";
+const EXTENSION = "?(c|m)[jt]s?(x)";
 
-function excluding(...patterns: readonly string[]): string[] {
-	return [...defaultExclude, TYPECHECK, TYPECHECK_ALONE, ...patterns];
+const TYPECHECK_ALONE = `**/typecheck.test.${EXTENSION}`;
+
+function named(environment?: Environment): string {
+	return environment === undefined ? `**/*.@(test|spec).${EXTENSION}` : `**/*.${environment}.@(test|spec).${EXTENSION}`;
+}
+
+function excluding(exclude: readonly string[], ...patterns: readonly string[]): string[] {
+	return [...defaultExclude, named("typecheck"), TYPECHECK_ALONE, ...exclude, ...patterns];
 }
 
-export function testProjects(): TestUserConfig {
+export function testProjects({ exclude = [] }: { readonly exclude?: readonly string[] } = {}): TestUserConfig {
 	return {
 		project: ["unit", "dom"],
 		projects: [
-			{ extends: true, test: { environment: "node", exclude: excluding(DOM, SLOW), include: [TEST], name: "unit" } },
-			{ extends: true, test: { environment: "happy-dom", exclude: excluding(SLOW), include: [DOM], name: "dom" } },
-			{ extends: true, test: { environment: "node", exclude: excluding(), include: [SLOW], name: "slow" } },
+			{ extends: true, test: { environment: "node", exclude: excluding(exclude, named("dom"), named("slow")), include: [named()], name: "unit" } },
+			{ extends: true, test: { environment: "happy-dom", exclude: excluding(exclude, named("slow")), include: [named("dom")], name: "dom" } },
+			{ extends: true, test: { environment: "node", exclude: excluding(exclude), include: [named("slow")], name: "slow" } },
 		],
 	};
 }