Revert unit tests back to bun:test (only integration tests use Jest)

Author: ammar-agent

src/browser/api.test.ts

@@ -3,7 +3,7 @@
  * Tests the invokeIPC function to ensure it behaves consistently with Electron's ipcRenderer.invoke()
  */
 
-import { describe, test, expect } from "@jest/globals";
+import { describe, test, expect } from "bun:test";
 
 // Helper to create a mock fetch that returns a specific response
 function createMockFetch(responseData: unknown) {

src/hooks/useReviewState.test.ts

@@ -6,7 +6,7 @@
  * The hook itself is a thin wrapper around usePersistedState with manual testing.
  */
 
-import { describe, it, expect } from "@jest/globals";
+import { describe, it, expect } from "bun:test";
 import type { HunkReadState } from "@/types/review";
 import { evictOldestReviews } from "./useReviewState";
 

src/runtime/initHook.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "@jest/globals";
+import { describe, it, expect } from "bun:test";
 import { LineBuffer, createLineBufferedLoggers } from "./initHook";
 import type { InitLogger } from "./Runtime";
 

src/services/aiService.test.ts

@@ -2,7 +2,7 @@
 // These tests would need to be rewritten to work with Bun's test runner
 // For now, the commandProcessor tests demonstrate our testing approach
 
-import { describe, it, expect, beforeEach } from "@jest/globals";
+import { describe, it, expect, beforeEach } from "bun:test";
 import { AIService } from "./aiService";
 import { HistoryService } from "./historyService";
 import { PartialService } from "./partialService";

src/services/historyService.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { HistoryService } from "./historyService";
 import { Config } from "@/config";
 import { createCmuxMessage } from "@/types/message";

src/services/initStateManager.test.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
-import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { Config } from "@/config";
 import { InitStateManager } from "./initStateManager";
 import type { WorkspaceInitEvent } from "@/types/ipc";

src/services/partialService.test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/unbound-method */
-import { describe, test, expect, beforeEach, jest } from "@jest/globals";
+import { describe, test, expect, beforeEach, mock } from "bun:test";
 import { PartialService } from "./partialService";
 import type { HistoryService } from "./historyService";
 import type { Config } from "@/config";
@@ -9,18 +9,18 @@ import { Ok } from "@/types/result";
 // Mock Config
 const createMockConfig = (): Config => {
   return {
-    getSessionDir: jest.fn((workspaceId: string) => `/tmp/test-sessions/${workspaceId}`),
+    getSessionDir: mock((workspaceId: string) => `/tmp/test-sessions/${workspaceId}`),
   } as unknown as Config;
 };
 
 // Mock HistoryService
 const createMockHistoryService = (): HistoryService => {
   return {
-    appendToHistory: jest.fn(() => Promise.resolve(Ok(undefined))),
-    getHistory: jest.fn(() => Promise.resolve(Ok([]))),
-    updateHistory: jest.fn(() => Promise.resolve(Ok(undefined))),
-    truncateAfterMessage: jest.fn(() => Promise.resolve(Ok(undefined))),
-    clearHistory: jest.fn(() => Promise.resolve(Ok(undefined))),
+    appendToHistory: mock(() => Promise.resolve(Ok(undefined))),
+    getHistory: mock(() => Promise.resolve(Ok([]))),
+    updateHistory: mock(() => Promise.resolve(Ok(undefined))),
+    truncateAfterMessage: mock(() => Promise.resolve(Ok(undefined))),
+    clearHistory: mock(() => Promise.resolve(Ok(undefined))),
   } as unknown as HistoryService;
 };
 
@@ -55,13 +55,13 @@ describe("PartialService - Error Recovery", () => {
     };
 
     // Mock readPartial to return errored partial
-    partialService.readPartial = jest.fn(() => Promise.resolve(erroredPartial));
+    partialService.readPartial = mock(() => Promise.resolve(erroredPartial));
 
     // Mock deletePartial
-    partialService.deletePartial = jest.fn(() => Promise.resolve(Ok(undefined)));
+    partialService.deletePartial = mock(() => Promise.resolve(Ok(undefined)));
 
     // Mock getHistory to return no existing messages
-    mockHistoryService.getHistory = jest.fn(() => Promise.resolve(Ok([])));
+    mockHistoryService.getHistory = mock(() => Promise.resolve(Ok([])));
 
     // Call commitToHistory
     const result = await partialService.commitToHistory(workspaceId);
@@ -70,7 +70,7 @@ describe("PartialService - Error Recovery", () => {
     expect(result.success).toBe(true);
 
     // Should have called appendToHistory with cleaned metadata (no error/errorType)
-    const appendToHistory = mockHistoryService.appendToHistory as ReturnType<typeof jest.fn>;
+    const appendToHistory = mockHistoryService.appendToHistory as ReturnType<typeof mock>;
     expect(appendToHistory).toHaveBeenCalledTimes(1);
     const appendedMessage = appendToHistory.mock.calls[0][1] as CmuxMessage;
 
@@ -81,7 +81,7 @@ describe("PartialService - Error Recovery", () => {
     expect(appendedMessage.metadata?.historySequence).toBe(1);
 
     // Should have deleted the partial after committing
-    const deletePartial = partialService.deletePartial as ReturnType<typeof jest.fn>;
+    const deletePartial = partialService.deletePartial as ReturnType<typeof mock>;
     expect(deletePartial).toHaveBeenCalledWith(workspaceId);
   });
 
@@ -123,13 +123,13 @@ describe("PartialService - Error Recovery", () => {
     };
 
     // Mock readPartial to return errored partial
-    partialService.readPartial = jest.fn(() => Promise.resolve(erroredPartial));
+    partialService.readPartial = mock(() => Promise.resolve(erroredPartial));
 
     // Mock deletePartial
-    partialService.deletePartial = jest.fn(() => Promise.resolve(Ok(undefined)));
+    partialService.deletePartial = mock(() => Promise.resolve(Ok(undefined)));
 
     // Mock getHistory to return existing placeholder
-    mockHistoryService.getHistory = jest.fn(() => Promise.resolve(Ok([existingPlaceholder])));
+    mockHistoryService.getHistory = mock(() => Promise.resolve(Ok([existingPlaceholder])));
 
     // Call commitToHistory
     const result = await partialService.commitToHistory(workspaceId);
@@ -138,8 +138,8 @@ describe("PartialService - Error Recovery", () => {
     expect(result.success).toBe(true);
 
     // Should have called updateHistory (not append) with cleaned metadata
-    const updateHistory = mockHistoryService.updateHistory as ReturnType<typeof jest.fn>;
-    const appendToHistory = mockHistoryService.appendToHistory as ReturnType<typeof jest.fn>;
+    const updateHistory = mockHistoryService.updateHistory as ReturnType<typeof mock>;
+    const appendToHistory = mockHistoryService.appendToHistory as ReturnType<typeof mock>;
     expect(updateHistory).toHaveBeenCalledTimes(1);
     expect(appendToHistory).not.toHaveBeenCalled();
 
@@ -150,7 +150,7 @@ describe("PartialService - Error Recovery", () => {
     expect(updatedMessage.metadata?.errorType).toBeUndefined();
 
     // Should have deleted the partial after updating
-    const deletePartial = partialService.deletePartial as ReturnType<typeof jest.fn>;
+    const deletePartial = partialService.deletePartial as ReturnType<typeof mock>;
     expect(deletePartial).toHaveBeenCalledWith(workspaceId);
   });
 
@@ -171,13 +171,13 @@ describe("PartialService - Error Recovery", () => {
     };
 
     // Mock readPartial to return empty errored partial
-    partialService.readPartial = jest.fn(() => Promise.resolve(emptyErrorPartial));
+    partialService.readPartial = mock(() => Promise.resolve(emptyErrorPartial));
 
     // Mock deletePartial
-    partialService.deletePartial = jest.fn(() => Promise.resolve(Ok(undefined)));
+    partialService.deletePartial = mock(() => Promise.resolve(Ok(undefined)));
 
     // Mock getHistory to return no existing messages
-    mockHistoryService.getHistory = jest.fn(() => Promise.resolve(Ok([])));
+    mockHistoryService.getHistory = mock(() => Promise.resolve(Ok([])));
 
     // Call commitToHistory
     const result = await partialService.commitToHistory(workspaceId);
@@ -186,11 +186,11 @@ describe("PartialService - Error Recovery", () => {
     expect(result.success).toBe(true);
 
     // Should NOT call appendToHistory for empty message (no value to preserve)
-    const appendToHistory = mockHistoryService.appendToHistory as ReturnType<typeof jest.fn>;
+    const appendToHistory = mockHistoryService.appendToHistory as ReturnType<typeof mock>;
     expect(appendToHistory).not.toHaveBeenCalled();
 
     // Should still delete the partial (cleanup)
-    const deletePartial = partialService.deletePartial as ReturnType<typeof jest.fn>;
+    const deletePartial = partialService.deletePartial as ReturnType<typeof mock>;
     expect(deletePartial).toHaveBeenCalledWith(workspaceId);
   });
 });

src/services/streamManager.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach, jest } from "@jest/globals";
+import { describe, test, expect, beforeEach, mock } from "bun:test";
 import { StreamManager } from "./streamManager";
 import type { HistoryService } from "./historyService";
 import type { PartialService } from "./partialService";
@@ -17,21 +17,21 @@ if (shouldRunIntegrationTests()) {
 // Mock HistoryService
 const createMockHistoryService = (): HistoryService => {
   return {
-    appendToHistory: jest.fn(() => Promise.resolve({ success: true })),
-    getHistory: jest.fn(() => Promise.resolve({ success: true, data: [] })),
-    updateHistory: jest.fn(() => Promise.resolve({ success: true })),
-    truncateAfterMessage: jest.fn(() => Promise.resolve({ success: true })),
-    clearHistory: jest.fn(() => Promise.resolve({ success: true })),
+    appendToHistory: mock(() => Promise.resolve({ success: true })),
+    getHistory: mock(() => Promise.resolve({ success: true, data: [] })),
+    updateHistory: mock(() => Promise.resolve({ success: true })),
+    truncateAfterMessage: mock(() => Promise.resolve({ success: true })),
+    clearHistory: mock(() => Promise.resolve({ success: true })),
   } as unknown as HistoryService;
 };
 
 // Mock PartialService
 const createMockPartialService = (): PartialService => {
   return {
-    writePartial: jest.fn(() => Promise.resolve({ success: true })),
-    readPartial: jest.fn(() => Promise.resolve(null)),
-    deletePartial: jest.fn(() => Promise.resolve({ success: true })),
-    commitToHistory: jest.fn(() => Promise.resolve({ success: true })),
+    writePartial: mock(() => Promise.resolve({ success: true })),
+    readPartial: mock(() => Promise.resolve(null)),
+    deletePartial: mock(() => Promise.resolve({ success: true })),
+    commitToHistory: mock(() => Promise.resolve({ success: true })),
   } as unknown as PartialService;
 };
 

src/services/systemMessage.test.ts

@@ -3,15 +3,15 @@ import * as os from "os";
 import * as path from "path";
 import { buildSystemMessage } from "./systemMessage";
 import type { WorkspaceMetadata } from "@/types/workspace";
-import { describe, test, expect, beforeEach, afterEach, jest } from "@jest/globals";
+import { describe, test, expect, beforeEach, afterEach, spyOn, type Mock } from "bun:test";
 import { LocalRuntime } from "@/runtime/LocalRuntime";
 
 describe("buildSystemMessage", () => {
   let tempDir: string;
   let projectDir: string;
   let workspaceDir: string;
   let globalDir: string;
-  let mockHomedir: jest.SpiedFunction<typeof os.homedir>;
+  let mockHomedir: Mock<typeof os.homedir>;
   let runtime: LocalRuntime;
 
   beforeEach(async () => {
@@ -25,7 +25,7 @@ describe("buildSystemMessage", () => {
     await fs.mkdir(globalDir, { recursive: true });
 
     // Mock homedir to return our test directory (getSystemDirectory will append .cmux)
-    mockHomedir = jest.spyOn(os, "homedir");
+    mockHomedir = spyOn(os, "homedir");
     mockHomedir.mockReturnValue(tempDir);
 
     // Create a local runtime for tests

src/stores/MapStore.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach } from "@jest/globals";
+import { describe, test, expect, beforeEach } from "bun:test";
 import { MapStore } from "./MapStore";
 
 describe("MapStore", () => {