test(api): cover task controls and view-local values

Author: easonliang28

src/core/webview/__tests__/ClineProvider.parallelMode.spec.ts

@@ -1060,6 +1060,44 @@ describe("ClineProvider - Parallel Mode Support", () => {
 			await provider.dispose()
 		})
 
+		it("should merge getValues from ContextProxy with view-local values taking precedence", async () => {
+			const provider = new ClineProvider(mockContext, mockOutputChannel, "sidebar", new ContextProxy(mockContext))
+			const providerAccess = provider as unknown as {
+				saveViewState: (key: keyof ExtensionState, value: unknown) => Promise<void>
+			}
+			const contextProxyAccess = provider.contextProxy as unknown as {
+				setValues: (values: Partial<ExtensionState>) => Promise<void>
+			}
+			await contextProxyAccess.setValues({
+				mode: "debugger",
+				currentApiConfigName: "shared-profile",
+				apiConfiguration: {
+					apiProvider: "anthropic",
+					apiKey: "shared-key",
+				},
+				customModePrompts: { code: { roleDefinition: "shared" } },
+			})
+
+			await providerAccess.saveViewState("mode", "architect")
+			await providerAccess.saveViewState("currentApiConfigName", "view-profile")
+			await providerAccess.saveViewState("apiConfiguration", {
+				apiProvider: "openrouter",
+				openRouterApiKey: "view-key",
+			})
+
+			const values = provider.getValues()
+
+			expect(values.mode).toBe("architect")
+			expect(values.currentApiConfigName).toBe("view-profile")
+			expect(values.apiConfiguration).toEqual({
+				apiProvider: "openrouter",
+				openRouterApiKey: "view-key",
+			})
+			expect(values.customModePrompts).toEqual({ code: { roleDefinition: "shared" } })
+
+			await provider.dispose()
+		})
+
 		it("should update viewLocalState apiConfiguration when setValues receives flat provider settings", async () => {
 			const provider = new ClineProvider(mockContext, mockOutputChannel, "sidebar", new ContextProxy(mockContext))
 

src/extension/__tests__/api-task-control.spec.ts

@@ -0,0 +1,253 @@
+import { EventEmitter } from "events"
+
+import { describe, expect, it, vi, beforeEach, type Mock } from "vitest"
+import * as vscode from "vscode"
+
+import { RooCodeEventName, type ModeConfig, type RooCodeSettings } from "@roo-code/types"
+
+import { API } from "../api"
+import { ClineProvider } from "../../core/webview/ClineProvider"
+
+const { openClineInNewTabMock } = vi.hoisted(() => ({
+	openClineInNewTabMock: vi.fn(),
+}))
+
+vi.mock("vscode", () => ({
+	commands: {
+		executeCommand: vi.fn().mockResolvedValue(undefined),
+	},
+}))
+
+vi.mock("@roo-code/ipc", () => ({
+	IpcServer: class {},
+}))
+
+vi.mock("../../activate/registerCommands", () => ({
+	openClineInNewTab: openClineInNewTabMock,
+}))
+
+vi.mock("../../integrations/terminal/Terminal", () => ({
+	Terminal: {
+		getTerminalProfile: vi.fn(),
+		setTerminalProfile: vi.fn(),
+	},
+}))
+
+vi.mock("../../integrations/terminal/TerminalRegistry", () => ({
+	TerminalRegistry: {
+		closeIdleTerminals: vi.fn(),
+	},
+}))
+
+type CreatedTask = {
+	taskId: string
+}
+
+type ProviderDouble = EventEmitter & {
+	context: vscode.ExtensionContext
+	evictCurrentTask: Mock<() => Promise<void>>
+	postStateToWebview: Mock<() => Promise<void>>
+	postMessageToWebview: Mock<(message: unknown) => Promise<void>>
+	createTask: Mock<(...args: unknown[]) => Promise<CreatedTask>>
+	getCurrentTaskStack: Mock<() => string[]>
+	getCurrentTask: Mock<() => undefined>
+	getState: Mock<() => Promise<{ customModes?: ModeConfig[] }>>
+	handleModeSwitch: Mock<(mode: string) => Promise<void>>
+	viewLaunched: boolean
+}
+
+type TaskDouble = EventEmitter & {
+	taskId: string
+	parentTaskId?: string
+	approveAsk: Mock<() => void>
+	handleWebviewAskResponse: Mock<(response: "messageResponse", text?: string, images?: string[]) => void>
+}
+
+const configuration: RooCodeSettings = {}
+
+function asClineProvider(provider: ProviderDouble): ClineProvider {
+	// ClineProvider has private members, so a structural test double requires an unknown bridge.
+	return provider as unknown as ClineProvider
+}
+
+function createProvider(taskId = "task-1"): ProviderDouble {
+	const provider = new EventEmitter() as ProviderDouble
+	provider.context = {} as vscode.ExtensionContext
+	provider.evictCurrentTask = vi.fn().mockResolvedValue(undefined)
+	provider.postStateToWebview = vi.fn().mockResolvedValue(undefined)
+	provider.postMessageToWebview = vi.fn().mockResolvedValue(undefined)
+	provider.createTask = vi.fn().mockResolvedValue({ taskId })
+	provider.getCurrentTaskStack = vi.fn().mockReturnValue([])
+	provider.getCurrentTask = vi.fn().mockReturnValue(undefined)
+	provider.getState = vi.fn().mockResolvedValue({ customModes: [] })
+	provider.handleModeSwitch = vi.fn().mockResolvedValue(undefined)
+	provider.viewLaunched = true
+	return provider
+}
+
+function createTask(taskId: string): TaskDouble {
+	const task = new EventEmitter() as TaskDouble
+	task.taskId = taskId
+	task.approveAsk = vi.fn()
+	task.handleWebviewAskResponse = vi.fn()
+	return task
+}
+
+describe("API task controls", () => {
+	let outputChannel: vscode.OutputChannel
+	let sidebarProvider: ProviderDouble
+	let api: API
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel
+		sidebarProvider = createProvider("sidebar-task")
+		api = new API(outputChannel, asClineProvider(sidebarProvider))
+	})
+
+	describe("startNewTask", () => {
+		it("reverts and closes existing editors before opening a new tab unless preserveOpenTabs is true", async () => {
+			const newTabProvider = createProvider("new-tab-task")
+			openClineInNewTabMock.mockResolvedValue(newTabProvider)
+
+			const taskId = await api.startNewTask({ configuration, text: "new task", newTab: true })
+
+			expect(taskId).toBe("new-tab-task")
+			expect(vscode.commands.executeCommand).toHaveBeenNthCalledWith(1, "workbench.action.files.revert")
+			expect(vscode.commands.executeCommand).toHaveBeenNthCalledWith(2, "workbench.action.closeAllEditors")
+			expect(openClineInNewTabMock).toHaveBeenCalledWith({
+				context: sidebarProvider.context,
+				outputChannel,
+			})
+			expect(newTabProvider.evictCurrentTask).toHaveBeenCalledOnce()
+			expect(newTabProvider.createTask).toHaveBeenCalledWith(
+				"new task",
+				undefined,
+				undefined,
+				{ consecutiveMistakeLimit: Number.MAX_SAFE_INTEGER },
+				configuration,
+			)
+		})
+
+		it("opens a new tab without revert or close commands when preserveOpenTabs is true", async () => {
+			const newTabProvider = createProvider("preserved-tab-task")
+			openClineInNewTabMock.mockResolvedValue(newTabProvider)
+
+			const taskId = await api.startNewTask({
+				configuration,
+				text: "keep editors",
+				newTab: true,
+				preserveOpenTabs: true,
+			})
+
+			expect(taskId).toBe("preserved-tab-task")
+			expect(vscode.commands.executeCommand).not.toHaveBeenCalled()
+			expect(openClineInNewTabMock).toHaveBeenCalledWith({
+				context: sidebarProvider.context,
+				outputChannel,
+			})
+			expect(newTabProvider.createTask).toHaveBeenCalledWith(
+				"keep editors",
+				undefined,
+				undefined,
+				{ consecutiveMistakeLimit: Number.MAX_SAFE_INTEGER },
+				configuration,
+			)
+		})
+	})
+
+	describe("task ask registry", () => {
+		it("returns false when approving an unknown task", async () => {
+			await expect(api.approveTaskAsk("missing-task")).resolves.toBe(false)
+		})
+
+		it("registers tasks on TaskCreated and approves a task by id", async () => {
+			const task = createTask("task-to-approve")
+
+			sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
+
+			await expect(api.approveTaskAsk(task.taskId)).resolves.toBe(true)
+			expect(task.approveAsk).toHaveBeenCalledOnce()
+		})
+
+		it("removes completed and aborted tasks from the registry", async () => {
+			const completedTask = createTask("completed-task")
+			sidebarProvider.emit(RooCodeEventName.TaskCreated, completedTask)
+			completedTask.emit(RooCodeEventName.TaskCompleted, completedTask.taskId, {}, {})
+
+			await expect(api.approveTaskAsk(completedTask.taskId)).resolves.toBe(false)
+
+			const abortedTask = createTask("aborted-task")
+			sidebarProvider.emit(RooCodeEventName.TaskCreated, abortedTask)
+			abortedTask.emit(RooCodeEventName.TaskAborted)
+
+			await expect(api.approveTaskAsk(abortedTask.taskId)).resolves.toBe(false)
+		})
+	})
+
+	describe("selectTaskFollowupSuggestion", () => {
+		it("returns false when the task is unknown", async () => {
+			await expect(
+				api.selectTaskFollowupSuggestion({ taskId: "missing-task", answer: "Use this" }),
+			).resolves.toBe(false)
+		})
+
+		it("responds to the task without switching modes when no mode is provided", async () => {
+			const task = createTask("task-without-mode")
+			sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
+
+			await expect(api.selectTaskFollowupSuggestion({ taskId: task.taskId, answer: "Continue" })).resolves.toBe(
+				true,
+			)
+
+			expect(sidebarProvider.getState).not.toHaveBeenCalled()
+			expect(sidebarProvider.handleModeSwitch).not.toHaveBeenCalled()
+			expect(task.handleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "Continue")
+		})
+
+		it("switches to a valid built-in mode before responding", async () => {
+			const task = createTask("task-built-in-mode")
+			sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
+
+			await expect(
+				api.selectTaskFollowupSuggestion({ taskId: task.taskId, answer: "Use architect", mode: "architect" }),
+			).resolves.toBe(true)
+
+			expect(sidebarProvider.getState).toHaveBeenCalledOnce()
+			expect(sidebarProvider.handleModeSwitch).toHaveBeenCalledWith("architect")
+			expect(task.handleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "Use architect")
+		})
+
+		it("responds without switching modes when the requested mode is invalid", async () => {
+			const task = createTask("task-invalid-mode")
+			sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
+
+			await expect(
+				api.selectTaskFollowupSuggestion({ taskId: task.taskId, answer: "Use invalid", mode: "not-a-mode" }),
+			).resolves.toBe(true)
+
+			expect(sidebarProvider.getState).toHaveBeenCalledOnce()
+			expect(sidebarProvider.handleModeSwitch).not.toHaveBeenCalled()
+			expect(task.handleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "Use invalid")
+		})
+
+		it("treats custom modes from the task provider state as valid", async () => {
+			const task = createTask("task-custom-mode")
+			const customMode: ModeConfig = {
+				slug: "custom-review",
+				name: "Custom Review",
+				roleDefinition: "Review the implementation",
+				groups: ["read"],
+			}
+			sidebarProvider.getState.mockResolvedValue({ customModes: [customMode] })
+			sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
+
+			await expect(
+				api.selectTaskFollowupSuggestion({ taskId: task.taskId, answer: "Review it", mode: customMode.slug }),
+			).resolves.toBe(true)
+
+			expect(sidebarProvider.handleModeSwitch).toHaveBeenCalledWith(customMode.slug)
+			expect(task.handleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "Review it")
+		})
+	})
+})