fix(tests): fix test isolation for cache-dependent tests

- Mock getOmoOpenCodeCacheDir to use temp directories

- Clear real cache files in beforeEach to prevent pollution

- Add top-level beforeEach/afterEach in model-availability.test.ts

- Use mock.module for proper test isolation

- Fixes model-error-classifier, model-availability, connected-providers-cache

src/shared/connected-providers-cache.test.ts

@@ -1,27 +1,47 @@
-import { describe, test, expect, beforeEach, afterEach, spyOn } from "bun:test"
+/// <reference types="bun-types" />
-import { existsSync, mkdirSync, rmSync } from "fs"
-import { join } from "path"
-import * as dataPath from "./data-path"
-import { updateConnectedProvidersCache, readProviderModelsCache } from "./connected-providers-cache"
 
-const TEST_CACHE_DIR = join(import.meta.dir, "__test-cache__")
+import { beforeAll, beforeEach, afterEach, describe, expect, mock, test } from "bun:test"
+
+import { existsSync, mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import * as dataPath from "./data-path"
+
+let testCacheDir = ""
+let moduleImportCounter = 0
+
+const getOmoOpenCodeCacheDirMock = mock(() => testCacheDir)
+
+let updateConnectedProvidersCache: typeof import("./connected-providers-cache").updateConnectedProvidersCache
+let readProviderModelsCache: typeof import("./connected-providers-cache").readProviderModelsCache
 
 describe("updateConnectedProvidersCache", () => {
-	let cacheDirSpy: ReturnType<typeof spyOn>
+	beforeAll(() => {
+		mock.restore()
+	})
 
-	beforeEach(() => {
+	beforeEach(async () => {
-		cacheDirSpy = spyOn(dataPath, "getOmoOpenCodeCacheDir").mockReturnValue(TEST_CACHE_DIR)
+		mock.restore()
-		if (existsSync(TEST_CACHE_DIR)) {
+		const realCacheDir = join(dataPath.getCacheDir(), "oh-my-opencode")
-			rmSync(TEST_CACHE_DIR, { recursive: true })
+		if (existsSync(realCacheDir)) {
+			rmSync(realCacheDir, { recursive: true, force: true })
 		}
-		mkdirSync(TEST_CACHE_DIR, { recursive: true })
+
+		testCacheDir = mkdtempSync(join(tmpdir(), "connected-providers-cache-test-"))
+		getOmoOpenCodeCacheDirMock.mockClear()
+		mock.module("./data-path", () => ({
+			getOmoOpenCodeCacheDir: getOmoOpenCodeCacheDirMock,
+		}))
+		moduleImportCounter += 1
+		;({ updateConnectedProvidersCache, readProviderModelsCache } = await import(`./connected-providers-cache?test=${moduleImportCounter}`))
 	})
 
 	afterEach(() => {
-		cacheDirSpy.mockRestore()
+		mock.restore()
-		if (existsSync(TEST_CACHE_DIR)) {
+		if (existsSync(testCacheDir)) {
-			rmSync(TEST_CACHE_DIR, { recursive: true })
+			rmSync(testCacheDir, { recursive: true, force: true })
 		}
+		testCacheDir = ""
 	})
 
 	test("extracts models from provider.list().all response", async () => {

src/shared/model-availability.test.ts

@@ -1,8 +1,9 @@
 declare const require: (name: string) => any
-const { describe, it, expect, beforeEach, afterEach, beforeAll } = require("bun:test")
+const { describe, it, expect, beforeEach, afterEach, beforeAll, spyOn } = require("bun:test")
-import { mkdtempSync, writeFileSync, rmSync } from "fs"
+import { mkdtempSync, writeFileSync, rmSync, existsSync, readFileSync } from "fs"
 import { tmpdir } from "os"
 import { join } from "path"
+import * as connectedProvidersCache from "./connected-providers-cache"
 
 let __resetModelCache: () => void
 let fetchAvailableModels: (client?: unknown, options?: { connectedProviders?: string[] | null }) => Promise<Set<string>>
@@ -33,25 +34,27 @@ beforeAll(async () => {
 })
 
 describe("fetchAvailableModels", () => {
-  let tempDir: string
+	let tempDir: string
 	let originalXdgCache: string | undefined
+	let providerModelsCacheSpy: { mockRestore(): void } | undefined
 
-
+	beforeEach(() => {
-  beforeEach(() => {
+		__resetModelCache()
-    __resetModelCache()
+		tempDir = mkdtempSync(join(tmpdir(), "opencode-test-"))
-    tempDir = mkdtempSync(join(tmpdir(), "opencode-test-"))
 		originalXdgCache = process.env.XDG_CACHE_HOME
 		process.env.XDG_CACHE_HOME = tempDir
-  })
+		providerModelsCacheSpy = spyOn(connectedProvidersCache, "readProviderModelsCache").mockReturnValue(null)
+	})
 
-  afterEach(() => {
+	afterEach(() => {
-    if (originalXdgCache !== undefined) {
+		providerModelsCacheSpy?.mockRestore()
+		if (originalXdgCache !== undefined) {
 			process.env.XDG_CACHE_HOME = originalXdgCache
 		} else {
 			delete process.env.XDG_CACHE_HOME
 		}
-    rmSync(tempDir, { recursive: true, force: true })
+		rmSync(tempDir, { recursive: true, force: true })
-  })
+	})
 
   function writeModelsCache(data: Record<string, any>) {
     const cacheDir = join(tempDir, "opencode")
@@ -485,15 +488,18 @@ describe("getConnectedProviders", () => {
 describe("fetchAvailableModels with connected providers filtering", () => {
 	let tempDir: string
 	let originalXdgCache: string | undefined
+	let providerModelsCacheSpy: { mockRestore(): void } | undefined
 
 	beforeEach(() => {
 		__resetModelCache()
 		tempDir = mkdtempSync(join(tmpdir(), "opencode-test-"))
 		originalXdgCache = process.env.XDG_CACHE_HOME
 		process.env.XDG_CACHE_HOME = tempDir
+		providerModelsCacheSpy = spyOn(connectedProvidersCache, "readProviderModelsCache").mockReturnValue(null)
 	})
 
 	afterEach(() => {
+		providerModelsCacheSpy?.mockRestore()
 		if (originalXdgCache !== undefined) {
 			process.env.XDG_CACHE_HOME = originalXdgCache
 		} else {
@@ -652,15 +658,24 @@ describe("fetchAvailableModels with connected providers filtering", () => {
 describe("fetchAvailableModels with provider-models cache (whitelist-filtered)", () => {
 	let tempDir: string
 	let originalXdgCache: string | undefined
+	let providerModelsCacheSpy: { mockRestore(): void } | undefined
 
 	beforeEach(() => {
 		__resetModelCache()
 		tempDir = mkdtempSync(join(tmpdir(), "opencode-test-"))
 		originalXdgCache = process.env.XDG_CACHE_HOME
 		process.env.XDG_CACHE_HOME = tempDir
+		providerModelsCacheSpy = spyOn(connectedProvidersCache, "readProviderModelsCache").mockImplementation(() => {
+			const cacheFile = join(tempDir, "oh-my-opencode", "provider-models.json")
+			if (!existsSync(cacheFile)) {
+				return null
+			}
+			return JSON.parse(readFileSync(cacheFile, "utf-8"))
+		})
 	})
 
 	afterEach(() => {
+		providerModelsCacheSpy?.mockRestore()
 		if (originalXdgCache !== undefined) {
 			process.env.XDG_CACHE_HOME = originalXdgCache
 		} else {
@@ -878,21 +893,23 @@ describe("isModelAvailable", () => {
 
 describe("fallback model availability", () => {
 	let tempDir: string
-	let originalXdgCache: string | undefined
+	let connectedProvidersCacheSpy: { mockRestore(): void } | undefined
 
 	beforeEach(() => {
 		// given
 		tempDir = mkdtempSync(join(tmpdir(), "opencode-test-"))
-		originalXdgCache = process.env.XDG_CACHE_HOME
+		connectedProvidersCacheSpy = spyOn(connectedProvidersCache, "readConnectedProvidersCache").mockImplementation(() => {
-		process.env.XDG_CACHE_HOME = tempDir
+			const cacheFile = join(tempDir, "oh-my-opencode", "connected-providers.json")
+			if (!existsSync(cacheFile)) {
+				return null
+			}
+			const cache = JSON.parse(readFileSync(cacheFile, "utf-8")) as { connected?: string[] }
+			return Array.isArray(cache.connected) ? cache.connected : null
+		})
 	})
 
 	afterEach(() => {
-		if (originalXdgCache !== undefined) {
+		connectedProvidersCacheSpy?.mockRestore()
-			process.env.XDG_CACHE_HOME = originalXdgCache
-		} else {
-			delete process.env.XDG_CACHE_HOME
-		}
 		rmSync(tempDir, { recursive: true, force: true })
 	})
 

src/shared/model-error-classifier.test.ts

@@ -1,28 +1,18 @@
-import { describe, expect, test, beforeEach, afterEach, spyOn } from "bun:test"
+declare const require: (name: string) => any
+const { describe, expect, test, beforeEach, mock } = require("bun:test")
+
+const readConnectedProvidersCacheMock = mock(() => null)
+
+mock.module("./connected-providers-cache", () => ({
+  readConnectedProvidersCache: readConnectedProvidersCacheMock,
+}))
 
-import { mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs"
-import { join } from "node:path"
-import * as dataPath from "./data-path"
 import { shouldRetryError, selectFallbackProvider } from "./model-error-classifier"
 
-const TEST_CACHE_DIR = join(import.meta.dir, "__test-cache__")
-
 describe("model-error-classifier", () => {
-  let cacheDirSpy: ReturnType<typeof spyOn>
-
   beforeEach(() => {
-    cacheDirSpy = spyOn(dataPath, "getOmoOpenCodeCacheDir").mockReturnValue(TEST_CACHE_DIR)
+    readConnectedProvidersCacheMock.mockReturnValue(null)
-    if (existsSync(TEST_CACHE_DIR)) {
+    readConnectedProvidersCacheMock.mockClear()
-      rmSync(TEST_CACHE_DIR, { recursive: true })
-    }
-    mkdirSync(TEST_CACHE_DIR, { recursive: true })
-  })
-
-  afterEach(() => {
-    cacheDirSpy.mockRestore()
-    if (existsSync(TEST_CACHE_DIR)) {
-      rmSync(TEST_CACHE_DIR, { recursive: true })
-    }
   })
 
   test("treats overloaded retry messages as retryable", () => {
@@ -52,10 +42,7 @@ describe("model-error-classifier", () => {
 
   test("selectFallbackProvider prefers first connected provider in preference order", () => {
     //#given
-    writeFileSync(
+    readConnectedProvidersCacheMock.mockReturnValue(["anthropic", "nvidia"])
-      join(TEST_CACHE_DIR, "connected-providers.json"),
-      JSON.stringify({ connected: ["anthropic", "nvidia"], updatedAt: new Date().toISOString() }, null, 2),
-    )
 
     //#when
     const provider = selectFallbackProvider(["anthropic", "nvidia"], "nvidia")
@@ -66,10 +53,7 @@ describe("model-error-classifier", () => {
 
   test("selectFallbackProvider falls back to next connected provider when first is disconnected", () => {
     //#given
-    writeFileSync(
+    readConnectedProvidersCacheMock.mockReturnValue(["nvidia"])
-      join(TEST_CACHE_DIR, "connected-providers.json"),
-      JSON.stringify({ connected: ["nvidia"], updatedAt: new Date().toISOString() }, null, 2),
-    )
 
     //#when
     const provider = selectFallbackProvider(["anthropic", "nvidia"])
@@ -90,10 +74,7 @@ describe("model-error-classifier", () => {
 
   test("selectFallbackProvider uses connected preferred provider when fallback providers are unavailable", () => {
     //#given
-    writeFileSync(
+    readConnectedProvidersCacheMock.mockReturnValue(["provider-x"])
-      join(TEST_CACHE_DIR, "connected-providers.json"),
-      JSON.stringify({ connected: ["provider-x"], updatedAt: new Date().toISOString() }, null, 2),
-    )
 
     //#when
     const provider = selectFallbackProvider(["provider-y"], "provider-x")