Add tests for deployment management

Author: EhabY

test/mocks/testHelpers.ts

@@ -1,8 +1,11 @@
-import { type IncomingMessage } from "node:http";
 import { vi } from "vitest";
 import * as vscode from "vscode";
 
-import { type Logger } from "@/logging/logger";
+import type { User } from "coder/site/src/api/typesGenerated";
+import type { IncomingMessage } from "node:http";
+
+import type { CoderApi } from "@/api/coderApi";
+import type { Logger } from "@/logging/logger";
 
 /**
  * Mock configuration provider that integrates with the vscode workspace configuration mock.
@@ -137,24 +140,42 @@ export class MockProgressReporter {
 }
 
 /**
- * Mock user interaction that integrates with vscode.window message dialogs.
+ * Mock user interaction that integrates with vscode.window message dialogs and input boxes.
  * Use this to control user responses in tests.
  */
 export class MockUserInteraction {
 	private readonly responses = new Map<string, string | undefined>();
+	private inputBoxValue: string | undefined;
+	private inputBoxValidateInput: ((value: string) => Promise<void>) | undefined;
 	private externalUrls: string[] = [];
 
 	constructor() {
 		this.setupVSCodeMock();
 	}
 
 	/**
-	 * Set a response for a specific message
+	 * Set a response for a specific message dialog
 	 */
 	setResponse(message: string, response: string | undefined): void {
 		this.responses.set(message, response);
 	}
 
+	/**
+	 * Set the value to return from showInputBox.
+	 * Pass undefined to simulate user cancelling.
+	 */
+	setInputBoxValue(value: string | undefined): void {
+		this.inputBoxValue = value;
+	}
+
+	/**
+	 * Set a custom validateInput handler for showInputBox.
+	 * This allows tests to simulate the validation callback behavior.
+	 */
+	setInputBoxValidateInput(fn: (value: string) => Promise<void>): void {
+		this.inputBoxValidateInput = fn;
+	}
+
 	/**
 	 * Get all URLs that were opened externally
 	 */
@@ -170,10 +191,13 @@ export class MockUserInteraction {
 	}
 
 	/**
-	 * Clear all responses
+	 * Clear all responses and input box values
 	 */
-	clearResponses(): void {
+	clear(): void {
 		this.responses.clear();
+		this.inputBoxValue = undefined;
+		this.inputBoxValidateInput = undefined;
+		this.externalUrls = [];
 	}
 
 	/**
@@ -206,6 +230,32 @@ export class MockUserInteraction {
 				return Promise.resolve(true);
 			},
 		);
+
+		vi.mocked(vscode.window.showInputBox).mockImplementation(
+			async (options?: vscode.InputBoxOptions) => {
+				const value = this.inputBoxValue;
+				if (value === undefined) {
+					return undefined; // User cancelled
+				}
+
+				if (options?.validateInput) {
+					const validationResult = await options.validateInput(value);
+					if (validationResult) {
+						// Validation failed - in real VS Code this would show error
+						// For tests, we can use the custom handler or return undefined
+						if (this.inputBoxValidateInput) {
+							await this.inputBoxValidateInput(value);
+						}
+						return undefined;
+					}
+				} else if (this.inputBoxValidateInput) {
+					// Run custom validation handler even without options.validateInput
+					await this.inputBoxValidateInput(value);
+				}
+
+				return value;
+			},
+		);
 	}
 }
 
@@ -399,3 +449,93 @@ export class MockStatusBar {
 		);
 	}
 }
+
+/**
+ * Mock CoderApi for testing. Tracks method calls and allows controlling responses.
+ */
+export class MockCoderApi
+	implements
+		Pick<
+			CoderApi,
+			| "setHost"
+			| "setSessionToken"
+			| "setCredentials"
+			| "getAuthenticatedUser"
+			| "dispose"
+		>
+{
+	private _host: string | undefined;
+	private _token: string | undefined;
+	private authenticatedUser: User | Error | undefined;
+
+	readonly setHost = vi.fn((host: string | undefined) => {
+		this._host = host;
+	});
+
+	readonly setSessionToken = vi.fn((token: string) => {
+		this._token = token;
+	});
+
+	readonly setCredentials = vi.fn(
+		(host: string | undefined, token: string | undefined) => {
+			this._host = host;
+			this._token = token;
+		},
+	);
+
+	readonly getAuthenticatedUser = vi.fn((): Promise<User> => {
+		if (this.authenticatedUser instanceof Error) {
+			return Promise.reject(this.authenticatedUser);
+		}
+		if (!this.authenticatedUser) {
+			return Promise.reject(new Error("Not authenticated"));
+		}
+		return Promise.resolve(this.authenticatedUser);
+	});
+
+	readonly dispose = vi.fn();
+
+	/**
+	 * Get current host (for assertions)
+	 */
+	get host(): string | undefined {
+		return this._host;
+	}
+
+	/**
+	 * Get current token (for assertions)
+	 */
+	get token(): string | undefined {
+		return this._token;
+	}
+
+	/**
+	 * Set the authenticated user that will be returned by getAuthenticatedUser.
+	 * Pass an Error to make getAuthenticatedUser reject.
+	 */
+	setAuthenticatedUserResponse(user: User | Error | undefined): void {
+		this.authenticatedUser = user;
+	}
+}
+
+/**
+ * Create a mock User for testing.
+ */
+export function createMockUser(overrides: Partial<User> = {}): User {
+	return {
+		id: "user-123",
+		username: "testuser",
+		email: "[email protected]",
+		name: "Test User",
+		created_at: new Date().toISOString(),
+		updated_at: new Date().toISOString(),
+		last_seen_at: new Date().toISOString(),
+		status: "active",
+		organization_ids: [],
+		roles: [],
+		avatar_url: "",
+		login_type: "password",
+		theme_preference: "",
+		...overrides,
+	};
+}

test/unit/api/coderApi.test.ts

@@ -557,6 +557,42 @@ describe("CoderApi", () => {
 			);
 		});
 	});
+
+	describe("getHost/getSessionToken", () => {
+		it("returns current host and token", () => {
+			const api = createApi(CODER_URL, AXIOS_TOKEN);
+
+			expect(api.getHost()).toBe(CODER_URL);
+			expect(api.getSessionToken()).toBe(AXIOS_TOKEN);
+		});
+	});
+
+	describe("dispose", () => {
+		it("disposes all tracked reconnecting sockets", async () => {
+			const sockets: Array<Partial<Ws>> = [];
+			vi.mocked(Ws).mockImplementation((url: string | URL) => {
+				const mockWs = createMockWebSocket(String(url), {
+					on: vi.fn((event, handler) => {
+						if (event === "open") {
+							setImmediate(() => handler());
+						}
+						return mockWs as Ws;
+					}),
+				});
+				sockets.push(mockWs);
+				return mockWs as Ws;
+			});
+
+			api = createApi(CODER_URL, AXIOS_TOKEN);
+			await api.watchAgentMetadata(AGENT_ID);
+			expect(sockets).toHaveLength(1);
+
+			api.dispose();
+
+			// Socket should be closed
+			expect(sockets[0].close).toHaveBeenCalled();
+		});
+	});
 });
 
 const mockAdapterImpl = vi.hoisted(() => (config: Record<string, unknown>) => {

test/unit/core/secretsManager.test.ts

@@ -200,4 +200,74 @@ describe("SecretsManager", () => {
 			expect(result).toBeNull();
 		});
 	});
+
+	describe("migrateFromLegacyStorage", () => {
+		it("migrates legacy url/token to new format and sets current deployment", async () => {
+			// Set up legacy storage
+			await memento.update("url", "https://legacy.coder.com");
+			await secretStorage.store("sessionToken", "legacy-token");
+
+			const result = await secretsManager.migrateFromLegacyStorage();
+
+			// Should return the migrated hostname
+			expect(result).toBe("legacy.coder.com");
+
+			// Should have migrated to new format
+			const auth = await secretsManager.getSessionAuth("legacy.coder.com");
+			expect(auth?.url).toBe("https://legacy.coder.com");
+			expect(auth?.token).toBe("legacy-token");
+
+			// Should have set current deployment
+			const deployment = await secretsManager.getCurrentDeployment();
+			expect(deployment?.url).toBe("https://legacy.coder.com");
+			expect(deployment?.safeHostname).toBe("legacy.coder.com");
+
+			// Legacy keys should be cleared
+			expect(memento.get("url")).toBeUndefined();
+			expect(await secretStorage.get("sessionToken")).toBeUndefined();
+		});
+
+		it("does not overwrite existing session auth", async () => {
+			// Set up existing auth
+			await secretsManager.setSessionAuth("existing.coder.com", {
+				url: "https://existing.coder.com",
+				token: "existing-token",
+			});
+
+			// Set up legacy storage with same hostname
+			await memento.update("url", "https://existing.coder.com");
+			await secretStorage.store("sessionToken", "legacy-token");
+
+			await secretsManager.migrateFromLegacyStorage();
+
+			// Existing auth should not be overwritten
+			const auth = await secretsManager.getSessionAuth("existing.coder.com");
+			expect(auth?.token).toBe("existing-token");
+		});
+
+		it("returns undefined when no legacy data exists", async () => {
+			const result = await secretsManager.migrateFromLegacyStorage();
+			expect(result).toBeUndefined();
+		});
+
+		it("returns undefined when only URL exists (no token)", async () => {
+			await memento.update("url", "https://legacy.coder.com");
+
+			const result = await secretsManager.migrateFromLegacyStorage();
+			expect(result).toBeUndefined();
+		});
+	});
+
+	describe("session auth - empty token handling (mTLS)", () => {
+		it("stores and retrieves empty string token", async () => {
+			await secretsManager.setSessionAuth("mtls.coder.com", {
+				url: "https://mtls.coder.com",
+				token: "",
+			});
+
+			const auth = await secretsManager.getSessionAuth("mtls.coder.com");
+			expect(auth?.token).toBe("");
+			expect(auth?.url).toBe("https://mtls.coder.com");
+		});
+	});
 });