fix changes from initial PR, add importing using ClineProvider, revise

tests

Author: takakoutso

apps/vscode-e2e/src/types/global.d.ts

@@ -1,7 +1,6 @@
 import type { RooCodeAPI } from "@roo-code/types"
 
 declare global {
-	// eslint-disable-next-line no-var
 	var api: RooCodeAPI
 }
 

src/extension.ts

@@ -114,8 +114,7 @@ export async function activate(context: vscode.ExtensionContext) {
 	// Auto-import configuration if specified in settings
 	try {
 		await autoImportConfig({
-			providerSettingsManager: provider.providerSettingsManager,
-			contextProxy,
+			provider,
 			customModesManager: provider.customModesManager,
 			outputChannel,
 		})

src/utils/__tests__/autoImportConfig.spec.ts

@@ -12,10 +12,13 @@ vi.mock("vscode", () => ({
 }))
 
 vi.mock("fs/promises", () => ({
+	__esModule: true,
 	default: {
-		readFile: vi.fn(),
+		readFile: vi.fn(), // This will be fs.default.readFile for the test
+		// If other default export properties are used by SUT, mock them here
 	},
-	readFile: vi.fn(),
+	// If SUT or tests use named exports from "fs/promises" (e.g. import { stat } from "fs/promises")
+	readFile: vi.fn(), // Example for a named export
 }))
 
 vi.mock("path", () => ({
@@ -32,20 +35,46 @@ vi.mock("../fs", () => ({
 	fileExistsAtPath: vi.fn(),
 }))
 
-vi.mock("../../core/config/ProviderSettingsManager")
+vi.mock("../../core/config/ProviderSettingsManager", async (importOriginal) => {
+	const originalModule = await importOriginal()
+	return {
+		// @ts-expect-error - we are overriding the type with a partial mock
+		__esModule: true,
+		// We need to mock the class constructor and its methods,
+		// but keep other exports (like schemas) as their original values.
+		// @ts-expect-error - we are overriding the type with a partial mock
+		...(originalModule || {}), // Spread original exports
+		ProviderSettingsManager: vi.fn().mockImplementation(() => ({
+			// Mock the class
+			export: vi.fn().mockResolvedValue({
+				apiConfigs: {},
+				modeApiConfigs: {},
+				currentApiConfigName: "default",
+			}),
+			import: vi.fn().mockResolvedValue({ success: true }),
+			listConfig: vi.fn().mockResolvedValue([]),
+			// Add other methods of ProviderSettingsManager here if they are called
+		})),
+		// Ensure providerProfilesSchema is the actual schema, not a mock fn
+		// If providerProfilesSchema is exported from this module, it will be retained by the spread.
+		// If it's a named export and you want to be explicit:
+		// providerProfilesSchema: (originalModule as any).providerProfilesSchema,
+	}
+})
 vi.mock("../../core/config/ContextProxy")
 vi.mock("../../core/config/CustomModesManager")
 
 import { autoImportConfig } from "../autoImportConfig"
 import * as vscode from "vscode"
-import * as fs from "fs/promises"
+import fsPromises from "fs/promises" // Changed from * as fs
 import { fileExistsAtPath } from "../fs"
 
 describe("autoImportConfig", () => {
 	let mockProviderSettingsManager: any
 	let mockContextProxy: any
 	let mockCustomModesManager: any
 	let mockOutputChannel: any
+	let mockProvider: any
 
 	beforeEach(() => {
 		// Reset all mocks
@@ -63,7 +92,7 @@ describe("autoImportConfig", () => {
 				modeApiConfigs: {},
 				currentApiConfigName: "default",
 			}),
-			import: vi.fn().mockResolvedValue(undefined),
+			import: vi.fn().mockResolvedValue({ success: true }), // Changed to return an object
 			listConfig: vi.fn().mockResolvedValue([]),
 		}
 
@@ -79,8 +108,17 @@ describe("autoImportConfig", () => {
 			updateCustomMode: vi.fn().mockResolvedValue(undefined),
 		}
 
+		// mockProvider must be initialized AFTER its dependencies
+		mockProvider = {
+			providerSettingsManager: mockProviderSettingsManager,
+			contextProxy: mockContextProxy, // Now mockContextProxy is defined
+			upsertProviderProfile: vi.fn().mockResolvedValue({ success: true }), // Return an object
+			postStateToWebview: vi.fn().mockResolvedValue({ success: true }), // Return an object
+			// settingsImportedAt will be set directly by the SUT
+		}
+
 		// Reset fs mock
-		vi.mocked(fs.readFile).mockReset()
+		vi.mocked(fsPromises.readFile).mockReset()
 		vi.mocked(fileExistsAtPath).mockReset()
 		vi.mocked(vscode.workspace.getConfiguration).mockReset()
 		vi.mocked(vscode.window.showInformationMessage).mockReset()
@@ -97,8 +135,7 @@ describe("autoImportConfig", () => {
 		} as any)
 
 		await autoImportConfig({
-			providerSettingsManager: mockProviderSettingsManager,
-			contextProxy: mockContextProxy,
+			provider: mockProvider,
 			customModesManager: mockCustomModesManager,
 			outputChannel: mockOutputChannel,
 		})
@@ -119,8 +156,7 @@ describe("autoImportConfig", () => {
 		vi.mocked(fileExistsAtPath).mockResolvedValue(false)
 
 		await autoImportConfig({
-			providerSettingsManager: mockProviderSettingsManager,
-			contextProxy: mockContextProxy,
+			provider: mockProvider,
 			customModesManager: mockCustomModesManager,
 			outputChannel: mockOutputChannel,
 		})
@@ -153,17 +189,17 @@ describe("autoImportConfig", () => {
 						anthropicApiKey: "test-key",
 					},
 				},
-				modeApiConfigs: {},
 			},
 			globalSettings: {
 				customInstructions: "Test instructions",
 			},
 		}
-		vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockConfig) as any)
+		// The SUT uses `import fs from "fs/promises"`, then `fs.readFile`.
+		// In the test, `import * as fs` means this is `fs.default.readFile`.
+		vi.mocked(fsPromises.readFile).mockResolvedValue(JSON.stringify(mockConfig) as any)
 
 		await autoImportConfig({
-			providerSettingsManager: mockProviderSettingsManager,
-			contextProxy: mockContextProxy,
+			provider: mockProvider,
 			customModesManager: mockCustomModesManager,
 			outputChannel: mockOutputChannel,
 		})
@@ -191,11 +227,10 @@ describe("autoImportConfig", () => {
 		vi.mocked(fileExistsAtPath).mockResolvedValue(true)
 
 		// Mock fs.readFile to return invalid JSON
-		vi.mocked(fs.readFile).mockResolvedValue("invalid json" as any)
+		vi.mocked(fsPromises.readFile).mockResolvedValue("invalid json" as any)
 
 		await autoImportConfig({
-			providerSettingsManager: mockProviderSettingsManager,
-			contextProxy: mockContextProxy,
+			provider: mockProvider,
 			customModesManager: mockCustomModesManager,
 			outputChannel: mockOutputChannel,
 		})
@@ -219,8 +254,7 @@ describe("autoImportConfig", () => {
 		vi.mocked(fileExistsAtPath).mockResolvedValue(false)
 
 		await autoImportConfig({
-			providerSettingsManager: mockProviderSettingsManager,
-			contextProxy: mockContextProxy,
+			provider: mockProvider,
 			customModesManager: mockCustomModesManager,
 			outputChannel: mockOutputChannel,
 		})
@@ -240,8 +274,7 @@ describe("autoImportConfig", () => {
 		vi.mocked(fileExistsAtPath).mockResolvedValue(false)
 
 		await autoImportConfig({
-			providerSettingsManager: mockProviderSettingsManager,
-			contextProxy: mockContextProxy,
+			provider: mockProvider,
 			customModesManager: mockCustomModesManager,
 			outputChannel: mockOutputChannel,
 		})
@@ -261,8 +294,7 @@ describe("autoImportConfig", () => {
 		vi.mocked(fileExistsAtPath).mockRejectedValue(new Error("File system error"))
 
 		await autoImportConfig({
-			providerSettingsManager: mockProviderSettingsManager,
-			contextProxy: mockContextProxy,
+			provider: mockProvider,
 			customModesManager: mockCustomModesManager,
 			outputChannel: mockOutputChannel,
 		})

src/utils/autoImportConfig.ts

@@ -7,14 +7,15 @@ import { z, ZodError } from "zod"
 import { globalSettingsSchema } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
-import { ProviderSettingsManager, providerProfilesSchema } from "../core/config/ProviderSettingsManager"
-import { ContextProxy } from "../core/config/ContextProxy"
+import { Package } from "../shared/package"
+import { ClineProvider } from "../core/webview/ClineProvider"
+
+import { providerProfilesSchema } from "../core/config/ProviderSettingsManager"
 import { CustomModesManager } from "../core/config/CustomModesManager"
 import { fileExistsAtPath } from "./fs"
 
 type AutoImportOptions = {
-	providerSettingsManager: ProviderSettingsManager
-	contextProxy: ContextProxy
+	provider: ClineProvider
 	customModesManager: CustomModesManager
 	outputChannel: vscode.OutputChannel
 }
@@ -25,14 +26,13 @@ type AutoImportOptions = {
  * their settings by placing a config file at a predefined location.
  */
 export async function autoImportConfig({
-	providerSettingsManager,
-	contextProxy,
+	provider,
 	customModesManager,
 	outputChannel,
 }: AutoImportOptions): Promise<void> {
 	try {
 		// Get the auto-import config path from VSCode settings
-		const configPath = vscode.workspace.getConfiguration("roo-cline").get<string>("autoImportConfigPath")
+		const configPath = vscode.workspace.getConfiguration(Package.name).get<string>("autoImportConfigPath")
 
 		if (!configPath || configPath.trim() === "") {
 			outputChannel.appendLine("[AutoImport] No auto-import config path specified, skipping auto-import")
@@ -51,8 +51,7 @@ export async function autoImportConfig({
 
 		// Attempt to import the configuration
 		const result = await importConfigFromPath(resolvedPath, {
-			providerSettingsManager,
-			contextProxy,
+			provider,
 			customModesManager,
 		})
 
@@ -103,18 +102,21 @@ function resolvePath(configPath: string): string {
  */
 async function importConfigFromPath(
 	filePath: string,
-	{ providerSettingsManager, contextProxy, customModesManager }: Omit<AutoImportOptions, "outputChannel">,
+	{ provider, customModesManager }: Omit<AutoImportOptions, "outputChannel">,
 ): Promise<{ success: boolean; error?: string }> {
-	const schema = z.object({
-		providerProfiles: providerProfilesSchema,
-		globalSettings: globalSettingsSchema.optional(),
-	})
-
 	try {
+		const { providerSettingsManager, contextProxy } = provider
+
+		const schema = z.object({
+			providerProfiles: providerProfilesSchema,
+			globalSettings: globalSettingsSchema,
+		})
+
 		const previousProviderProfiles = await providerSettingsManager.export()
 
-		const data = JSON.parse(await fs.readFile(filePath, "utf-8"))
-		const { providerProfiles: newProviderProfiles, globalSettings = {} } = schema.parse(data)
+		const { providerProfiles: newProviderProfiles, globalSettings } = schema.parse(
+			JSON.parse(await fs.readFile(filePath, "utf-8")),
+		)
 
 		const providerProfiles = {
 			currentApiConfigName: newProviderProfiles.currentApiConfigName,
@@ -135,16 +137,15 @@ async function importConfigFromPath(
 		await providerSettingsManager.import(newProviderProfiles)
 		await contextProxy.setValues(globalSettings)
 
-		// Set the current provider
-		const currentProviderName = providerProfiles.currentApiConfigName
-		const currentProvider = providerProfiles.apiConfigs[currentProviderName]
-		contextProxy.setValue("currentApiConfigName", currentProviderName)
+		const listApiConfigMetaResult = await providerSettingsManager.listConfig()
+		contextProxy.setValue("currentApiConfigName", providerProfiles.currentApiConfigName)
+		contextProxy.setValue("listApiConfigMeta", listApiConfigMetaResult)
 
-		if (currentProvider) {
-			contextProxy.setProviderSettings(currentProvider)
-		}
+		const apiConfiguration = newProviderProfiles.apiConfigs[newProviderProfiles.currentApiConfigName]
+		await provider.upsertProviderProfile(newProviderProfiles.currentApiConfigName, apiConfiguration)
 
-		contextProxy.setValue("listApiConfigMeta", await providerSettingsManager.listConfig())
+		provider.settingsImportedAt = Date.now()
+		await provider.postStateToWebview()
 
 		return { success: true }
 	} catch (e) {