test(code-index,tools): cover lines left uncovered by #1297

src/core/tools/__tests__/generateImageTool.test.ts

@@ -6,6 +6,7 @@ import * as fs from "fs/promises"
 import * as pathUtils from "../../../utils/pathUtils"
 import * as fileUtils from "../../../utils/fs"
 import { formatResponse } from "../../prompts/responses"
+import { t } from "../../../i18n"
 import { EXPERIMENT_IDS } from "../../../shared/experiments"
 import { OpenRouterHandler } from "../../../api/providers/openrouter"
 
@@ -369,4 +370,43 @@ describe("generateImageTool", () => {
 			expect(mockPushToolResult).toHaveBeenCalledWith(expect.stringContaining("Unsupported image format"))
 		})
 	})
+
+	describe("openrouter api key validation", () => {
+		it("should error when the OpenRouter API key is not configured", async () => {
+			// An OpenRouter image model is selected but no API key is configured
+			mockCline.providerRef.deref().getState.mockResolvedValue({
+				experiments: {
+					[EXPERIMENT_IDS.IMAGE_GENERATION]: true,
+				},
+				openRouterImageGenerationSelectedModel: "google/gemini-2.5-flash-image",
+			})
+
+			const block: ToolUse = {
+				type: "tool_use",
+				name: "generate_image",
+				params: {
+					prompt: "Generate a test image",
+					path: "test-image.png",
+				},
+				nativeArgs: {
+					prompt: "Generate a test image",
+					path: "test-image.png",
+				},
+				partial: false,
+			}
+
+			await generateImageTool.handle(mockCline as Task, block as ToolUse<"generate_image">, {
+				askApproval: mockAskApproval,
+				handleError: mockHandleError,
+				pushToolResult: mockPushToolResult,
+			})
+
+			const expectedMessage = t("tools:generateImage.openRouterApiKeyRequired")
+			expect(mockCline.say).toHaveBeenCalledWith("error", expectedMessage)
+			expect(mockPushToolResult).toHaveBeenCalledWith(formatResponse.toolError(expectedMessage))
+			// The tool must stop before asking for approval or generating anything
+			expect(mockAskApproval).not.toHaveBeenCalled()
+			expect(OpenRouterHandler).not.toHaveBeenCalled()
+		})
+	})
 })

src/services/code-index/__tests__/config-manager.spec.ts

@@ -2035,4 +2035,132 @@ describe("CodeIndexConfigManager", () => {
 			})
 		})
 	})
+
+	describe("mistral, vercel-ai-gateway and bedrock provider configuration", () => {
+		it("should load Mistral provider configuration and mark it configured", async () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://qdrant.local",
+				codebaseIndexEmbedderProvider: providerIdentifiers.mistral,
+			})
+			mockContextProxy.getSecret.mockImplementation((key: string) => {
+				if (key === "codebaseIndexMistralApiKey") return "test-mistral-key"
+				return undefined
+			})
+
+			const result = await configManager.loadConfiguration()
+
+			expect(result.currentConfig.embedderProvider).toBe(providerIdentifiers.mistral)
+			expect(result.currentConfig.mistralOptions).toEqual({ apiKey: "test-mistral-key" })
+			expect(result.currentConfig.isConfigured).toBe(true)
+			expect(configManager.currentEmbedderProvider).toBe("mistral")
+		})
+
+		it("should return false from isConfigured for Mistral when the API key is missing", () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://qdrant.local",
+				codebaseIndexEmbedderProvider: providerIdentifiers.mistral,
+			})
+			mockContextProxy.getSecret.mockReturnValue(undefined)
+
+			configManager = new CodeIndexConfigManager(mockContextProxy)
+			expect(configManager.isConfigured()).toBe(false)
+		})
+
+		it("should load Vercel AI Gateway provider configuration and mark it configured", async () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://qdrant.local",
+				codebaseIndexEmbedderProvider: providerIdentifiers.vercelAiGateway,
+			})
+			mockContextProxy.getSecret.mockImplementation((key: string) => {
+				if (key === "codebaseIndexVercelAiGatewayApiKey") return "test-vercel-key"
+				return undefined
+			})
+
+			const result = await configManager.loadConfiguration()
+
+			expect(result.currentConfig.embedderProvider).toBe(providerIdentifiers.vercelAiGateway)
+			expect(result.currentConfig.vercelAiGatewayOptions).toEqual({ apiKey: "test-vercel-key" })
+			expect(result.currentConfig.isConfigured).toBe(true)
+			expect(configManager.currentEmbedderProvider).toBe("vercel-ai-gateway")
+		})
+
+		it("should return false from isConfigured for Vercel AI Gateway when the API key is missing", () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://qdrant.local",
+				codebaseIndexEmbedderProvider: providerIdentifiers.vercelAiGateway,
+			})
+			mockContextProxy.getSecret.mockReturnValue(undefined)
+
+			configManager = new CodeIndexConfigManager(mockContextProxy)
+			expect(configManager.isConfigured()).toBe(false)
+		})
+
+		it("should load Bedrock provider configuration with region and profile and mark it configured", async () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://qdrant.local",
+				codebaseIndexEmbedderProvider: providerIdentifiers.bedrock,
+				codebaseIndexBedrockRegion: "eu-west-1",
+				codebaseIndexBedrockProfile: "test-profile",
+			})
+			mockContextProxy.getSecret.mockReturnValue(undefined)
+
+			const result = await configManager.loadConfiguration()
+
+			expect(result.currentConfig.embedderProvider).toBe(providerIdentifiers.bedrock)
+			expect(result.currentConfig.bedrockOptions).toEqual({ region: "eu-west-1", profile: "test-profile" })
+			expect(result.currentConfig.isConfigured).toBe(true)
+			expect(configManager.currentEmbedderProvider).toBe("bedrock")
+		})
+
+		it("should default Bedrock region to us-east-1 when no region is configured", async () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://qdrant.local",
+				codebaseIndexEmbedderProvider: providerIdentifiers.bedrock,
+			})
+			mockContextProxy.getSecret.mockReturnValue(undefined)
+
+			const result = await configManager.loadConfiguration()
+
+			expect(result.currentConfig.bedrockOptions).toEqual({ region: "us-east-1", profile: undefined })
+			expect(result.currentConfig.isConfigured).toBe(true)
+		})
+
+		it("should return false from isConfigured for Bedrock when the Qdrant URL is missing", () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexEmbedderProvider: providerIdentifiers.bedrock,
+				codebaseIndexBedrockRegion: "us-east-1",
+			})
+			mockContextProxy.getSecret.mockReturnValue(undefined)
+
+			configManager = new CodeIndexConfigManager(mockContextProxy)
+			expect(configManager.isConfigured()).toBe(false)
+		})
+	})
+
+	describe("isConfigured defensive fallback", () => {
+		it("should return false when the provider is not a recognized embedder provider", () => {
+			// The isConfigured() switch lists every EmbedderProvider member explicitly and
+			// ends in a defensive `return false` ("Should not happen if embedderProvider is
+			// always set correctly"). That fallback is unreachable through the public API
+			// because EmbedderProvider is a closed union, so exercise it by forcing the
+			// private field to a value outside the union.
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+			})
+			mockContextProxy.getSecret.mockReturnValue(undefined)
+
+			configManager = new CodeIndexConfigManager(mockContextProxy)
+			// The private `embedderProvider` field has no public setter; the cast is the
+			// only way to reach the defensive branch without changing source logic.
+			Object.defineProperty(configManager, "embedderProvider", { value: "not-a-provider" })
+			expect(configManager.isConfigured()).toBe(false)
+		})
+	})
 })