chore: clean up WorkspaceMonitor and Inbox tests

- Remove unnecessary dispose() calls from tests that don't test dispose
- Combine two "before initial setup" tests into one
- Import ContextManager type properly instead of inline import()
- Improve test names to describe behavior more precisely

Author: EhabY

test/mocks/testHelpers.ts

@@ -9,13 +9,15 @@ import { vi } from "vitest";
 import * as vscode from "vscode";
 
 import type { User } from "coder/site/src/api/typesGenerated";
+import type { WebSocketEventType } from "coder/site/src/utils/OneWayWebSocket";
 import type { IncomingMessage } from "node:http";
 
 import type { CoderApi } from "@/api/coderApi";
 import type { CliCredentialManager } from "@/core/cliCredentialManager";
 import type { Logger } from "@/logging/logger";
 import type {
 	EventHandler,
+	EventPayloadMap,
 	ParsedMessageEvent,
 	UnidirectionalStream,
 } from "@/websocket/eventStreamConnection";
@@ -836,50 +838,63 @@ export class MockCancellationToken implements vscode.CancellationToken {
 }
 
 /**
- * Mock event stream for testing UnidirectionalStream consumers.
+ * Mock event stream that implements UnidirectionalStream directly.
+ * Use pushMessage/pushError for common cases, or emit() for any event type.
  */
-export class MockEventStream<T> {
+export class MockEventStream<T> implements UnidirectionalStream<T> {
+	readonly url = "ws://test/mock-stream";
+	readonly close = vi.fn();
+
 	private readonly handlers = new Map<
 		string,
-		Array<(...args: unknown[]) => void>
+		Set<(...args: unknown[]) => void>
 	>();
 
-	readonly stream: UnidirectionalStream<T> = {
-		url: "ws://test/mock-stream",
-		addEventListener: vi.fn(
-			(event: string, callback: (...args: unknown[]) => void) => {
-				if (!this.handlers.has(event)) {
-					this.handlers.set(event, []);
-				}
-				this.handlers.get(event)!.push(callback);
-			},
-		),
-		removeEventListener: vi.fn(),
-		close: vi.fn(),
-	};
+	addEventListener<E extends WebSocketEventType>(
+		event: E,
+		callback: EventHandler<T, E>,
+	): void {
+		if (!this.handlers.has(event)) {
+			this.handlers.set(event, new Set());
+		}
+		this.handlers.get(event)!.add(callback as (...args: unknown[]) => void);
+	}
+
+	removeEventListener<E extends WebSocketEventType>(
+		event: E,
+		callback: EventHandler<T, E>,
+	): void {
+		this.handlers.get(event)?.delete(callback as (...args: unknown[]) => void);
+	}
+
+	emit<E extends WebSocketEventType>(
+		event: E,
+		payload: EventPayloadMap<T>[E],
+	): void {
+		const handlers = this.handlers.get(event);
+		if (handlers) {
+			for (const handler of handlers) {
+				handler(payload);
+			}
+		}
+	}
 
 	pushMessage(parsedMessage: T): void {
-		const event: ParsedMessageEvent<T> = {
+		const payload: ParsedMessageEvent<T> = {
 			sourceEvent: { data: undefined },
 			parsedMessage,
 			parseError: undefined,
 		};
-		this.fire("message", event);
+		this.emit("message", payload);
 	}
 
 	pushError(error: Error): void {
-		const event: ParsedMessageEvent<T> = {
+		const payload: ParsedMessageEvent<T> = {
 			sourceEvent: { data: undefined },
 			parsedMessage: undefined,
 			parseError: error,
 		};
-		this.fire("message", event);
-	}
-
-	private fire(event: string, payload: unknown): void {
-		for (const handler of this.handlers.get(event) ?? []) {
-			(handler as EventHandler<T, "message">)(payload as ParsedMessageEvent<T>);
-		}
+		this.emit("message", payload);
 	}
 }
 

test/unit/inbox.test.ts

@@ -32,85 +32,76 @@ function createNotification(title: string): GetInboxNotificationResponse {
 	};
 }
 
-function createMockClient(
-	stream: MockEventStream<GetInboxNotificationResponse>,
-) {
-	return {
-		watchInboxNotifications: vi.fn().mockResolvedValue(stream.stream),
-	} as unknown as CoderApi;
-}
-
 describe("Inbox", () => {
-	let config: MockConfigurationProvider;
-
 	beforeEach(() => {
 		vi.resetAllMocks();
-		config = new MockConfigurationProvider();
 	});
 
-	async function createInbox(
+	async function setup(
 		stream = new MockEventStream<GetInboxNotificationResponse>(),
 	) {
-		const ws = createWorkspace();
-		const client = createMockClient(stream);
-		const inbox = await Inbox.create(ws, client, createMockLogger());
-		return { inbox, stream };
+		const config = new MockConfigurationProvider();
+		const inbox = await Inbox.create(
+			createWorkspace(),
+			{
+				watchInboxNotifications: () => Promise.resolve(stream),
+			} as unknown as CoderApi,
+			createMockLogger(),
+		);
+		return { inbox, stream, config };
 	}
 
 	describe("message handling", () => {
-		it("shows notification when a message arrives", async () => {
-			const { inbox, stream } = await createInbox();
+		it("shows notification with the message title", async () => {
+			const { stream } = await setup();
 
 			stream.pushMessage(createNotification("Out of memory"));
 
 			expect(vscode.window.showInformationMessage).toHaveBeenCalledWith(
 				"Out of memory",
 			);
-			inbox.dispose();
 		});
 
-		it("shows multiple notifications for successive messages", async () => {
-			const { inbox, stream } = await createInbox();
+		it("shows each notification independently (no dedup)", async () => {
+			const { stream } = await setup();
 
 			stream.pushMessage(createNotification("First alert"));
 			stream.pushMessage(createNotification("Second alert"));
 
 			expect(vscode.window.showInformationMessage).toHaveBeenCalledTimes(2);
-			inbox.dispose();
 		});
 
 		it("logs parse errors without showing notifications", async () => {
-			const { inbox, stream } = await createInbox();
+			const { stream } = await setup();
 
 			stream.pushError(new Error("bad json"));
 
 			expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
-			inbox.dispose();
 		});
 
 		it("closes the socket on dispose", async () => {
 			const stream = new MockEventStream<GetInboxNotificationResponse>();
-			const { inbox } = await createInbox(stream);
+			const { inbox } = await setup(stream);
+
 			inbox.dispose();
 
-			expect(stream.stream.close).toHaveBeenCalled();
+			expect(stream.close).toHaveBeenCalled();
 		});
 	});
 
 	describe("disableNotifications", () => {
 		it("suppresses notifications when enabled", async () => {
+			const { stream, config } = await setup();
 			config.set("coder.disableNotifications", true);
-			const { inbox, stream } = await createInbox();
 
 			stream.pushMessage(createNotification("Out of memory"));
 
 			expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
-			inbox.dispose();
 		});
 
 		it("shows notifications after re-enabling", async () => {
+			const { stream, config } = await setup();
 			config.set("coder.disableNotifications", true);
-			const { inbox, stream } = await createInbox();
 
 			stream.pushMessage(createNotification("suppressed"));
 			expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
@@ -121,7 +112,6 @@ describe("Inbox", () => {
 			expect(vscode.window.showInformationMessage).toHaveBeenCalledWith(
 				"visible",
 			);
-			inbox.dispose();
 		});
 	});
 });