Ref: setup property and its maker (#16)

* Minor: mv before to setup.

* Also makeSetup().

src/rule.spec.ts

@@ -7,103 +7,100 @@ mock.module("node:fs", () => ({
   readFileSync: readerMock,
 }));
 
-const mockEnv = (env: object) =>
+const makeSetup = (env: object) => () =>
   readerMock.mockReturnValueOnce(JSON.stringify(env));
 
 new Runner("dependencies", rule, {
   // Valid
   "regular import of prod dependency": {
     code: `import {} from "eslint"`,
-    before: () => mockEnv({ dependencies: { eslint: "" } }),
+    setup: makeSetup({ dependencies: { eslint: "" } }),
   },
   "regular import of explicitly enabled prod dependencies": {
     code: `import {} from "eslint"`,
     options: [{ production: true }],
-    before: () => mockEnv({ dependencies: { eslint: "" } }),
+    setup: makeSetup({ dependencies: { eslint: "" } }),
   },
   "regular import of required peer dependency": {
     code: `import {} from "eslint"`,
-    before: () => mockEnv({ peerDependencies: { eslint: "" } }),
+    setup: makeSetup({ peerDependencies: { eslint: "" } }),
   },
   "type import of optional peer dependency": {
     code: `import type {} from "eslint"`,
-    before: () =>
-      mockEnv({
-        peerDependencies: { eslint: "" },
-        peerDependenciesMeta: { eslint: { optional: true } },
-      }),
+    setup: makeSetup({
+      peerDependencies: { eslint: "" },
+      peerDependenciesMeta: { eslint: { optional: true } },
+    }),
   },
   "type import of unlisted type only dependency": {
     code: `import type {} from "eslint"`,
     options: [{ typeOnly: ["eslint"] }],
-    before: () => mockEnv({ dependencies: {} }),
+    setup: makeSetup({ dependencies: {} }),
   },
   "type import of prod dependency": {
     code: `import type {} from "eslint"`,
-    before: () => mockEnv({ dependencies: { eslint: "" } }),
+    setup: makeSetup({ dependencies: { eslint: "" } }),
   },
   "import a path of prod dependency": {
     code: `import {} from "eslint/something/useful.js"`,
-    before: () => mockEnv({ dependencies: { eslint: "" } }),
+    setup: makeSetup({ dependencies: { eslint: "" } }),
   },
   "import of scoped required peer dependency": {
     code: `import {} from "@eslint/js/something"`,
-    before: () => mockEnv({ peerDependencies: { "@eslint/js": "" } }),
+    setup: makeSetup({ peerDependencies: { "@eslint/js": "" } }),
   },
   "import of local path": {
     code: `import {} from "./some/path.js"`,
-    before: () => mockEnv({}),
+    setup: makeSetup({}),
   },
   "import of built-in module": {
     code: `import { readFileSync } from "node:fs"`,
-    before: () => mockEnv({}),
+    setup: makeSetup({}),
   },
   "import of something explicitly ignored by regex": {
     code: `import {} from "fancy-module"`,
     options: [{ ignore: ["^fancy-\\w+$"] }],
-    before: () => mockEnv({}),
+    setup: makeSetup({}),
   },
   // Invalid
   "regular import of unlisted dependency": {
     code: `import {} from "eslint"`,
-    before: () => mockEnv({ dependencies: {} }),
+    setup: makeSetup({ dependencies: {} }),
     errors: [{ messageId: "prohibited" }],
   },
   "regular import of explicitly disabled prod dependency": {
     code: `import {} from "eslint"`,
     options: [{ production: false }],
-    before: () => mockEnv({ dependencies: { eslint: "" } }),
+    setup: makeSetup({ dependencies: { eslint: "" } }),
     errors: [{ messageId: "prohibited" }],
   },
   "regular import of optional peer dependency": {
     code: `import {} from "eslint"`,
-    before: () =>
-      mockEnv({
-        peerDependencies: { eslint: "" },
-        peerDependenciesMeta: { eslint: { optional: true } },
-      }),
+    setup: makeSetup({
+      peerDependencies: { eslint: "" },
+      peerDependenciesMeta: { eslint: { optional: true } },
+    }),
     errors: [{ messageId: "typeOnly" }],
   },
   "regular import of unlisted type only dependency": {
     code: `import {} from "eslint"`,
     options: [{ typeOnly: ["eslint"] }],
-    before: () => mockEnv({}),
+    setup: makeSetup({}),
     errors: [{ messageId: "typeOnly" }],
   },
   "import of built-in module when missing in ignore list": {
     code: `import {} from "node:fs"`,
     options: [{ ignore: ["^fancy-\\w+$"] }],
-    before: () => mockEnv({}),
+    setup: makeSetup({}),
     errors: [{ messageId: "prohibited" }],
   },
   demo: {
     code: `import {factory} from "typescript"; import {format} from "prettier";`,
-    before: () =>
-      mockEnv({
-        devDependencies: { typescript: "^5" },
-        peerDependencies: { prettier: "^3" },
-        peerDependenciesMeta: { prettier: { optional: true } },
-      }),
+    setup: makeSetup({
+      devDependencies: { typescript: "^5" },
+      peerDependencies: { prettier: "^3" },
+      peerDependenciesMeta: { prettier: { optional: true } },
+    }),
     errors: [{ messageId: "prohibited" }, { messageId: "typeOnly" }],
   },
 }).run();

test-runner/helpers.ts

@@ -5,7 +5,7 @@ const caseFromScenario = <
   Options extends readonly unknown[],
   MessageId extends string,
 >(
-  { before, ...rest }: Scenario<Options, MessageId>,
+  { setup, ...rest }: Scenario<Options, MessageId>,
   name: string,
 ): SomeCase<Options, MessageId> => ({ name, ...rest });
 

test-runner/index.ts

@@ -18,8 +18,8 @@ export class Runner<
     RuleTester.afterAll = afterAll;
     RuleTester.describe = describe;
     RuleTester.it = (...[name, ...rest]: Parameters<typeof it>) => {
-      const { before } = scenarios[name];
-      before?.();
+      const { setup } = scenarios[name];
+      setup?.();
       it(name, ...rest);
     };
   }

test-runner/types.ts

@@ -11,4 +11,4 @@ export type SomeCase<
 export type Scenario<
   Options extends readonly unknown[],
   MessageId extends string,
-> = SomeCase<Options, MessageId> & { before?: () => void };
+> = SomeCase<Options, MessageId> & { setup?: () => void };