refactor: simplify shared workspaces provider and tests

- collapse per-query branches into a readonly WORKSPACE_QUERY_CONFIG table
- drop the unreachable re-entry branch in the workspace refresh loop
- remove test-only getCurrentUserId; tests read getSnapshot via a helper
- extract the repeated tree-view wiring in extension.ts into a helper
- drive metadata tests through the real watcher over MockEventStream
- move shared test doubles (session, workspaces client, flush) into testHelpers
- replace describe-scoped state + beforeEach/afterEach with a setup() helper

Author: EhabY

src/deployment/deploymentManager.ts

@@ -109,12 +109,6 @@ export class DeploymentManager
 		return this.#session.deployment;
 	}
 
-	public getCurrentUserId(): string | undefined {
-		return this.#session.kind === "signedIn"
-			? this.#session.user.id
-			: undefined;
-	}
-
 	public getSnapshot(): WorkspaceSessionSnapshot {
 		if (this.#session.kind === "signedIn") {
 			return {

src/extension.ts

@@ -188,44 +188,28 @@ async function doActivate(
 
 	// createTreeView, unlike registerTreeDataProvider, gives us the tree view API
 	// (so we can see when it is visible) but otherwise they have the same effect.
-	const myWsTree = vscode.window.createTreeView(MY_WORKSPACES_TREE_ID, {
-		treeDataProvider: myWorkspacesProvider,
-	});
-	ctx.subscriptions.push(myWsTree);
-	myWorkspacesProvider.setVisibility(myWsTree.visible);
-	myWsTree.onDidChangeVisibility(
-		(event) => {
-			myWorkspacesProvider.setVisibility(event.visible);
-		},
-		undefined,
-		ctx.subscriptions,
-	);
-
-	const sharedWsTree = vscode.window.createTreeView(SHARED_WORKSPACES_TREE_ID, {
-		treeDataProvider: sharedWorkspacesProvider,
-	});
-	ctx.subscriptions.push(sharedWsTree);
-	sharedWorkspacesProvider.setVisibility(sharedWsTree.visible);
-	sharedWsTree.onDidChangeVisibility(
-		(event) => {
-			sharedWorkspacesProvider.setVisibility(event.visible);
-		},
-		undefined,
-		ctx.subscriptions,
-	);
+	const registerWorkspaceTreeView = (
+		viewId: string,
+		provider: WorkspaceProvider,
+	) => {
+		const tree = vscode.window.createTreeView(viewId, {
+			treeDataProvider: provider,
+		});
+		ctx.subscriptions.push(tree);
+		provider.setVisibility(tree.visible);
+		tree.onDidChangeVisibility(
+			(event) => provider.setVisibility(event.visible),
+			undefined,
+			ctx.subscriptions,
+		);
+	};
 
-	const allWsTree = vscode.window.createTreeView(ALL_WORKSPACES_TREE_ID, {
-		treeDataProvider: allWorkspacesProvider,
-	});
-	ctx.subscriptions.push(allWsTree);
-	allWorkspacesProvider.setVisibility(allWsTree.visible);
-	allWsTree.onDidChangeVisibility(
-		(event) => {
-			allWorkspacesProvider.setVisibility(event.visible);
-		},
-		undefined,
-		ctx.subscriptions,
+	registerWorkspaceTreeView(MY_WORKSPACES_TREE_ID, myWorkspacesProvider);
+	registerWorkspaceTreeView(
+		SHARED_WORKSPACES_TREE_ID,
+		sharedWorkspacesProvider,
 	);
+	registerWorkspaceTreeView(ALL_WORKSPACES_TREE_ID, allWorkspacesProvider);
 
 	// Register globally available commands.  Many of these have visibility
 	// controlled by contexts, see `when` in the package.json.

src/workspace/workspacesProvider.ts

@@ -31,6 +31,31 @@ export enum WorkspaceQuery {
 	Shared = "shared:true",
 }
 
+/** Per-view rendering behavior, keyed by workspace query. */
+interface WorkspaceQueryConfig {
+	readonly showOwner: boolean;
+	readonly showMetadata: boolean;
+	readonly excludeOwn: boolean;
+}
+
+const WORKSPACE_QUERY_CONFIG = {
+	[WorkspaceQuery.Mine]: {
+		showOwner: false,
+		showMetadata: true,
+		excludeOwn: false,
+	},
+	[WorkspaceQuery.All]: {
+		showOwner: true,
+		showMetadata: false,
+		excludeOwn: false,
+	},
+	[WorkspaceQuery.Shared]: {
+		showOwner: true,
+		showMetadata: false,
+		excludeOwn: true,
+	},
+} as const satisfies Record<WorkspaceQuery, WorkspaceQueryConfig>;
+
 export interface WorkspaceProviderOptions {
 	readonly refreshIntervalMs?: number;
 }
@@ -53,6 +78,7 @@ export class WorkspaceProvider
 		AgentMetadataWatcher
 	>();
 	private readonly sessionChangeDisposable: vscode.Disposable;
+	private readonly config: WorkspaceQueryConfig;
 	private timeout: NodeJS.Timeout | undefined;
 	private fetching = false;
 	private refreshQueued = false;
@@ -66,6 +92,7 @@ export class WorkspaceProvider
 		private readonly sessionState: WorkspaceSessionState,
 		private readonly options: WorkspaceProviderOptions = {},
 	) {
+		this.config = WORKSPACE_QUERY_CONFIG[getWorkspacesQuery];
 		this.sessionChangeDisposable = this.sessionState.onDidChange(() => {
 			this.clear();
 			this.requestRefresh();
@@ -121,13 +148,11 @@ export class WorkspaceProvider
 					this.setWorkspaces([]);
 				}
 
-				shouldScheduleRefresh = !hadError && !this.refreshQueued;
+				shouldScheduleRefresh = !hadError;
 			}
 		} finally {
 			this.fetching = false;
-			if (this.refreshQueued && !this.disposed && this.visible) {
-				void this.runRefreshLoop();
-			} else if (shouldScheduleRefresh && !this.disposed && this.visible) {
+			if (shouldScheduleRefresh && !this.disposed && this.visible) {
 				this.maybeScheduleRefresh();
 			}
 		}
@@ -176,8 +201,7 @@ export class WorkspaceProvider
 		// TODO: I think it might make more sense for the tree items to contain
 		// their own watchers, rather than recreate the tree items every time and
 		// have this separate map held outside the tree.
-		const showMetadata = this.getWorkspacesQuery === WorkspaceQuery.Mine;
-		if (showMetadata) {
+		if (this.config.showMetadata) {
 			const agents = extractAllAgents(workspaces);
 			for (const agent of agents) {
 				// If we have an existing watcher, re-use it.
@@ -204,22 +228,26 @@ export class WorkspaceProvider
 			}
 		}
 
-		const showOwner = this.getWorkspacesQuery !== WorkspaceQuery.Mine;
-
 		// Create tree items for each workspace
 		return workspaces.map(
 			(workspace: Workspace) =>
-				new WorkspaceTreeItem(workspace, showOwner, showMetadata),
+				new WorkspaceTreeItem(
+					workspace,
+					this.config.showOwner,
+					this.config.showMetadata,
+				),
 		);
 	}
 
 	private filterWorkspaces(
 		workspaces: readonly Workspace[],
 		session: Extract<WorkspaceSessionSnapshot, { kind: "signedIn" }>,
 	): readonly Workspace[] {
-		if (this.getWorkspacesQuery !== WorkspaceQuery.Shared) {
+		if (!this.config.excludeOwn) {
 			return workspaces;
 		}
+		// `shared:true` also returns workspaces we own and shared out; drop them
+		// to leave only those shared with us.
 		return workspaces.filter(
 			(workspace) => workspace.owner_id !== session.userId,
 		);

test/mocks/testHelpers.ts

@@ -12,10 +12,15 @@ import * as vscode from "vscode";
 import { createTestTelemetryService } from "./telemetry";
 import { window as vscodeWindow } from "./vscode.runtime";
 
-import type { Experiment, User } from "coder/site/src/api/typesGenerated";
+import type {
+	Experiment,
+	User,
+	Workspace,
+} from "coder/site/src/api/typesGenerated";
 import type { WebSocketEventType } from "coder/site/src/utils/OneWayWebSocket";
 import type { IncomingMessage } from "node:http";
 
+import type { AgentMetadataEvent } from "@/api/api-helper";
 import type { CoderApi } from "@/api/coderApi";
 import type { CliCredentialManager } from "@/core/cliCredentialManager";
 import type { ServiceContainer } from "@/core/container";
@@ -31,6 +36,10 @@ import type {
 	ParsedMessageEvent,
 	UnidirectionalStream,
 } from "@/websocket/eventStreamConnection";
+import type {
+	WorkspaceSessionSnapshot,
+	WorkspaceSessionState,
+} from "@/workspace/session";
 
 /**
  * Subset of `ContextManager`'s public API that mocks (e.g. `MockContextManager`)
@@ -461,6 +470,21 @@ export function createMockLogger(): Logger {
 	};
 }
 
+/** Resolve once pending microtasks and the macrotask queue have drained. */
+export async function flush(): Promise<void> {
+	await new Promise((resolve) => setImmediate(resolve));
+}
+
+/**
+ * Drain only the microtask queue. Use instead of flush() under fake timers,
+ * which leave the macrotask queue (setImmediate) untouched.
+ */
+export async function flushPromises(): Promise<void> {
+	await Promise.resolve();
+	await Promise.resolve();
+	await Promise.resolve();
+}
+
 /**
  * Backdate a file's atime/mtime by `daysAgo` days so tests can exercise the
  * support-bundle age cutoff without waiting.
@@ -1184,3 +1208,88 @@ export class MockTerminalOutputChannel {
 		this.write.mockClear();
 	}
 }
+
+/** Default user id reported by MockWorkspaceSessionState's signed-in snapshot. */
+export const TEST_CURRENT_USER_ID = "current-user";
+
+/** In-memory WorkspaceSessionState double with sign-in/out controls. */
+export class MockWorkspaceSessionState implements WorkspaceSessionState {
+	private revision = 0;
+	private readonly emitter =
+		new vscode.EventEmitter<WorkspaceSessionSnapshot>();
+	private snapshot: WorkspaceSessionSnapshot = {
+		kind: "signedIn",
+		revision: 0,
+		userId: TEST_CURRENT_USER_ID,
+	};
+
+	readonly onDidChange = this.emitter.event;
+
+	getSnapshot(): WorkspaceSessionSnapshot {
+		return this.snapshot;
+	}
+
+	signIn(userId = TEST_CURRENT_USER_ID): void {
+		this.revision += 1;
+		this.snapshot = { kind: "signedIn", revision: this.revision, userId };
+		this.emitter.fire(this.snapshot);
+	}
+
+	signOut(): void {
+		this.revision += 1;
+		this.snapshot = { kind: "signedOut", revision: this.revision };
+		this.emitter.fire(this.snapshot);
+	}
+}
+
+interface WorkspacesResponse {
+	workspaces: readonly Workspace[];
+	count: number;
+}
+
+/**
+ * Stands in for CoderApi at the boundaries WorkspaceProvider touches: the
+ * workspaces query and the per-agent metadata socket. Program responses with
+ * respondOnce()/pending(); metadata flows through a real MockEventStream so
+ * tests drive the production watcher rather than a stub.
+ */
+export class MockWorkspacesClient {
+	baseURL: string | undefined = "https://coder.example.com";
+	readonly metadataStreams = new Map<
+		string,
+		MockEventStream<{ data: AgentMetadataEvent[] }>
+	>();
+
+	readonly getWorkspaces = vi.fn(
+		(_req: { q: string }): Promise<WorkspacesResponse> =>
+			Promise.resolve({ workspaces: [], count: 0 }),
+	);
+
+	watchAgentMetadata(agentId: string) {
+		const stream = new MockEventStream<{ data: AgentMetadataEvent[] }>();
+		this.metadataStreams.set(agentId, stream);
+		return Promise.resolve(stream);
+	}
+
+	getAxiosInstance() {
+		return { defaults: { baseURL: this.baseURL } };
+	}
+
+	/** Resolve the next getWorkspaces call with these workspaces. */
+	respondOnce(workspaces: readonly Workspace[]): void {
+		this.getWorkspaces.mockResolvedValueOnce({
+			workspaces,
+			count: workspaces.length,
+		});
+	}
+
+	/** Make the next getWorkspaces call hang until the returned resolve() runs. */
+	pending(): { resolve: (workspaces: readonly Workspace[]) => void } {
+		const { promise, resolve } = Promise.withResolvers<WorkspacesResponse>();
+		this.getWorkspaces.mockReturnValueOnce(promise);
+		return {
+			resolve: (workspaces) =>
+				resolve({ workspaces, count: workspaces.length }),
+		};
+	}
+}