oxlint-plugin-effect 0.0.0

package/tests/ban-rules.test.ts

@@ -0,0 +1,252 @@
+import { describe, test, expect } from "bun:test"
+import { Testing } from "../src/vendor/effect-oxlint/index.js"
+import {
+  noEffectDo,
+  noEffectNever,
+  noEffectAs,
+  noEffectAsync,
+  noEffectBind,
+  noOptionAs,
+  noRuntimeRunFork,
+  noRunInEffect,
+  noGlobalFetch,
+  noGlobalConsole,
+  noGlobalDate,
+  noGlobalRandom,
+  noGlobalTimers,
+  noNewPromise,
+  noNewError,
+  noProcessEnv,
+  noNodeBuiltinImport,
+  noDynamicImport,
+  noThrowStatement,
+  noTryCatch,
+  noJsonParse,
+} from "../src/rules/index.js"
+
+// --- API ban rules ---
+
+describe("noEffectDo", () => {
+  test("reports Effect.Do", () => {
+    const result = Testing.runRule(noEffectDo, "MemberExpression", Testing.memberExpr("Effect", "Do"))
+    Testing.expectDiagnostics(result, [{ message: "Avoid Effect.Do builder notation. Use flat pipe-based flow or Effect.gen." }])
+  })
+
+  test("ignores Effect.map", () => {
+    const result = Testing.runRule(noEffectDo, "MemberExpression", Testing.memberExpr("Effect", "map"))
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noEffectNever", () => {
+  test("reports Effect.never", () => {
+    const result = Testing.runRule(noEffectNever, "MemberExpression", Testing.memberExpr("Effect", "never"))
+    Testing.expectDiagnostics(result, [{ message: "Avoid Effect.never. Use Stream or explicit acquire/release lifecycles." }])
+  })
+})
+
+describe("noEffectAs", () => {
+  test("reports Effect.as", () => {
+    const result = Testing.runRule(noEffectAs, "MemberExpression", Testing.memberExpr("Effect", "as"))
+    Testing.expectDiagnostics(result, [{ message: "Avoid Effect.as. Use Effect.map for value mapping or Effect.asVoid." }])
+  })
+})
+
+describe("noEffectAsync", () => {
+  test("reports Effect.async", () => {
+    const result = Testing.runRule(noEffectAsync, "MemberExpression", Testing.memberExpr("Effect", "async"))
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noEffectBind", () => {
+  test("reports Effect.bind", () => {
+    const result = Testing.runRule(noEffectBind, "MemberExpression", Testing.memberExpr("Effect", "bind"))
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noOptionAs", () => {
+  test("reports Option.as", () => {
+    const result = Testing.runRule(noOptionAs, "MemberExpression", Testing.memberExpr("Option", "as"))
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noRuntimeRunFork", () => {
+  test("reports Runtime.runFork", () => {
+    const result = Testing.runRule(noRuntimeRunFork, "MemberExpression", Testing.memberExpr("Runtime", "runFork"))
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noRunInEffect", () => {
+  test("reports Effect.runSync", () => {
+    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "runSync"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports Effect.runPromise", () => {
+    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "runPromise"))
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores Effect.gen", () => {
+    const result = Testing.runRule(noRunInEffect, "MemberExpression", Testing.memberExpr("Effect", "gen"))
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+// --- Global ban rules ---
+
+describe("noGlobalFetch", () => {
+  test("reports fetch()", () => {
+    const result = Testing.runRule(noGlobalFetch, "CallExpression", Testing.callExpr("fetch"))
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores other calls", () => {
+    const result = Testing.runRule(noGlobalFetch, "CallExpression", Testing.callExpr("getData"))
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noGlobalConsole", () => {
+  test("reports console.log", () => {
+    const result = Testing.runRule(noGlobalConsole, "MemberExpression", Testing.memberExpr("console", "log"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports console.error", () => {
+    const result = Testing.runRule(noGlobalConsole, "MemberExpression", Testing.memberExpr("console", "error"))
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores logger.log", () => {
+    const result = Testing.runRule(noGlobalConsole, "MemberExpression", Testing.memberExpr("logger", "log"))
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noGlobalDate", () => {
+  test("reports Date.now", () => {
+    const result = Testing.runRule(noGlobalDate, "MemberExpression", Testing.memberExpr("Date", "now"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports new Date()", () => {
+    const result = Testing.runRule(noGlobalDate, "NewExpression", Testing.newExpr("Date"))
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noGlobalRandom", () => {
+  test("reports Math.random", () => {
+    const result = Testing.runRule(noGlobalRandom, "MemberExpression", Testing.memberExpr("Math", "random"))
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noGlobalTimers", () => {
+  test("reports setTimeout", () => {
+    const result = Testing.runRule(noGlobalTimers, "CallExpression", Testing.callExpr("setTimeout"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports setInterval", () => {
+    const result = Testing.runRule(noGlobalTimers, "CallExpression", Testing.callExpr("setInterval"))
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noNewPromise", () => {
+  test("reports new Promise()", () => {
+    const result = Testing.runRule(noNewPromise, "NewExpression", Testing.newExpr("Promise"))
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noNewError", () => {
+  test("reports new Error()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("Error"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports new TypeError()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("TypeError"))
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores new MyError()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("MyError"))
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noProcessEnv", () => {
+  test("reports process.env", () => {
+    const result = Testing.runRule(noProcessEnv, "MemberExpression", Testing.memberExpr("process", "env"))
+    expect(result.length).toBe(1)
+  })
+})
+
+// --- Import ban rules ---
+
+describe("noNodeBuiltinImport", () => {
+  test("reports import from 'fs'", () => {
+    const result = Testing.runRule(noNodeBuiltinImport, "ImportDeclaration", Testing.importDecl("fs"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports import from 'node:fs'", () => {
+    const result = Testing.runRule(noNodeBuiltinImport, "ImportDeclaration", Testing.importDecl("node:fs"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports import from 'child_process'", () => {
+    const result = Testing.runRule(noNodeBuiltinImport, "ImportDeclaration", Testing.importDecl("child_process"))
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores import from 'effect'", () => {
+    const result = Testing.runRule(noNodeBuiltinImport, "ImportDeclaration", Testing.importDecl("effect"))
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+// --- Statement ban rules ---
+
+describe("noThrowStatement", () => {
+  test("reports throw", () => {
+    const result = Testing.runRule(noThrowStatement, "ThrowStatement", Testing.throwStmt())
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noTryCatch", () => {
+  test("reports try/catch", () => {
+    const result = Testing.runRule(noTryCatch, "TryStatement", Testing.tryStmt())
+    expect(result.length).toBe(1)
+  })
+})
+
+describe("noDynamicImport", () => {
+  test("reports dynamic import()", () => {
+    const result = Testing.runRule(noDynamicImport, "ImportExpression", { type: "ImportExpression" } as never)
+    expect(result.length).toBe(1)
+  })
+})
+
+// --- JSON ---
+
+describe("noJsonParse", () => {
+  test("reports JSON.parse", () => {
+    const result = Testing.runRule(noJsonParse, "MemberExpression", Testing.memberExpr("JSON", "parse"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports JSON.stringify", () => {
+    const result = Testing.runRule(noJsonParse, "MemberExpression", Testing.memberExpr("JSON", "stringify"))
+    expect(result.length).toBe(1)
+  })
+})

package/tests/context-rules.test.ts

@@ -0,0 +1,281 @@
+import { describe, test, expect } from "bun:test"
+import { Testing } from "../src/vendor/effect-oxlint/index.js"
+import {
+  noPlatformGlobals,
+  noThrowInEffectGen,
+  noTryCatchInEffectGen,
+  noConsoleInEffect,
+  noFetchInEffect,
+  noDateInEffect,
+  noRandomInEffect,
+  noTimersInEffect,
+  noJsonInEffect,
+  noProcessEnvInEffect,
+} from "../src/rules/index.js"
+
+// Helper: simulate entering and exiting Effect.gen context
+const effectGenNode = Testing.callOfMember("Effect", "gen", [])
+
+/**
+ * For context-aware rules, we need to:
+ * 1. Enter Effect.gen (CallExpression event)
+ * 2. Fire the target event (ThrowStatement, MemberExpression, etc.)
+ * 3. Exit Effect.gen (CallExpression:exit event)
+ *
+ * Using runRuleMulti to simulate the sequence.
+ */
+
+describe("noThrowInEffectGen", () => {
+  test("reports throw inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noThrowInEffectGen, [
+      ["CallExpression", effectGenNode],
+      ["ThrowStatement", Testing.throwStmt()],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores throw outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noThrowInEffectGen, [
+      ["ThrowStatement", Testing.throwStmt()],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noTryCatchInEffectGen", () => {
+  test("reports try/catch inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noTryCatchInEffectGen, [
+      ["CallExpression", effectGenNode],
+      ["TryStatement", Testing.tryStmt()],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores try/catch outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noTryCatchInEffectGen, [
+      ["TryStatement", Testing.tryStmt()],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noConsoleInEffect", () => {
+  test("reports console.log inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noConsoleInEffect, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("console", "log")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores console.log outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noConsoleInEffect, [
+      ["MemberExpression", Testing.memberExpr("console", "log")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noFetchInEffect", () => {
+  test("reports fetch() inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noFetchInEffect, [
+      ["CallExpression", effectGenNode],
+      ["CallExpression", Testing.callExpr("fetch")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores fetch() outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noFetchInEffect, [
+      ["CallExpression", Testing.callExpr("fetch")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noDateInEffect", () => {
+  test("reports Date.now inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noDateInEffect, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("Date", "now")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("reports new Date() inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noDateInEffect, [
+      ["CallExpression", effectGenNode],
+      ["NewExpression", Testing.newExpr("Date")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores Date.now outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noDateInEffect, [
+      ["MemberExpression", Testing.memberExpr("Date", "now")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noRandomInEffect", () => {
+  test("reports Math.random inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRandomInEffect, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("Math", "random")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores Math.random outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRandomInEffect, [
+      ["MemberExpression", Testing.memberExpr("Math", "random")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noTimersInEffect", () => {
+  test("reports setTimeout inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noTimersInEffect, [
+      ["CallExpression", effectGenNode],
+      ["CallExpression", Testing.callExpr("setTimeout")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores setTimeout outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noTimersInEffect, [
+      ["CallExpression", Testing.callExpr("setTimeout")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noJsonInEffect", () => {
+  test("reports JSON.parse inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noJsonInEffect, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("JSON", "parse")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores JSON.parse outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noJsonInEffect, [
+      ["MemberExpression", Testing.memberExpr("JSON", "parse")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noProcessEnvInEffect", () => {
+  test("reports process.env inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noProcessEnvInEffect, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("process", "env")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores process.env outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noProcessEnvInEffect, [
+      ["MemberExpression", Testing.memberExpr("process", "env")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})
+
+describe("noPlatformGlobals", () => {
+  test("reports Bun.file with FileSystem hint", () => {
+    const result = Testing.runRuleMulti(noPlatformGlobals, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("Bun", "file")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectDiagnostics(result, [{
+      message: "Avoid Bun.file inside Effect context. Use FileSystem from 'effect'.",
+    }])
+  })
+
+  test("reports Bun.serve with HttpServer hint", () => {
+    const result = Testing.runRuleMulti(noPlatformGlobals, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("Bun", "serve")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectDiagnostics(result, [{
+      message: "Avoid Bun.serve inside Effect context. Use HttpServer from 'effect/unstable/http'.",
+    }])
+  })
+
+  test("reports process.exit with Effect.fail hint", () => {
+    const result = Testing.runRuleMulti(noPlatformGlobals, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("process", "exit")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectDiagnostics(result, [{
+      message: "Avoid process.exit inside Effect context. Use Effect.fail or Effect.die.",
+    }])
+  })
+
+  test("reports process.cwd with Path hint", () => {
+    const result = Testing.runRuleMulti(noPlatformGlobals, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("process", "cwd")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectDiagnostics(result, [{
+      message: "Avoid process.cwd inside Effect context. Use Path from 'effect'.",
+    }])
+  })
+
+  test("reports Deno.readFile with FileSystem hint", () => {
+    const result = Testing.runRuleMulti(noPlatformGlobals, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("Deno", "readFile")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectDiagnostics(result, [{
+      message: "Avoid Deno.readFile inside Effect context. Use FileSystem from 'effect'.",
+    }])
+  })
+
+  test("reports unknown property with generic hint", () => {
+    const result = Testing.runRuleMulti(noPlatformGlobals, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("Bun", "someNewApi")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectDiagnostics(result, [{
+      message: "Avoid Bun.someNewApi inside Effect context. Wrap in a service for testability.",
+    }])
+  })
+
+  test("ignores Bun.file outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noPlatformGlobals, [
+      ["MemberExpression", Testing.memberExpr("Bun", "file")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+
+  test("ignores non-platform globals inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noPlatformGlobals, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("Effect", "succeed")],
+      ["CallExpression:exit", effectGenNode],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+})