fix(test): migrate config-handler tests from mock.module to spyOn to prevent cross-file cache pollution

src/plugin-handlers/config-handler.test.ts

@@ -1,56 +1,56 @@
-import { describe, test, expect, mock, beforeEach } from "bun:test"
+import { describe, test, expect, spyOn, beforeEach, afterEach } from "bun:test"
 import { resolveCategoryConfig, createConfigHandler } from "./config-handler"
 import type { CategoryConfig } from "../config/schema"
 import type { OhMyOpenCodeConfig } from "../config"
 
-mock.module("../agents", () => ({
+import * as agents from "../agents"
-  createBuiltinAgents: async () => ({
+import * as sisyphusJunior from "../agents/sisyphus-junior"
+import * as commandLoader from "../features/claude-code-command-loader"
+import * as builtinCommands from "../features/builtin-commands"
+import * as skillLoader from "../features/opencode-skill-loader"
+import * as agentLoader from "../features/claude-code-agent-loader"
+import * as mcpLoader from "../features/claude-code-mcp-loader"
+import * as pluginLoader from "../features/claude-code-plugin-loader"
+import * as mcpModule from "../mcp"
+import * as shared from "../shared"
+import * as configDir from "../shared/opencode-config-dir"
+import * as permissionCompat from "../shared/permission-compat"
+import * as modelResolver from "../shared/model-resolver"
+
+beforeEach(() => {
+  spyOn(agents, "createBuiltinAgents" as any).mockResolvedValue({
     sisyphus: { name: "sisyphus", prompt: "test", mode: "primary" },
     oracle: { name: "oracle", prompt: "test", mode: "subagent" },
-  }),
+  })
-}))
 
-mock.module("../agents/sisyphus-junior", () => ({
+  spyOn(sisyphusJunior, "createSisyphusJuniorAgentWithOverrides" as any).mockReturnValue({
-  createSisyphusJuniorAgentWithOverrides: () => ({
     name: "sisyphus-junior",
     prompt: "test",
     mode: "subagent",
-  }),
+  })
-}))
 
-mock.module("../features/claude-code-command-loader", () => ({
+  spyOn(commandLoader, "loadUserCommands" as any).mockResolvedValue({})
-  loadUserCommands: async () => ({}),
+  spyOn(commandLoader, "loadProjectCommands" as any).mockResolvedValue({})
-  loadProjectCommands: async () => ({}),
+  spyOn(commandLoader, "loadOpencodeGlobalCommands" as any).mockResolvedValue({})
-  loadOpencodeGlobalCommands: async () => ({}),
+  spyOn(commandLoader, "loadOpencodeProjectCommands" as any).mockResolvedValue({})
-  loadOpencodeProjectCommands: async () => ({}),
-}))
 
-mock.module("../features/builtin-commands", () => ({
+  spyOn(builtinCommands, "loadBuiltinCommands" as any).mockReturnValue({})
-  loadBuiltinCommands: () => ({}),
-}))
 
-mock.module("../features/opencode-skill-loader", () => ({
+  spyOn(skillLoader, "loadUserSkills" as any).mockResolvedValue({})
-  loadUserSkills: async () => ({}),
+  spyOn(skillLoader, "loadProjectSkills" as any).mockResolvedValue({})
-  loadProjectSkills: async () => ({}),
+  spyOn(skillLoader, "loadOpencodeGlobalSkills" as any).mockResolvedValue({})
-  loadOpencodeGlobalSkills: async () => ({}),
+  spyOn(skillLoader, "loadOpencodeProjectSkills" as any).mockResolvedValue({})
-  loadOpencodeProjectSkills: async () => ({}),
+  spyOn(skillLoader, "discoverUserClaudeSkills" as any).mockResolvedValue([])
-  discoverUserClaudeSkills: async () => [],
+  spyOn(skillLoader, "discoverProjectClaudeSkills" as any).mockResolvedValue([])
-  discoverProjectClaudeSkills: async () => [],
+  spyOn(skillLoader, "discoverOpencodeGlobalSkills" as any).mockResolvedValue([])
-  discoverOpencodeGlobalSkills: async () => [],
+  spyOn(skillLoader, "discoverOpencodeProjectSkills" as any).mockResolvedValue([])
-  discoverOpencodeProjectSkills: async () => [],
-}))
 
-mock.module("../features/claude-code-agent-loader", () => ({
+  spyOn(agentLoader, "loadUserAgents" as any).mockReturnValue({})
-  loadUserAgents: () => ({}),
+  spyOn(agentLoader, "loadProjectAgents" as any).mockReturnValue({})
-  loadProjectAgents: () => ({}),
-}))
 
-mock.module("../features/claude-code-mcp-loader", () => ({
+  spyOn(mcpLoader, "loadMcpConfigs" as any).mockResolvedValue({ servers: {} })
-  loadMcpConfigs: async () => ({ servers: {} }),
-}))
 
-mock.module("../features/claude-code-plugin-loader", () => ({
+  spyOn(pluginLoader, "loadAllPluginComponents" as any).mockResolvedValue({
-  loadAllPluginComponents: async () => ({
     commands: {},
     skills: {},
     agents: {},
@@ -58,60 +58,52 @@ mock.module("../features/claude-code-plugin-loader", () => ({
     hooksConfigs: [],
     plugins: [],
     errors: [],
-  }),
+  })
-}))
 
-mock.module("../mcp", () => ({
+  spyOn(mcpModule, "createBuiltinMcps" as any).mockReturnValue({})
-  createBuiltinMcps: () => ({}),
-}))
 
-mock.module("../shared", () => ({
+  spyOn(shared, "log" as any).mockImplementation(() => {})
-  log: () => {},
+  spyOn(shared, "fetchAvailableModels" as any).mockResolvedValue(new Set(["anthropic/claude-opus-4-5"]))
-  fetchAvailableModels: async () => new Set(["anthropic/claude-opus-4-5"]),
+  spyOn(shared, "readConnectedProvidersCache" as any).mockReturnValue(null)
-  readConnectedProvidersCache: () => null,
-}))
 
-mock.module("../shared/opencode-config-dir", () => ({
+  spyOn(configDir, "getOpenCodeConfigPaths" as any).mockReturnValue({
-  getOpenCodeConfigPaths: () => ({
     global: "/tmp/.config/opencode",
     project: "/tmp/.opencode",
-  }),
+  })
-}))
 
-mock.module("../shared/permission-compat", () => ({
+  spyOn(permissionCompat, "migrateAgentConfig" as any).mockImplementation((config: Record<string, unknown>) => config)
-  migrateAgentConfig: (config: Record<string, unknown>) => config,
-}))
 
-mock.module("../shared/migration", () => ({
+  spyOn(modelResolver, "resolveModelWithFallback" as any).mockReturnValue({ model: "anthropic/claude-opus-4-5" })
-  AGENT_NAME_MAP: {},
+})
-}))
 
-mock.module("../shared/model-resolver", () => ({
+afterEach(() => {
-  resolveModelWithFallback: () => ({ model: "anthropic/claude-opus-4-5" }),
+  (agents.createBuiltinAgents as any)?.mockRestore?.()
-}))
+  ;(sisyphusJunior.createSisyphusJuniorAgentWithOverrides as any)?.mockRestore?.()
-
+  ;(commandLoader.loadUserCommands as any)?.mockRestore?.()
-mock.module("../shared/model-requirements", () => ({
+  ;(commandLoader.loadProjectCommands as any)?.mockRestore?.()
-  AGENT_MODEL_REQUIREMENTS: {
+  ;(commandLoader.loadOpencodeGlobalCommands as any)?.mockRestore?.()
-    sisyphus: { fallbackChain: [{ providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5" }] },
+  ;(commandLoader.loadOpencodeProjectCommands as any)?.mockRestore?.()
-    oracle: { fallbackChain: [{ providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }] },
+  ;(builtinCommands.loadBuiltinCommands as any)?.mockRestore?.()
-    librarian: { fallbackChain: [{ providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" }] },
+  ;(skillLoader.loadUserSkills as any)?.mockRestore?.()
-    explore: { fallbackChain: [{ providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" }] },
+  ;(skillLoader.loadProjectSkills as any)?.mockRestore?.()
-    "multimodal-looker": { fallbackChain: [{ providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" }] },
+  ;(skillLoader.loadOpencodeGlobalSkills as any)?.mockRestore?.()
-    prometheus: { fallbackChain: [{ providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5" }] },
+  ;(skillLoader.loadOpencodeProjectSkills as any)?.mockRestore?.()
-    metis: { fallbackChain: [{ providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5" }] },
+  ;(skillLoader.discoverUserClaudeSkills as any)?.mockRestore?.()
-    momus: { fallbackChain: [{ providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }] },
+  ;(skillLoader.discoverProjectClaudeSkills as any)?.mockRestore?.()
-    atlas: { fallbackChain: [{ providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" }] },
+  ;(skillLoader.discoverOpencodeGlobalSkills as any)?.mockRestore?.()
-  },
+  ;(skillLoader.discoverOpencodeProjectSkills as any)?.mockRestore?.()
-  CATEGORY_MODEL_REQUIREMENTS: {
+  ;(agentLoader.loadUserAgents as any)?.mockRestore?.()
-    "visual-engineering": { fallbackChain: [{ providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }] },
+  ;(agentLoader.loadProjectAgents as any)?.mockRestore?.()
-    ultrabrain: { fallbackChain: [{ providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex" }] },
+  ;(mcpLoader.loadMcpConfigs as any)?.mockRestore?.()
-    artistry: { fallbackChain: [{ providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }] },
+  ;(pluginLoader.loadAllPluginComponents as any)?.mockRestore?.()
-    quick: { fallbackChain: [{ providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" }] },
+  ;(mcpModule.createBuiltinMcps as any)?.mockRestore?.()
-    "unspecified-low": { fallbackChain: [{ providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" }] },
+  ;(shared.log as any)?.mockRestore?.()
-    "unspecified-high": { fallbackChain: [{ providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5" }] },
+  ;(shared.fetchAvailableModels as any)?.mockRestore?.()
-    writing: { fallbackChain: [{ providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" }] },
+  ;(shared.readConnectedProvidersCache as any)?.mockRestore?.()
-  },
+  ;(configDir.getOpenCodeConfigPaths as any)?.mockRestore?.()
-}))
+  ;(permissionCompat.migrateAgentConfig as any)?.mockRestore?.()
+  ;(modelResolver.resolveModelWithFallback as any)?.mockRestore?.()
+})
 
 describe("Plan agent demote behavior", () => {
   test("plan agent should be demoted to subagent mode when replacePlan is true", async () => {