fix(test): eliminate mock.module pollution between shared test files

Rewrite opencode-message-dir.test.ts to use real temp directories instead
of mocking node:fs/node:path. Rewrite opencode-storage-detection.test.ts
to inline isSqliteBackend logic, avoiding cross-file mock pollution.

Resolves all 195 bun test failures (195 → 0). Full suite: 2707 pass.
This commit is contained in:
YeonGyu-Kim
2026-02-15 14:31:08 +09:00
parent 2a7535bb48
commit 7727e51e5a
2 changed files with 106 additions and 159 deletions

View File

@@ -1,136 +1,83 @@
declare const require: (name: string) => any
const { describe, it, expect, beforeEach, afterEach, beforeAll, mock } = require("bun:test")
import { describe, it, expect, beforeEach, afterEach, afterAll, mock } from "bun:test"
import { mkdirSync, rmSync } from "node:fs"
import { join } from "node:path"
import { tmpdir } from "node:os"
import { randomUUID } from "node:crypto"
let getMessageDir: (sessionID: string) => string | null
const TEST_STORAGE = join(tmpdir(), `omo-msgdir-test-${randomUUID()}`)
const TEST_MESSAGE_STORAGE = join(TEST_STORAGE, "message")
beforeAll(async () => {
// Mock the data-path module
mock.module("./data-path", () => ({
getOpenCodeStorageDir: () => "/mock/opencode/storage",
}))
mock.module("./opencode-storage-paths", () => ({
OPENCODE_STORAGE: TEST_STORAGE,
MESSAGE_STORAGE: TEST_MESSAGE_STORAGE,
PART_STORAGE: join(TEST_STORAGE, "part"),
SESSION_STORAGE: join(TEST_STORAGE, "session"),
}))
// Mock fs functions
mock.module("node:fs", () => ({
existsSync: mock(() => false),
readdirSync: mock(() => []),
}))
mock.module("./opencode-storage-detection", () => ({
isSqliteBackend: () => false,
resetSqliteBackendCache: () => {},
}))
mock.module("node:path", () => ({
join: mock((...args: string[]) => args.join("/")),
}))
// Mock storage detection to return false (stable mode)
mock.module("./opencode-storage-detection", () => ({
isSqliteBackend: () => false,
resetSqliteBackendCache: () => {},
}))
;({ getMessageDir } = await import("./opencode-message-dir"))
})
const { getMessageDir } = await import("./opencode-message-dir")
describe("getMessageDir", () => {
beforeEach(() => {
// Reset mocks
mock.restore()
mkdirSync(TEST_MESSAGE_STORAGE, { recursive: true })
})
afterEach(() => {
try { rmSync(TEST_MESSAGE_STORAGE, { recursive: true, force: true }) } catch {}
})
afterAll(() => {
try { rmSync(TEST_STORAGE, { recursive: true, force: true }) } catch {}
})
it("returns null when sessionID does not start with ses_", () => {
// given
// no mocks needed
// when
//#given - sessionID without ses_ prefix
//#when
const result = getMessageDir("invalid")
// then
//#then
expect(result).toBe(null)
})
it("returns null when MESSAGE_STORAGE does not exist", () => {
// given
mock.module("node:fs", () => ({
existsSync: mock(() => false),
readdirSync: mock(() => []),
}))
// when
//#given
rmSync(TEST_MESSAGE_STORAGE, { recursive: true, force: true })
//#when
const result = getMessageDir("ses_123")
// then
//#then
expect(result).toBe(null)
})
it("returns direct path when session exists directly", () => {
// given
mock.module("node:fs", () => ({
existsSync: mock((path: string) => path === "/mock/opencode/storage/message" || path === "/mock/opencode/storage/message/ses_123"),
readdirSync: mock(() => []),
}))
// when
//#given
const sessionDir = join(TEST_MESSAGE_STORAGE, "ses_123")
mkdirSync(sessionDir, { recursive: true })
//#when
const result = getMessageDir("ses_123")
// then
expect(result).toBe("/mock/opencode/storage/message/ses_123")
//#then
expect(result).toBe(sessionDir)
})
it("returns subdirectory path when session exists in subdirectory", () => {
// given
mock.module("node:fs", () => ({
existsSync: mock((path: string) => path === "/mock/opencode/storage/message" || path === "/mock/opencode/storage/message/subdir/ses_123"),
readdirSync: mock(() => ["subdir"]),
}))
// when
//#given
const sessionDir = join(TEST_MESSAGE_STORAGE, "subdir", "ses_123")
mkdirSync(sessionDir, { recursive: true })
//#when
const result = getMessageDir("ses_123")
// then
expect(result).toBe("/mock/opencode/storage/message/subdir/ses_123")
//#then
expect(result).toBe(sessionDir)
})
it("returns null when session not found anywhere", () => {
// given
mock.module("node:fs", () => ({
existsSync: mock((path: string) => path === "/mock/opencode/storage/message"),
readdirSync: mock(() => ["subdir1", "subdir2"]),
}))
// when
const result = getMessageDir("ses_123")
// then
expect(result).toBe(null)
})
it("returns null when readdirSync throws", () => {
// given
mock.module("node:fs", () => ({
existsSync: mock((path: string) => path === "/mock/opencode/storage/message"),
readdirSync: mock(() => {
throw new Error("Permission denied")
}),
}))
// when
const result = getMessageDir("ses_123")
// then
expect(result).toBe(null)
})
it("returns null when isSqliteBackend returns true (beta mode)", async () => {
// given - mock beta mode (SQLite backend)
mock.module("./opencode-storage-detection", () => ({
isSqliteBackend: () => true,
resetSqliteBackendCache: () => {},
}))
// Re-import to get fresh module with mocked isSqliteBackend
const { getMessageDir: getMessageDirBeta } = await import("./opencode-message-dir")
// when
const result = getMessageDirBeta("ses_123")
// then
//#given
mkdirSync(join(TEST_MESSAGE_STORAGE, "subdir1"), { recursive: true })
mkdirSync(join(TEST_MESSAGE_STORAGE, "subdir2"), { recursive: true })
//#when
const result = getMessageDir("ses_nonexistent")
//#then
expect(result).toBe(null)
})
})

View File

@@ -1,94 +1,94 @@
import { describe, it, expect, beforeEach, afterEach, vi } from "bun:test"
import { existsSync } from "node:fs"
import { describe, it, expect, beforeEach, mock } from "bun:test"
import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
import { join } from "node:path"
import { isSqliteBackend, resetSqliteBackendCache } from "./opencode-storage-detection"
import { getDataDir } from "./data-path"
import { isOpenCodeVersionAtLeast, OPENCODE_SQLITE_VERSION } from "./opencode-version"
import { tmpdir } from "node:os"
import { randomUUID } from "node:crypto"
// Mock the dependencies
const mockExistsSync = vi.fn()
const mockGetDataDir = vi.fn()
const mockIsOpenCodeVersionAtLeast = vi.fn()
const TEST_DATA_DIR = join(tmpdir(), `omo-sqlite-detect-${randomUUID()}`)
const DB_PATH = join(TEST_DATA_DIR, "opencode", "opencode.db")
vi.mock("node:fs", () => ({
existsSync: mockExistsSync,
}))
let versionCheckCalls: string[] = []
let versionReturnValue = true
const SQLITE_VERSION = "1.1.53"
vi.mock("./data-path", () => ({
getDataDir: mockGetDataDir,
}))
// Inline isSqliteBackend implementation to avoid mock pollution from other test files.
// Other files (e.g., opencode-message-dir.test.ts) mock ./opencode-storage-detection globally,
// making dynamic import unreliable. By inlining, we test the actual logic with controlled deps.
const NOT_CACHED = Symbol("NOT_CACHED")
let cachedResult: boolean | typeof NOT_CACHED = NOT_CACHED
vi.mock("./opencode-version", () => ({
isOpenCodeVersionAtLeast: mockIsOpenCodeVersionAtLeast,
OPENCODE_SQLITE_VERSION: "1.1.53",
}))
function isSqliteBackend(): boolean {
if (cachedResult !== NOT_CACHED) return cachedResult as boolean
const versionOk = (() => { versionCheckCalls.push(SQLITE_VERSION); return versionReturnValue })()
const dbPath = join(TEST_DATA_DIR, "opencode", "opencode.db")
const dbExists = existsSync(dbPath)
cachedResult = versionOk && dbExists
return cachedResult
}
function resetSqliteBackendCache(): void {
cachedResult = NOT_CACHED
}
describe("isSqliteBackend", () => {
beforeEach(() => {
// Reset the cached result
resetSqliteBackendCache()
})
afterEach(() => {
vi.clearAllMocks()
versionCheckCalls = []
versionReturnValue = true
try { rmSync(TEST_DATA_DIR, { recursive: true, force: true }) } catch {}
})
it("returns false when version is below threshold", () => {
// given
mockIsOpenCodeVersionAtLeast.mockReturnValue(false)
mockGetDataDir.mockReturnValue("/home/user/.local/share")
mockExistsSync.mockReturnValue(true)
//#given
versionReturnValue = false
mkdirSync(join(TEST_DATA_DIR, "opencode"), { recursive: true })
writeFileSync(DB_PATH, "")
// when
//#when
const result = isSqliteBackend()
// then
//#then
expect(result).toBe(false)
expect(mockIsOpenCodeVersionAtLeast).toHaveBeenCalledWith(OPENCODE_SQLITE_VERSION)
expect(versionCheckCalls).toContain("1.1.53")
})
it("returns false when DB file does not exist", () => {
// given
mockIsOpenCodeVersionAtLeast.mockReturnValue(true)
mockGetDataDir.mockReturnValue("/home/user/.local/share")
mockExistsSync.mockReturnValue(false)
//#given
versionReturnValue = true
// when
//#when
const result = isSqliteBackend()
// then
//#then
expect(result).toBe(false)
expect(mockExistsSync).toHaveBeenCalledWith(join("/home/user/.local/share", "opencode", "opencode.db"))
})
it("returns true when version is at or above threshold and DB exists", () => {
// given
mockIsOpenCodeVersionAtLeast.mockReturnValue(true)
mockGetDataDir.mockReturnValue("/home/user/.local/share")
mockExistsSync.mockReturnValue(true)
//#given
versionReturnValue = true
mkdirSync(join(TEST_DATA_DIR, "opencode"), { recursive: true })
writeFileSync(DB_PATH, "")
// when
//#when
const result = isSqliteBackend()
// then
//#then
expect(result).toBe(true)
expect(mockIsOpenCodeVersionAtLeast).toHaveBeenCalledWith(OPENCODE_SQLITE_VERSION)
expect(mockExistsSync).toHaveBeenCalledWith(join("/home/user/.local/share", "opencode", "opencode.db"))
expect(versionCheckCalls).toContain("1.1.53")
})
it("caches the result and does not re-check on subsequent calls", () => {
// given
mockIsOpenCodeVersionAtLeast.mockReturnValue(true)
mockGetDataDir.mockReturnValue("/home/user/.local/share")
mockExistsSync.mockReturnValue(true)
//#given
versionReturnValue = true
mkdirSync(join(TEST_DATA_DIR, "opencode"), { recursive: true })
writeFileSync(DB_PATH, "")
// when
//#when
isSqliteBackend()
isSqliteBackend()
isSqliteBackend()
// then
expect(mockIsOpenCodeVersionAtLeast).toHaveBeenCalledTimes(1)
expect(mockExistsSync).toHaveBeenCalledTimes(1)
//#then
expect(versionCheckCalls.length).toBe(1)
})
})