test(roo-import): add unit tests for importRooHandoff command handler

Author: edelauna

src/activate/__tests__/registerCommands.spec.ts

@@ -1,8 +1,9 @@
 import type { Mock } from "vitest"
 import * as vscode from "vscode"
 import { ClineProvider } from "../../core/webview/ClineProvider"
+import * as RooImport from "../../services/roo-import/RooImport"
 
-import { getVisibleProviderOrLog } from "../registerCommands"
+import { getVisibleProviderOrLog, handleImportRooHandoff } from "../registerCommands"
 
 vi.mock("execa", () => ({
 	execa: vi.fn(),
@@ -29,6 +30,11 @@ vi.mock("vscode", () => ({
 
 vi.mock("../../core/webview/ClineProvider")
 
+vi.mock("../../services/roo-import/RooImport", () => ({
+	importRooHandoffFromPath: vi.fn(),
+	promptAndImportRooHandoff: vi.fn(),
+}))
+
 describe("getVisibleProviderOrLog", () => {
 	let mockOutputChannel: vscode.OutputChannel
 
@@ -65,3 +71,68 @@ describe("getVisibleProviderOrLog", () => {
 		expect(mockOutputChannel.appendLine).toHaveBeenCalledWith("Cannot find any visible Roo Code instances.")
 	})
 })
+
+describe("handleImportRooHandoff", () => {
+	let mockOutputChannel: vscode.OutputChannel
+	let mockContext: vscode.ExtensionContext
+	let mockProvider: Partial<ClineProvider>
+
+	beforeEach(() => {
+		mockOutputChannel = { appendLine: vi.fn() } as any
+		mockContext = { globalStorageUri: { fsPath: "/tmp/zoo" } } as any
+		mockProvider = {
+			providerSettingsManager: {} as any,
+			contextProxy: {} as any,
+			customModesManager: {} as any,
+			postStateToWebview: vi.fn().mockResolvedValue(undefined),
+		}
+		vi.clearAllMocks()
+		;(ClineProvider.getInstance as Mock).mockResolvedValue(mockProvider)
+	})
+
+	it("returns undefined when no provider is available", async () => {
+		;(ClineProvider.getInstance as Mock).mockResolvedValue(undefined)
+
+		const result = await handleImportRooHandoff(undefined, mockContext, mockOutputChannel)
+
+		expect(result).toBeUndefined()
+	})
+
+	it("calls importRooHandoffFromPath when a handoff path is given", async () => {
+		const mockResult = { success: true, tasksCopied: 2 }
+		vi.mocked(RooImport.importRooHandoffFromPath).mockResolvedValue(mockResult)
+
+		const result = await handleImportRooHandoff("/path/to/handoff.json", mockContext, mockOutputChannel)
+
+		expect(RooImport.importRooHandoffFromPath).toHaveBeenCalledWith("/path/to/handoff.json", expect.any(Object))
+		expect(mockProvider.postStateToWebview).toHaveBeenCalled()
+		expect(result).toBe(mockResult)
+	})
+
+	it("calls promptAndImportRooHandoff when no path is given", async () => {
+		const mockResult = { success: true, tasksCopied: 0 }
+		vi.mocked(RooImport.promptAndImportRooHandoff).mockResolvedValue(mockResult)
+
+		const result = await handleImportRooHandoff(undefined, mockContext, mockOutputChannel)
+
+		expect(RooImport.promptAndImportRooHandoff).toHaveBeenCalled()
+		expect(result).toBe(mockResult)
+	})
+
+	it("does not call postStateToWebview when import returns undefined", async () => {
+		vi.mocked(RooImport.promptAndImportRooHandoff).mockResolvedValue(undefined)
+
+		await handleImportRooHandoff(undefined, mockContext, mockOutputChannel)
+
+		expect(mockProvider.postStateToWebview).not.toHaveBeenCalled()
+	})
+
+	it("logs and returns undefined when the import throws", async () => {
+		vi.mocked(RooImport.importRooHandoffFromPath).mockRejectedValue(new Error("disk full"))
+
+		const result = await handleImportRooHandoff("/path/to/handoff.json", mockContext, mockOutputChannel)
+
+		expect(result).toBeUndefined()
+		expect(mockOutputChannel.appendLine).toHaveBeenCalledWith("[Roo Import] Failed: disk full")
+	})
+})

src/activate/registerCommands.ts

@@ -62,6 +62,41 @@ export type RegisterCommandOptions = {
 	provider: ClineProvider
 }
 
+export async function handleImportRooHandoff(
+	handoffPath: string | undefined,
+	context: vscode.ExtensionContext,
+	outputChannel: vscode.OutputChannel,
+) {
+	const visibleProvider = await ClineProvider.getInstance()
+	if (!visibleProvider) {
+		return undefined
+	}
+
+	const importOptions = {
+		context,
+		providerSettingsManager: visibleProvider.providerSettingsManager,
+		contextProxy: visibleProvider.contextProxy,
+		customModesManager: visibleProvider.customModesManager,
+		outputChannel,
+	}
+
+	try {
+		const result = handoffPath
+			? await importRooHandoffFromPath(handoffPath, importOptions)
+			: await promptAndImportRooHandoff(importOptions)
+
+		if (result) {
+			await visibleProvider.postStateToWebview()
+		}
+
+		return result
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error)
+		outputChannel.appendLine(`[Roo Import] Failed: ${message}`)
+		return undefined
+	}
+}
+
 export const registerCommands = (options: RegisterCommandOptions) => {
 	const { context } = options
 
@@ -145,36 +180,7 @@ const getCommandsMap = ({ context, outputChannel, provider }: RegisterCommandOpt
 			filePath,
 		)
 	},
-	importRooHandoff: async (handoffPath?: string) => {
-		const visibleProvider = await ClineProvider.getInstance()
-		if (!visibleProvider) {
-			return undefined
-		}
-
-		const importOptions = {
-			context,
-			providerSettingsManager: visibleProvider.providerSettingsManager,
-			contextProxy: visibleProvider.contextProxy,
-			customModesManager: visibleProvider.customModesManager,
-			outputChannel,
-		}
-
-		try {
-			const result = handoffPath
-				? await importRooHandoffFromPath(handoffPath, importOptions)
-				: await promptAndImportRooHandoff(importOptions)
-
-			if (result) {
-				await visibleProvider.postStateToWebview()
-			}
-
-			return result
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error)
-			outputChannel.appendLine(`[Roo Import] Failed: ${message}`)
-			return undefined
-		}
-	},
+	importRooHandoff: (handoffPath?: string) => handleImportRooHandoff(handoffPath, context, outputChannel),
 	focusInput: async () => {
 		try {
 			await focusPanel(tabPanel, sidebarPanel)