fix vitest 4 mock typings

Author: maxdewald

packages/cloud/src/__mocks__/vscode.ts

@@ -1,19 +1,30 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
+type VscodeWindowMock = {
+	showInformationMessage: (message: string) => void
+	showErrorMessage: (message: string) => void
+}
+
+type VscodeEnvMock = {
+	openExternal: (uri: unknown) => Promise<void>
+}
+
+type VscodeCommandsMock = {
+	executeCommand: (command: string, ...args: unknown[]) => Promise<unknown>
+}
 
-export const window = {
+export const window: VscodeWindowMock = {
 	showInformationMessage: vi.fn(),
 	showErrorMessage: vi.fn(),
 }
 
-export const env = {
+export const env: VscodeEnvMock = {
 	openExternal: vi.fn(),
 }
 
 export const Uri = {
 	parse: vi.fn((uri: string) => ({ toString: () => uri })),
 }
 
-export const commands = {
+export const commands: VscodeCommandsMock = {
 	executeCommand: vi.fn().mockResolvedValue(undefined),
 }
 
@@ -28,9 +39,9 @@ export interface ExtensionContext {
 	}
 	globalState: {
 		get: <T>(key: string) => T | undefined
-		update: (key: string, value: any) => Promise<void>
+		update: (key: string, value: unknown) => Promise<void>
 	}
-	subscriptions: any[]
+	subscriptions: unknown[]
 	extension?: {
 		packageJSON?: {
 			version?: string

packages/cloud/src/__tests__/CloudSettingsService.test.ts

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "vscode"
+import type { Mock } from "vitest"
 
 import type { OrganizationSettings, AuthService } from "@roo-code/types"
 
@@ -13,21 +14,23 @@ vi.mock("../config", () => ({
 
 global.fetch = vi.fn()
 
+type AuthStateChangedListener = (data: unknown) => unknown
+
 describe("CloudSettingsService", () => {
 	let mockContext: ExtensionContext
 	let mockAuthService: {
-		getState: ReturnType<typeof vi.fn>
-		getSessionToken: ReturnType<typeof vi.fn>
-		hasActiveSession: ReturnType<typeof vi.fn>
-		on: ReturnType<typeof vi.fn>
-		getStoredOrganizationId: ReturnType<typeof vi.fn>
+		getState: Mock<() => string>
+		getSessionToken: Mock<() => string | undefined | null>
+		hasActiveSession: Mock<() => boolean>
+		on: Mock<(event: string, listener: AuthStateChangedListener) => void>
+		getStoredOrganizationId: Mock<() => string | null>
 	}
 	let mockRefreshTimer: {
-		start: ReturnType<typeof vi.fn>
-		stop: ReturnType<typeof vi.fn>
+		start: Mock<() => void>
+		stop: Mock<() => void>
 	}
 	let cloudSettingsService: CloudSettingsService
-	let mockLog: ReturnType<typeof vi.fn>
+	let mockLog: Mock<(...args: unknown[]) => void>
 
 	const mockSettings: OrganizationSettings = {
 		version: 1,
@@ -72,10 +75,12 @@ describe("CloudSettingsService", () => {
 			stop: vi.fn(),
 		}
 
-		mockLog = vi.fn()
+		mockLog = vi.fn<(...args: unknown[]) => void>()
 
 		// Mock RefreshTimer constructor
-		vi.mocked(RefreshTimer).mockImplementation(() => mockRefreshTimer as unknown as RefreshTimer)
+		vi.mocked(RefreshTimer).mockImplementation(function () {
+			return mockRefreshTimer as unknown as RefreshTimer
+		})
 
 		cloudSettingsService = new CloudSettingsService(mockContext, mockAuthService as unknown as AuthService, mockLog)
 	})
@@ -502,10 +507,9 @@ describe("CloudSettingsService", () => {
 			await cloudSettingsService.initialize()
 
 			// Get the auth-state-changed handler
-			const authStateChangedHandler = mockAuthService.on.mock.calls.find(
-				(call: string[]) => call[0] === "auth-state-changed",
-			)?.[1]
-			expect(authStateChangedHandler).toBeDefined()
+			const [, authStateChangedHandler] = mockAuthService.on.mock.calls.find(
+				([event]) => event === "auth-state-changed",
+			) as [string, AuthStateChangedListener]
 
 			// Simulate active-session state change
 			authStateChangedHandler({
@@ -519,10 +523,9 @@ describe("CloudSettingsService", () => {
 			await cloudSettingsService.initialize()
 
 			// Get the auth-state-changed handler
-			const authStateChangedHandler = mockAuthService.on.mock.calls.find(
-				(call: string[]) => call[0] === "auth-state-changed",
-			)?.[1]
-			expect(authStateChangedHandler).toBeDefined()
+			const [, authStateChangedHandler] = mockAuthService.on.mock.calls.find(
+				([event]) => event === "auth-state-changed",
+			) as [string, AuthStateChangedListener]
 
 			// Simulate logged-out state change from active-session
 			await authStateChangedHandler({

packages/cloud/src/retry-queue/__tests__/RetryQueue.test.ts

@@ -173,7 +173,7 @@ describe("RetryQueue", () => {
 
 		it("should not process retries when paused", async () => {
 			const fetchMock = vi.fn().mockResolvedValue({ ok: true })
-			global.fetch = fetchMock
+			global.fetch = fetchMock as typeof fetch
 
 			await retryQueue.enqueue("https://api.example.com/test", { method: "POST" }, "telemetry")
 
@@ -303,7 +303,7 @@ describe("RetryQueue", () => {
 		beforeEach(() => {
 			// Mock global fetch
 			fetchMock = vi.fn()
-			global.fetch = fetchMock
+			global.fetch = fetchMock as typeof fetch
 		})
 
 		afterEach(() => {

packages/config-typescript/vscode-library.json

@@ -2,7 +2,7 @@
 	"$schema": "https://json.schemastore.org/tsconfig",
 	"extends": "./base.json",
 	"compilerOptions": {
-		"types": ["vitest/globals"],
+		"types": ["node", "vitest/globals"],
 		"outDir": "dist",
 		"module": "esnext",
 		"moduleResolution": "Bundler",

src/core/tools/__tests__/attemptCompletionTool.spec.ts

@@ -1,6 +1,8 @@
+import type { Mock } from "vitest"
+
 import { RooCodeEventName, TodoItem } from "@roo-code/types"
 
-import { AttemptCompletionToolUse } from "../../../shared/tools"
+import { AskApproval, AttemptCompletionToolUse, HandleError, PushToolResult } from "../../../shared/tools"
 
 // Mock the formatResponse module before importing the tool
 vi.mock("../../prompts/responses", () => ({
@@ -44,28 +46,35 @@ import * as vscode from "vscode"
 
 describe("attemptCompletionTool", () => {
 	let mockTask: Partial<Task>
-	let mockPushToolResult: ReturnType<typeof vi.fn>
-	let mockAskApproval: ReturnType<typeof vi.fn>
-	let mockHandleError: ReturnType<typeof vi.fn>
-	let mockToolDescription: ReturnType<typeof vi.fn>
-	let mockAskFinishSubTaskApproval: ReturnType<typeof vi.fn>
-	let mockGetConfiguration: ReturnType<typeof vi.fn>
-
-	beforeEach(() => {
-		mockCaptureTaskCompleted.mockReset()
-		mockPushToolResult = vi.fn()
-		mockAskApproval = vi.fn()
-		mockHandleError = vi.fn()
-		mockToolDescription = vi.fn()
-		mockAskFinishSubTaskApproval = vi.fn()
-		mockGetConfiguration = vi.fn(() => ({
-			get: vi.fn((key: string, defaultValue: any) => {
+	let mockPushToolResult: Mock<PushToolResult>
+	let mockAskApproval: Mock<AskApproval>
+	let mockHandleError: Mock<HandleError>
+	let mockToolDescription: Mock<() => string>
+	let mockAskFinishSubTaskApproval: Mock<() => Promise<boolean>>
+	let mockGetConfiguration: Mock<typeof vscode.workspace.getConfiguration>
+	const workspaceConfigurationWithOpenTodoCompletionPrevention = (
+		preventCompletionWithOpenTodos: boolean,
+	): vscode.WorkspaceConfiguration =>
+		({
+			get: <T>(key: string, defaultValue: T): T => {
 				if (key === "preventCompletionWithOpenTodos") {
-					return defaultValue // Default to false unless overridden in test
+					return preventCompletionWithOpenTodos as T
 				}
+
 				return defaultValue
-			}),
-		}))
+			},
+		}) as vscode.WorkspaceConfiguration
+
+	beforeEach(() => {
+		mockCaptureTaskCompleted.mockReset()
+		mockPushToolResult = vi.fn<PushToolResult>()
+		mockAskApproval = vi.fn<AskApproval>()
+		mockHandleError = vi.fn<HandleError>()
+		mockToolDescription = vi.fn<() => string>()
+		mockAskFinishSubTaskApproval = vi.fn<() => Promise<boolean>>()
+		mockGetConfiguration = vi.fn<typeof vscode.workspace.getConfiguration>(() =>
+			workspaceConfigurationWithOpenTodoCompletionPrevention(false),
+		)
 
 		// Setup vscode mock
 		vi.mocked(vscode.workspace.getConfiguration).mockImplementation(mockGetConfiguration)
@@ -182,14 +191,7 @@ describe("attemptCompletionTool", () => {
 			mockTask.todoList = todosWithPending
 
 			// Enable the setting to prevent completion with open todos
-			mockGetConfiguration.mockReturnValue({
-				get: vi.fn((key: string, defaultValue: any) => {
-					if (key === "preventCompletionWithOpenTodos") {
-						return true // Setting is enabled
-					}
-					return defaultValue
-				}),
-			})
+			mockGetConfiguration.mockReturnValue(workspaceConfigurationWithOpenTodoCompletionPrevention(true))
 
 			const callbacks: AttemptCompletionCallbacks = {
 				askApproval: mockAskApproval,
@@ -224,14 +226,7 @@ describe("attemptCompletionTool", () => {
 			mockTask.todoList = todosWithInProgress
 
 			// Enable the setting to prevent completion with open todos
-			mockGetConfiguration.mockReturnValue({
-				get: vi.fn((key: string, defaultValue: any) => {
-					if (key === "preventCompletionWithOpenTodos") {
-						return true // Setting is enabled
-					}
-					return defaultValue
-				}),
-			})
+			mockGetConfiguration.mockReturnValue(workspaceConfigurationWithOpenTodoCompletionPrevention(true))
 
 			const callbacks: AttemptCompletionCallbacks = {
 				askApproval: mockAskApproval,
@@ -267,14 +262,7 @@ describe("attemptCompletionTool", () => {
 			mockTask.todoList = mixedTodos
 
 			// Enable the setting to prevent completion with open todos
-			mockGetConfiguration.mockReturnValue({
-				get: vi.fn((key: string, defaultValue: any) => {
-					if (key === "preventCompletionWithOpenTodos") {
-						return true // Setting is enabled
-					}
-					return defaultValue
-				}),
-			})
+			mockGetConfiguration.mockReturnValue(workspaceConfigurationWithOpenTodoCompletionPrevention(true))
 
 			const callbacks: AttemptCompletionCallbacks = {
 				askApproval: mockAskApproval,
@@ -309,14 +297,7 @@ describe("attemptCompletionTool", () => {
 			mockTask.todoList = todosWithPending
 
 			// Ensure the setting is disabled (default behavior)
-			mockGetConfiguration.mockReturnValue({
-				get: vi.fn((key: string, defaultValue: any) => {
-					if (key === "preventCompletionWithOpenTodos") {
-						return false // Setting is disabled
-					}
-					return defaultValue
-				}),
-			})
+			mockGetConfiguration.mockReturnValue(workspaceConfigurationWithOpenTodoCompletionPrevention(false))
 
 			const callbacks: AttemptCompletionCallbacks = {
 				askApproval: mockAskApproval,
@@ -352,14 +333,7 @@ describe("attemptCompletionTool", () => {
 			mockTask.todoList = todosWithPending
 
 			// Enable the setting
-			mockGetConfiguration.mockReturnValue({
-				get: vi.fn((key: string, defaultValue: any) => {
-					if (key === "preventCompletionWithOpenTodos") {
-						return true // Setting is enabled
-					}
-					return defaultValue
-				}),
-			})
+			mockGetConfiguration.mockReturnValue(workspaceConfigurationWithOpenTodoCompletionPrevention(true))
 
 			const callbacks: AttemptCompletionCallbacks = {
 				askApproval: mockAskApproval,
@@ -395,14 +369,7 @@ describe("attemptCompletionTool", () => {
 			mockTask.todoList = completedTodos
 
 			// Enable the setting
-			mockGetConfiguration.mockReturnValue({
-				get: vi.fn((key: string, defaultValue: any) => {
-					if (key === "preventCompletionWithOpenTodos") {
-						return true // Setting is enabled
-					}
-					return defaultValue
-				}),
-			})
+			mockGetConfiguration.mockReturnValue(workspaceConfigurationWithOpenTodoCompletionPrevention(true))
 
 			const callbacks: AttemptCompletionCallbacks = {
 				askApproval: mockAskApproval,

src/core/tools/__tests__/editFileTool.spec.ts

@@ -1,12 +1,12 @@
 import * as path from "path"
 import fs from "fs/promises"
 
-import type { MockedFunction } from "vitest"
+import type { Mock, MockedFunction } from "vitest"
 
 import { fileExistsAtPath } from "../../../utils/fs"
 import { isPathOutsideWorkspace } from "../../../utils/pathUtils"
 import { getReadablePath } from "../../../utils/path"
-import { ToolUse, ToolResponse } from "../../../shared/tools"
+import { AskApproval, HandleError, PushToolResult, ToolUse, ToolResponse } from "../../../shared/tools"
 import { editFileTool } from "../EditFileTool"
 
 vi.mock("fs/promises", () => ({
@@ -88,9 +88,9 @@ describe("editFileTool", () => {
 	const mockedPathIsAbsolute = path.isAbsolute as MockedFunction<typeof path.isAbsolute>
 
 	const mockTask: any = {}
-	let mockAskApproval: ReturnType<typeof vi.fn>
-	let mockHandleError: ReturnType<typeof vi.fn>
-	let mockPushToolResult: ReturnType<typeof vi.fn>
+	let mockAskApproval: Mock<AskApproval>
+	let mockHandleError: Mock<HandleError>
+	let mockPushToolResult: Mock<PushToolResult>
 	let toolResult: ToolResponse | undefined
 
 	beforeEach(() => {
@@ -150,8 +150,8 @@ describe("editFileTool", () => {
 		mockTask.processQueuedMessages = vi.fn()
 		mockTask.sayAndCreateMissingParamError = vi.fn().mockResolvedValue("Missing param error")
 
-		mockAskApproval = vi.fn().mockResolvedValue(true)
-		mockHandleError = vi.fn().mockResolvedValue(undefined)
+		mockAskApproval = vi.fn<AskApproval>().mockResolvedValue(true)
+		mockHandleError = vi.fn<HandleError>().mockResolvedValue(undefined)
 
 		toolResult = undefined
 	})
@@ -203,7 +203,7 @@ describe("editFileTool", () => {
 			partial: isPartial,
 		}
 
-		mockPushToolResult = vi.fn((result: ToolResponse) => {
+		mockPushToolResult = vi.fn<PushToolResult>((result) => {
 			toolResult = result
 		})
 
@@ -280,7 +280,7 @@ describe("editFileTool", () => {
 				}
 
 				let capturedResult: ToolResponse | undefined
-				const localPushToolResult = vi.fn((result: ToolResponse) => {
+				const localPushToolResult = vi.fn<PushToolResult>((result) => {
 					capturedResult = result
 				})
 
@@ -649,7 +649,7 @@ describe("editFileTool", () => {
 			}
 
 			let capturedResult: ToolResponse | undefined
-			const localPushToolResult = vi.fn((result: ToolResponse) => {
+			const localPushToolResult = vi.fn<PushToolResult>((result) => {
 				capturedResult = result
 			})