test: consolidate workspace update fixtures and scenarios

Author: EhabY

test/unit/api/workspace.test.ts

@@ -300,7 +300,7 @@ describe("updateWorkspace", () => {
 		};
 		ctx.workspace = source;
 		restClient.getWorkspace.mockResolvedValue(source);
-		const accepted = {
+		const accepted: WorkspaceBuild = {
 			...ctx.workspace.latest_build,
 			id: "accepted-stop-build",
 			build_number: ctx.workspace.latest_build.build_number + 1,

test/unit/api/workspaceUpdate.test.ts

@@ -14,23 +14,32 @@ import { workspace as createWorkspace } from "@repo/mocks";
 
 import type { WorkspaceBuild } from "coder/site/src/api/typesGenerated";
 
-function setup(status: "running" | "stopped" | "failed" = "running") {
+const parameters = [{ name: "region", value: "east" }];
+const expectedStart = {
+	transition: "start" as const,
+	template_version_id: "target-version",
+	rich_parameter_values: parameters,
+};
+
+function setup(
+	status: "running" | "stopped" = "running",
+	jobStatus: WorkspaceBuild["job"]["status"] = "pending",
+) {
 	const client = new Api();
 	const http = axios.create();
-	vi.spyOn(client, "getAxiosInstance").mockReturnValue(http);
 	const source = createWorkspace({
 		template_active_version_id: "target-version",
 		latest_build: { status, build_number: 1 },
 	});
 	const acceptedBuild: WorkspaceBuild = {
 		...source.latest_build,
 		id: "accepted-build",
-		workspace_id: source.id,
 		build_number: 2,
 		transition: status === "running" ? "stop" : "start",
 		template_version_id: "target-version",
-		job: { ...source.latest_build.job, status: "pending" },
+		job: { ...source.latest_build.job, status: jobStatus },
 	};
+	vi.spyOn(client, "getAxiosInstance").mockReturnValue(http);
 	const getWorkspace = vi
 		.spyOn(client, "getWorkspace")
 		.mockResolvedValue(source);
@@ -40,6 +49,10 @@ function setup(status: "running" | "stopped" | "failed" = "running") {
 	return { client, source, acceptedBuild, getWorkspace, post };
 }
 
+function buildInfo(version: string): Awaited<ReturnType<Api["getBuildInfo"]>> {
+	return { version } as Awaited<ReturnType<Api["getBuildInfo"]>>;
+}
+
 function responseError(status: number): AxiosError {
 	return new AxiosError("request failed", undefined, undefined, undefined, {
 		status,
@@ -68,9 +81,7 @@ describe("server capability and preflight", () => {
 		"does not require template permission for a stopped workspace on %s",
 		async (version) => {
 			const { client, source } = setup("stopped");
-			vi.spyOn(client, "getBuildInfo").mockResolvedValue({ version } as Awaited<
-				ReturnType<Api["getBuildInfo"]>
-			>);
+			vi.spyOn(client, "getBuildInfo").mockResolvedValue(buildInfo(version));
 			const auth = vi.spyOn(client, "checkAuthorization");
 
 			await preflightWorkspaceUpdate(client, source);
@@ -83,9 +94,7 @@ describe("server capability and preflight", () => {
 		"refuses denied or unverifiable permission: %s",
 		async (permission) => {
 			const { client, source, post } = setup();
-			vi.spyOn(client, "getBuildInfo").mockResolvedValue({
-				version: "2.36.0",
-			} as Awaited<ReturnType<Api["getBuildInfo"]>>);
+			vi.spyOn(client, "getBuildInfo").mockResolvedValue(buildInfo("2.36.0"));
 			const auth = vi.spyOn(client, "checkAuthorization");
 			if (permission === "error") auth.mockRejectedValue(new Error("secret"));
 			else auth.mockResolvedValue({ templateUpdate: false });
@@ -99,57 +108,34 @@ describe("server capability and preflight", () => {
 });
 
 describe("pinned update acceptance", () => {
-	it.each(["pending", "succeeded"] as const)(
-		"returns an accepted direct start without waiting for completion: %s",
-		async (jobStatus) => {
-			const { client, source, acceptedBuild, post } = setup("stopped");
-			const accepted = {
-				...acceptedBuild,
-				job: { ...acceptedBuild.job, status: jobStatus },
-			};
-			post.mockResolvedValue({ data: accepted });
+	it.each([
+		["stopped", "pending", { ...expectedStart, reason: "vscode_connection" }],
+		["stopped", "succeeded", { ...expectedStart, reason: "vscode_connection" }],
+		[
+			"running",
+			"pending",
+			{
+				transition: "stop",
+				reason: "vscode_connection",
+				on_success: expectedStart,
+			},
+		],
+	] as const)(
+		"accepts %s workspace update with %s build job",
+		async (status, jobStatus, request) => {
+			const { client, source, acceptedBuild, post } = setup(status, jobStatus);
 
 			await expect(
-				updateWorkspaceWithPinnedBuild(client, source, [
-					{ name: "region", value: "east" },
-				]),
-			).resolves.toEqual({ ...source, latest_build: accepted });
+				updateWorkspaceWithPinnedBuild(client, source, parameters),
+			).resolves.toEqual({ ...source, latest_build: acceptedBuild });
 			expect(post).toHaveBeenCalledExactlyOnceWith(
 				`/api/v2/workspaces/${source.id}/builds`,
-				{
-					transition: "start",
-					template_version_id: "target-version",
-					rich_parameter_values: [{ name: "region", value: "east" }],
-					reason: "vscode_connection",
-				},
+				request,
 				{ signal: undefined, sensitive: true },
 			);
 		},
 	);
 
-	it("queues a pinned restart for a running workspace and returns its accepted stop build", async () => {
-		const { client, source, acceptedBuild, post } = setup();
-
-		await expect(
-			updateWorkspaceWithPinnedBuild(client, source, [
-				{ name: "region", value: "east" },
-			]),
-		).resolves.toEqual({ ...source, latest_build: acceptedBuild });
-		expect(post).toHaveBeenCalledExactlyOnceWith(
-			`/api/v2/workspaces/${source.id}/builds`,
-			{
-				transition: "stop",
-				reason: "vscode_connection",
-				on_success: {
-					transition: "start",
-					template_version_id: "target-version",
-					rich_parameter_values: [{ name: "region", value: "east" }],
-				},
-			},
-			{ signal: undefined, sensitive: true },
-		);
-	});
-
 	it.each(["build", "version"] as const)(
 		"rejects source %s drift before queueing",
 		async (drift) => {
@@ -172,17 +158,12 @@ describe("pinned update acceptance", () => {
 		const { client, source, post } = setup();
 		post.mockRejectedValue(new Error("secret server detail"));
 
-		const error = await updateWorkspaceWithPinnedBuild(
-			client,
-			source,
-			[],
-		).catch((error: unknown) => error);
-
-		expect(error).toBeInstanceOf(WorkspaceUpdateFailedError);
-		expect(error).toHaveProperty(
-			"message",
-			"Workspace update failed or could not be queued safely. Check the workspace in the dashboard before retrying.",
-		);
+		const result = updateWorkspaceWithPinnedBuild(client, source, []);
+		await expect(result).rejects.toBeInstanceOf(WorkspaceUpdateFailedError);
+		await expect(result).rejects.toMatchObject({
+			message:
+				"Workspace update failed or could not be queued safely. Check the workspace in the dashboard before retrying.",
+		});
 		expect(post).toHaveBeenCalledOnce();
 	});
 
@@ -196,27 +177,24 @@ describe("pinned update acceptance", () => {
 		expect(post).toHaveBeenCalledOnce();
 	});
 
-	it("aborts after an accepted request", async () => {
+	it.each([
+		["after an accepted request", true, 1],
+		["before sending a request", false, 0],
+	] as const)("aborts %s", async (_when, abortAfterRequest, requestCount) => {
 		const { client, source, post } = setup();
 		const controller = new AbortController();
-		post.mockImplementation(() => {
+		if (abortAfterRequest) {
+			post.mockImplementation(() => {
+				controller.abort();
+				return Promise.resolve({ data: source.latest_build });
+			});
+		} else {
 			controller.abort();
-			return Promise.resolve({ data: source.latest_build });
-		});
-
-		await expect(
-			updateWorkspaceWithPinnedBuild(client, source, [], controller.signal),
-		).rejects.toMatchObject({ name: "AbortError" });
-		expect(post).toHaveBeenCalledOnce();
-	});
-	it("does not send a request when aborted", async () => {
-		const { client, source, post } = setup();
-		const controller = new AbortController();
-		controller.abort();
+		}
 
 		await expect(
 			updateWorkspaceWithPinnedBuild(client, source, [], controller.signal),
 		).rejects.toMatchObject({ name: "AbortError" });
-		expect(post).not.toHaveBeenCalled();
+		expect(post).toHaveBeenCalledTimes(requestCount);
 	});
 });

test/unit/command/updateWorkspace.telemetry.test.ts

@@ -5,17 +5,13 @@ import {
 	preflightWorkspaceUpdate,
 	WorkspaceUpdateRefusedError,
 } from "@/api/workspaceUpdate";
-import { Commands } from "@/commands";
-import { MementoManager } from "@/core/mementoManager";
 
 import { workspace } from "@repo/mocks";
 
 import { createTelemetryHarness } from "../../mocks/telemetry";
-import { createMockLogger, InMemoryMemento } from "../../mocks/testHelpers";
+import { createTestCommands } from "../../mocks/testHelpers";
 
 import type { CoderApi } from "@/api/coderApi";
-import type { ServiceContainer } from "@/core/container";
-import type { DeploymentManager } from "@/deployment/deploymentManager";
 
 vi.mock("@/api/workspaceUpdate", async (importActual) => {
 	const actual = await importActual<typeof import("@/api/workspaceUpdate")>();
@@ -29,25 +25,9 @@ const UPDATE_ACTION = "Update and Restart";
 
 function setup() {
 	const { sink, service } = createTelemetryHarness();
-	const mementoManager = new MementoManager(new InMemoryMemento());
-	const logger = createMockLogger();
-	const container = {
-		getTelemetryService: () => service,
-		getLogger: () => logger,
-		getPathResolver: () => ({}),
-		getMementoManager: () => mementoManager,
-		getSecretsManager: () => ({}),
-		getCliManager: () => ({}),
-		getLoginCoordinator: () => ({}),
-		getDuplicateWorkspaceIpc: () => ({}),
-		getSpeedtestPanelFactory: () => ({}),
-		getNetcheckPanelFactory: () => ({}),
-	} as unknown as ServiceContainer;
-	const commands = new Commands(
-		container,
-		{} as CoderApi,
-		{} as DeploymentManager,
-	);
+	const commands = createTestCommands({
+		services: { getTelemetryService: service },
+	});
 	commands.workspace = workspace({ outdated: true });
 	commands.remoteWorkspaceClient = {
 		getAxiosInstance: () => ({
@@ -63,67 +43,57 @@ describe("Commands.updateWorkspace", () => {
 		vi.mocked(preflightWorkspaceUpdate).mockResolvedValue(undefined);
 	});
 
-	it("records an aborted update confirmation when the prompt is dismissed", async () => {
-		const { commands, sink } = setup();
-		vi.mocked(vscode.window.showWarningMessage).mockResolvedValue(undefined);
-
-		await commands.updateWorkspace();
-
-		expect(sink.expectOne("workspace.update.prompted")).toMatchObject({
-			properties: {
-				prompt: "confirmation",
-				result: "aborted",
-			},
-		});
-		expect(vscode.commands.executeCommand).not.toHaveBeenCalled();
-	});
+	it.each([
+		{ choice: undefined, result: "aborted", properties: {} },
+		{
+			choice: UPDATE_ACTION,
+			result: "success",
+			properties: { action: "update" },
+		},
+	])(
+		"records $result when confirmation returns $choice",
+		async ({ choice, result, properties }) => {
+			const { commands, sink } = setup();
+			vi.mocked(vscode.window.showWarningMessage).mockResolvedValue(
+				choice as never,
+			);
+			await commands.updateWorkspace();
+			expect(sink.expectOne("workspace.update.prompted")).toMatchObject({
+				properties: { prompt: "confirmation", result, ...properties },
+			});
+			if (choice) {
+				expect(vscode.commands.executeCommand).toHaveBeenCalledWith(
+					"workbench.action.reloadWindow",
+				);
+			} else {
+				expect(vscode.commands.executeCommand).not.toHaveBeenCalled();
+			}
+		},
+	);
 
-	it("records success and reloads when the update confirmation is accepted", async () => {
+	it("refuses an unauthorized pinned update before confirmation or reload", async () => {
 		const { commands, sink } = setup();
-		vi.mocked(vscode.window.showWarningMessage).mockResolvedValue(
-			UPDATE_ACTION as never,
+		vi.mocked(preflightWorkspaceUpdate).mockRejectedValueOnce(
+			new WorkspaceUpdateRefusedError("Cannot pin this update"),
 		);
-
+		vi.mocked(vscode.window.showWarningMessage).mockResolvedValue(undefined);
 		await commands.updateWorkspace();
-
-		expect(sink.expectOne("workspace.update.prompted")).toMatchObject({
-			properties: {
-				action: "update",
-				prompt: "confirmation",
-				result: "success",
-			},
-		});
-		expect(vscode.commands.executeCommand).toHaveBeenCalledWith(
-			"workbench.action.reloadWindow",
+		expect(vscode.window.showWarningMessage).toHaveBeenLastCalledWith(
+			"Cannot pin this update",
+			"Open in Dashboard",
 		);
+		expect(vscode.commands.executeCommand).not.toHaveBeenCalled();
+		expect(sink.events).toHaveLength(0);
 	});
-});
-
-it("refuses an unauthorized pinned update before confirmation or reload", async () => {
-	const { commands, sink } = setup();
-	vi.mocked(preflightWorkspaceUpdate).mockRejectedValueOnce(
-		new WorkspaceUpdateRefusedError("Cannot pin this update"),
-	);
-	vi.mocked(vscode.window.showWarningMessage).mockResolvedValue(undefined);
-	vi.mocked(vscode.commands.executeCommand).mockClear();
-	await commands.updateWorkspace();
-	expect(vscode.window.showWarningMessage).toHaveBeenLastCalledWith(
-		"Cannot pin this update",
-		"Open in Dashboard",
-	);
-	expect(vscode.commands.executeCommand).not.toHaveBeenCalled();
-	expect(sink.events).toHaveLength(0);
-});
 
-it("does not continue after disconnect during preflight", async () => {
-	const { commands } = setup();
-	vi.mocked(preflightWorkspaceUpdate).mockImplementationOnce(() => {
-		commands.workspace = undefined;
-		return Promise.resolve();
+	it("does not continue after disconnect during preflight", async () => {
+		const { commands } = setup();
+		vi.mocked(preflightWorkspaceUpdate).mockImplementationOnce(() => {
+			commands.workspace = undefined;
+			return Promise.resolve();
+		});
+		await commands.updateWorkspace();
+		expect(vscode.commands.executeCommand).not.toHaveBeenCalled();
+		expect(vscode.window.showWarningMessage).not.toHaveBeenCalled();
 	});
-	vi.mocked(vscode.commands.executeCommand).mockClear();
-	vi.mocked(vscode.window.showWarningMessage).mockClear();
-	await commands.updateWorkspace();
-	expect(vscode.commands.executeCommand).not.toHaveBeenCalled();
-	expect(vscode.window.showWarningMessage).not.toHaveBeenCalled();
 });