test: increasing coverage of touched files

Author: edelauna

src/api/providers/__tests__/unbound.spec.ts

@@ -181,4 +181,24 @@ describe("UnboundHandler", () => {
 			}),
 		)
 	})
+
+	it("completePrompt returns the response text", async () => {
+		const mockCreate = (OpenAI as unknown as any)().chat.completions.create
+		mockCreate.mockResolvedValue({
+			choices: [{ message: { content: "completed text" } }],
+		})
+
+		const handler = new UnboundHandler({
+			unboundApiKey: "test-key",
+			unboundModelId: "openai/gpt-4o",
+		})
+
+		const result = await handler.completePrompt("Write a haiku")
+		expect(result).toBe("completed text")
+		expect(mockCreate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: [{ role: "system", content: "Write a haiku" }],
+			}),
+		)
+	})
 })

src/core/context-tracking/__tests__/FileContextTracker.spec.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { FileContextTracker } from "../FileContextTracker"
+
+vi.mock("vscode", () => ({
+	workspace: {
+		workspaceFolders: [{ uri: { fsPath: "/workspace" } }],
+		createFileSystemWatcher: vi.fn().mockReturnValue({
+			onDidChange: vi.fn(),
+			onDidCreate: vi.fn(),
+			onDidDelete: vi.fn(),
+			dispose: vi.fn(),
+		}),
+	},
+	Uri: { file: vi.fn((p: string) => ({ fsPath: p })) },
+	RelativePattern: vi.fn(),
+}))
+
+vi.mock("../../../utils/storage", () => ({
+	getTaskDirectoryPath: vi.fn().mockResolvedValue("/storage/task-1"),
+}))
+
+vi.mock("../../../utils/fs", () => ({
+	fileExistsAtPath: vi.fn().mockResolvedValue(false),
+}))
+
+vi.mock("../../../utils/safeWriteJson", () => ({
+	safeWriteJson: vi.fn().mockResolvedValue(undefined),
+}))
+
+vi.mock("fs/promises", () => ({
+	default: { readFile: vi.fn() },
+}))
+
+vi.mock("path", async () => {
+	const actual = await vi.importActual<typeof import("path")>("path")
+	return { ...actual, default: actual }
+})
+
+describe("FileContextTracker.addFileToFileContextTracker", () => {
+	let tracker: FileContextTracker
+	const mockProvider = {
+		contextProxy: {
+			globalStorageUri: { fsPath: "/storage" },
+		},
+	} as any
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		tracker = new FileContextTracker(mockProvider, "task-1")
+	})
+
+	it("creates a new active entry with record_source set to the given source", async () => {
+		const { safeWriteJson } = await import("../../../utils/safeWriteJson")
+		const mockWrite = vi.mocked(safeWriteJson)
+
+		await tracker.addFileToFileContextTracker("task-1", "/workspace/foo.ts", "read_tool")
+
+		expect(mockWrite).toHaveBeenCalledOnce()
+		const written = mockWrite.mock.calls[0][1] as any
+		const entry = written.files_in_context[0]
+		expect(entry.path).toBe("/workspace/foo.ts")
+		expect(entry.record_state).toBe("active")
+		expect(entry.record_source).toBe("read_tool")
+		expect(entry.roo_read_date).toBeTypeOf("number")
+	})
+
+	it("marks existing active entries as stale before adding the new entry", async () => {
+		const { fileExistsAtPath } = await import("../../../utils/fs")
+		const fs = await import("fs/promises")
+		vi.mocked(fileExistsAtPath).mockResolvedValue(true)
+		vi.mocked(fs.default.readFile).mockResolvedValue(
+			JSON.stringify({
+				files_in_context: [{ path: "/workspace/foo.ts", record_state: "active", record_source: "read_tool" }],
+			}) as any,
+		)
+
+		const { safeWriteJson } = await import("../../../utils/safeWriteJson")
+		const mockWrite = vi.mocked(safeWriteJson)
+
+		await tracker.addFileToFileContextTracker("task-1", "/workspace/foo.ts", "roo_edited")
+
+		const written = mockWrite.mock.calls[0][1] as any
+		expect(written.files_in_context[0].record_state).toBe("stale")
+		expect(written.files_in_context[1].record_state).toBe("active")
+	})
+})

src/services/code-index/__tests__/orchestrator.spec.ts

@@ -160,6 +160,67 @@ describe("CodeIndexOrchestrator - error path cleanup gating", () => {
 		const lastCall = stateManager.setSystemState.mock.calls[stateManager.setSystemState.mock.calls.length - 1]
 		expect(lastCall[0]).toBe("Error")
 	})
+
+	it("collects batch errors from full scan and transitions to Error when all blocks fail", async () => {
+		const batchError = new Error("batch failure")
+		vectorStore.initialize.mockResolvedValue(false) // existing collection
+		vectorStore.hasIndexedData.mockResolvedValue(false) // force full scan path
+		vectorStore.markIndexingIncomplete.mockResolvedValue(undefined)
+		vectorStore.markIndexingComplete.mockResolvedValue(undefined)
+
+		// Report a batch error — no blocks indexed, so orchestrator treats it as complete failure
+		scanner.scanDirectory.mockImplementation(async (_dir: string, onBatchError: (e: Error) => void) => {
+			onBatchError(batchError)
+			return { stats: { processed: 0, skipped: 0 }, totalBlockCount: 0 }
+		})
+
+		const orchestrator = new CodeIndexOrchestrator(
+			configManager,
+			stateManager,
+			workspacePath,
+			cacheManager,
+			vectorStore,
+			scanner,
+			fileWatcher,
+		)
+
+		await orchestrator.startIndexing()
+
+		// With a batch error and zero indexed blocks the orchestrator sets Error state
+		const calls = stateManager.setSystemState.mock.calls.map((c: any[]) => c[0])
+		expect(calls[calls.length - 1]).toBe("Error")
+	})
+
+	it("collects batch errors from incremental scan and still completes indexing", async () => {
+		const batchError = new Error("incremental batch failure")
+		vectorStore.initialize.mockResolvedValue(false) // existing collection
+		vectorStore.hasIndexedData.mockResolvedValue(true) // force incremental scan path
+		vectorStore.markIndexingIncomplete.mockResolvedValue(undefined)
+		vectorStore.markIndexingComplete.mockResolvedValue(undefined)
+
+		// Incremental scan reports a batch error but returns a result — orchestrator completes normally
+		scanner.scanDirectory.mockImplementation(async (_dir: string, onBatchError: (e: Error) => void) => {
+			onBatchError(batchError)
+			return { stats: { processed: 0, skipped: 0 }, totalBlockCount: 0 }
+		})
+
+		const orchestrator = new CodeIndexOrchestrator(
+			configManager,
+			stateManager,
+			workspacePath,
+			cacheManager,
+			vectorStore,
+			scanner,
+			fileWatcher,
+		)
+
+		await orchestrator.startIndexing()
+
+		// Incremental scan doesn't gate on batch errors — Indexed state is still reached
+		const calls = stateManager.setSystemState.mock.calls.map((c: any[]) => c[0])
+		expect(calls[calls.length - 1]).toBe("Indexed")
+		expect(calls).not.toContain("Error")
+	})
 })
 
 describe("CodeIndexOrchestrator - stopIndexing", () => {

src/services/mcp/__tests__/McpHub.spec.ts

@@ -2692,6 +2692,35 @@ describe("McpHub", () => {
 			expect(mockAuthProvider.close).toHaveBeenCalled()
 		})
 
+		it("should dispose the cancellation listener when the OAuth flow times out", async () => {
+			vi.useFakeTimers()
+			const mockDispose = vi.fn()
+			vsc.window.withProgress.mockImplementationOnce((_options: any, task: any) => {
+				const progress = { report: vi.fn() }
+				const cancellationToken = {
+					isCancellationRequested: false,
+					onCancellationRequested: vi.fn(() => ({ dispose: mockDispose })),
+				}
+				return task(progress, cancellationToken)
+			})
+			vsc.window.showInformationMessage.mockImplementation(() => new Promise(() => {}))
+
+			const flowPromise = (mcpHub as any)._initiateOAuthFlow(
+				serverName,
+				source,
+				config,
+				mockAuthProvider,
+				mockTransport,
+				mockConnection,
+			)
+
+			await vi.advanceTimersByTimeAsync(OAUTH_FLOW_TIMEOUT_MS)
+			await flowPromise
+
+			// cleanup(cancellationDisposable) inside the timeout handler must dispose the listener
+			expect(mockDispose).toHaveBeenCalled()
+		})
+
 		it("should resolve without calling _completeOAuthFlow when tokens exist at click time", async () => {
 			// Tokens are present when Authenticate is clicked (click-time guard in the loop).
 			// First call (pre-withProgress early-return check) returns null so withProgress runs.