diff --git a/site/src/testHelpers/websockets.test.ts b/site/src/testHelpers/websockets.test.ts
new file mode 100644
index 0000000000000..edd4191cffebe
--- /dev/null
+++ b/site/src/testHelpers/websockets.test.ts
@@ -0,0 +1,186 @@
+import { createMockWebSocket } from "./websockets";
+
+describe(createMockWebSocket.name, () => {
+	it("Throws if URL does not have ws:// or wss:// protocols", () => {
+		const urls: readonly string[] = [
+			"http://www.dog.ceo/roll-over",
+			"https://www.dog.ceo/roll-over",
+		];
+		for (const url of urls) {
+			expect(() => {
+				void createMockWebSocket(url);
+			}).toThrow("URL must start with ws:// or wss://");
+		}
+	});
+
+	it("Sends events from server to socket", () => {
+		const [socket, server] = createMockWebSocket("wss://www.dog.ceo/shake");
+
+		const onOpen = jest.fn();
+		const onError = jest.fn();
+		const onMessage = jest.fn();
+		const onClose = jest.fn();
+
+		socket.addEventListener("open", onOpen);
+		socket.addEventListener("error", onError);
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("close", onClose);
+
+		const openEvent = new Event("open");
+		const errorEvent = new Event("error");
+		const messageEvent = new MessageEvent<string>("message");
+		const closeEvent = new CloseEvent("close");
+
+		server.publishOpen(openEvent);
+		server.publishError(errorEvent);
+		server.publishMessage(messageEvent);
+		server.publishClose(closeEvent);
+
+		expect(onOpen).toHaveBeenCalledTimes(1);
+		expect(onOpen).toHaveBeenCalledWith(openEvent);
+
+		expect(onError).toHaveBeenCalledTimes(1);
+		expect(onError).toHaveBeenCalledWith(errorEvent);
+
+		expect(onMessage).toHaveBeenCalledTimes(1);
+		expect(onMessage).toHaveBeenCalledWith(messageEvent);
+
+		expect(onClose).toHaveBeenCalledTimes(1);
+		expect(onClose).toHaveBeenCalledWith(closeEvent);
+	});
+
+	it("Sends JSON data to the socket for message events", () => {
+		const [socket, server] = createMockWebSocket("wss://www.dog.ceo/wag");
+		const onMessage = jest.fn();
+
+		// Could type this as a special JSON type, but unknown is good enough,
+		// since any invalid values will throw in the test case
+		const jsonData: readonly unknown[] = [
+			"blah",
+			42,
+			true,
+			false,
+			null,
+			{},
+			[],
+			[{ value: "blah" }, { value: "guh" }, { value: "huh" }],
+			{
+				name: "Hershel Layton",
+				age: 40,
+				profession: "Puzzle Solver",
+				sadBackstory: true,
+				greatVideoGames: true,
+			},
+		];
+		for (const jd of jsonData) {
+			socket.addEventListener("message", onMessage);
+			server.publishMessage(
+				new MessageEvent("message", { data: JSON.stringify(jd) }),
+			);
+
+			expect(onMessage).toHaveBeenCalledTimes(1);
+			expect(onMessage).toHaveBeenCalledWith(
+				new MessageEvent("message", { data: JSON.stringify(jd) }),
+			);
+
+			socket.removeEventListener("message", onMessage);
+			onMessage.mockClear();
+		}
+	});
+
+	it("Only registers each socket event handler once", () => {
+		const [socket, server] = createMockWebSocket("wss://www.dog.ceo/borf");
+
+		const onOpen = jest.fn();
+		const onError = jest.fn();
+		const onMessage = jest.fn();
+		const onClose = jest.fn();
+
+		// Do it once
+		socket.addEventListener("open", onOpen);
+		socket.addEventListener("error", onError);
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("close", onClose);
+
+		// Do it again with the exact same functions
+		socket.addEventListener("open", onOpen);
+		socket.addEventListener("error", onError);
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("close", onClose);
+
+		server.publishOpen(new Event("open"));
+		server.publishError(new Event("error"));
+		server.publishMessage(new MessageEvent<string>("message"));
+		server.publishClose(new CloseEvent("close"));
+
+		expect(onOpen).toHaveBeenCalledTimes(1);
+		expect(onError).toHaveBeenCalledTimes(1);
+		expect(onMessage).toHaveBeenCalledTimes(1);
+		expect(onClose).toHaveBeenCalledTimes(1);
+	});
+
+	it("Lets a socket unsubscribe to event types", () => {
+		const [socket, server] = createMockWebSocket("wss://www.dog.ceo/zoomies");
+
+		const onOpen = jest.fn();
+		const onError = jest.fn();
+		const onMessage = jest.fn();
+		const onClose = jest.fn();
+
+		socket.addEventListener("open", onOpen);
+		socket.addEventListener("error", onError);
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("close", onClose);
+
+		socket.removeEventListener("open", onOpen);
+		socket.removeEventListener("error", onError);
+		socket.removeEventListener("message", onMessage);
+		socket.removeEventListener("close", onClose);
+
+		server.publishOpen(new Event("open"));
+		server.publishError(new Event("error"));
+		server.publishMessage(new MessageEvent<string>("message"));
+		server.publishClose(new CloseEvent("close"));
+
+		expect(onOpen).not.toHaveBeenCalled();
+		expect(onError).not.toHaveBeenCalled();
+		expect(onMessage).not.toHaveBeenCalled();
+		expect(onClose).not.toHaveBeenCalled();
+	});
+
+	it("Renders socket inert after being closed", () => {
+		const [socket, server] = createMockWebSocket("wss://www.dog.ceo/woof");
+		expect(server.isConnectionOpen).toBe(true);
+
+		const onMessage = jest.fn();
+		socket.addEventListener("message", onMessage);
+
+		socket.close();
+		expect(server.isConnectionOpen).toBe(false);
+
+		server.publishMessage(new MessageEvent<string>("message"));
+		expect(onMessage).not.toHaveBeenCalled();
+	});
+
+	it("Tracks arguments sent by the mock socket", () => {
+		const [socket, server] = createMockWebSocket("wss://www.dog.ceo/wan-wan");
+		const data = JSON.stringify({
+			famousDogs: [
+				"snoopy",
+				"clifford",
+				"lassie",
+				"beethoven",
+				"courage the cowardly dog",
+			],
+		});
+
+		socket.send(data);
+		expect(server.clientSentData).toHaveLength(1);
+		expect(server.clientSentData).toEqual([data]);
+
+		socket.close();
+		socket.send(data);
+		expect(server.clientSentData).toHaveLength(1);
+		expect(server.clientSentData).toEqual([data]);
+	});
+});
diff --git a/site/src/testHelpers/websockets.ts b/site/src/testHelpers/websockets.ts
new file mode 100644
index 0000000000000..57584cd55e887
--- /dev/null
+++ b/site/src/testHelpers/websockets.ts
@@ -0,0 +1,162 @@
+import type { WebSocketEventType } from "utils/OneWayWebSocket";
+
+type SocketSendData = Parameters<WebSocket["send"]>[0];
+
+export type MockWebSocketServer = Readonly<{
+	publishMessage: (event: MessageEvent<string>) => void;
+	publishError: (event: Event) => void;
+	publishClose: (event: CloseEvent) => void;
+	publishOpen: (event: Event) => void;
+
+	readonly isConnectionOpen: boolean;
+	readonly clientSentData: readonly SocketSendData[];
+}>;
+
+type CallbackStore = {
+	[K in keyof WebSocketEventMap]: Set<(event: WebSocketEventMap[K]) => void>;
+};
+
+type MockWebSocket = Omit<WebSocket, "send"> & {
+	/**
+	 * A version of the WebSocket `send` method that has been pre-wrapped inside
+	 * a Jest mock.
+	 *
+	 * The Jest mock functionality should be used at a minimum. Basically:
+	 * 1. If you want to check that the mock socket sent something to the mock
+	 *    server: call the `send` method as a function, and then check the
+	 *    `clientSentData` on `MockWebSocketServer` to see what data got
+	 *    received.
+	 * 2. If you need to make sure that the client-side `send` method got called
+	 *    at all: you can use the Jest mock functionality, but you should
+	 *    probably also be checking `clientSentData` still and making additional
+	 *    assertions with it.
+	 *
+	 * Generally, tests should center around whether socket-to-server
+	 * communication was successful, not whether the client-side method was
+	 * called.
+	 */
+	send: jest.Mock<void, [SocketSendData], unknown>;
+};
+
+export function createMockWebSocket(
+	url: string,
+	protocol?: string | string[] | undefined,
+): readonly [MockWebSocket, MockWebSocketServer] {
+	if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
+		throw new Error("URL must start with ws:// or wss://");
+	}
+
+	const activeProtocol = Array.isArray(protocol)
+		? protocol.join(" ")
+		: (protocol ?? "");
+
+	let isOpen = true;
+	const store: CallbackStore = {
+		message: new Set(),
+		error: new Set(),
+		close: new Set(),
+		open: new Set(),
+	};
+
+	const sentData: SocketSendData[] = [];
+
+	const mockSocket: MockWebSocket = {
+		CONNECTING: 0,
+		OPEN: 1,
+		CLOSING: 2,
+		CLOSED: 3,
+
+		url,
+		protocol: activeProtocol,
+		readyState: 1,
+		binaryType: "blob",
+		bufferedAmount: 0,
+		extensions: "",
+		onclose: null,
+		onerror: null,
+		onmessage: null,
+		onopen: null,
+		dispatchEvent: jest.fn(),
+
+		send: jest.fn((data) => {
+			if (!isOpen) {
+				return;
+			}
+			sentData.push(data);
+		}),
+
+		addEventListener: <E extends WebSocketEventType>(
+			eventType: E,
+			callback: (event: WebSocketEventMap[E]) => void,
+		) => {
+			if (!isOpen) {
+				return;
+			}
+			const subscribers = store[eventType];
+			subscribers.add(callback);
+		},
+
+		removeEventListener: <E extends WebSocketEventType>(
+			eventType: E,
+			callback: (event: WebSocketEventMap[E]) => void,
+		) => {
+			if (!isOpen) {
+				return;
+			}
+			const subscribers = store[eventType];
+			subscribers.delete(callback);
+		},
+
+		close: () => {
+			isOpen = false;
+		},
+	};
+
+	const publisher: MockWebSocketServer = {
+		get isConnectionOpen() {
+			return isOpen;
+		},
+
+		get clientSentData() {
+			return [...sentData];
+		},
+
+		publishOpen: (event) => {
+			if (!isOpen) {
+				return;
+			}
+			for (const sub of store.open) {
+				sub(event);
+			}
+		},
+
+		publishError: (event) => {
+			if (!isOpen) {
+				return;
+			}
+			for (const sub of store.error) {
+				sub(event);
+			}
+		},
+
+		publishMessage: (event) => {
+			if (!isOpen) {
+				return;
+			}
+			for (const sub of store.message) {
+				sub(event);
+			}
+		},
+
+		publishClose: (event) => {
+			if (!isOpen) {
+				return;
+			}
+			for (const sub of store.close) {
+				sub(event);
+			}
+		},
+	};
+
+	return [mockSocket, publisher] as const;
+}
diff --git a/site/src/utils/OneWayWebSocket.test.ts b/site/src/utils/OneWayWebSocket.test.ts
index c6b00b593111f..a0492dab9b439 100644
--- a/site/src/utils/OneWayWebSocket.test.ts
+++ b/site/src/utils/OneWayWebSocket.test.ts
@@ -8,144 +8,10 @@
  */
 
 import {
-	type OneWayMessageEvent,
-	OneWayWebSocket,
-	type WebSocketEventType,
-} from "./OneWayWebSocket";
-
-type MockPublisher = Readonly<{
-	publishMessage: (event: MessageEvent<string>) => void;
-	publishError: (event: ErrorEvent) => void;
-	publishClose: (event: CloseEvent) => void;
-	publishOpen: (event: Event) => void;
-}>;
-
-function createMockWebSocket(
-	url: string,
-	protocols?: string | string[],
-): readonly [WebSocket, MockPublisher] {
-	type EventMap = {
-		message: MessageEvent<string>;
-		error: ErrorEvent;
-		close: CloseEvent;
-		open: Event;
-	};
-	type CallbackStore = {
-		[K in keyof EventMap]: ((event: EventMap[K]) => void)[];
-	};
-
-	let activeProtocol: string;
-	if (Array.isArray(protocols)) {
-		activeProtocol = protocols[0] ?? "";
-	} else if (typeof protocols === "string") {
-		activeProtocol = protocols;
-	} else {
-		activeProtocol = "";
-	}
-
-	let closed = false;
-	const store: CallbackStore = {
-		message: [],
-		error: [],
-		close: [],
-		open: [],
-	};
-
-	const mockSocket: WebSocket = {
-		CONNECTING: 0,
-		OPEN: 1,
-		CLOSING: 2,
-		CLOSED: 3,
-
-		url,
-		protocol: activeProtocol,
-		readyState: 1,
-		binaryType: "blob",
-		bufferedAmount: 0,
-		extensions: "",
-		onclose: null,
-		onerror: null,
-		onmessage: null,
-		onopen: null,
-		send: jest.fn(),
-		dispatchEvent: jest.fn(),
-
-		addEventListener: <E extends WebSocketEventType>(
-			eventType: E,
-			callback: WebSocketEventMap[E],
-		) => {
-			if (closed) {
-				return;
-			}
-
-			const subscribers = store[eventType];
-			const cb = callback as unknown as CallbackStore[E][0];
-			if (!subscribers.includes(cb)) {
-				subscribers.push(cb);
-			}
-		},
-
-		removeEventListener: <E extends WebSocketEventType>(
-			eventType: E,
-			callback: WebSocketEventMap[E],
-		) => {
-			if (closed) {
-				return;
-			}
-
-			const subscribers = store[eventType];
-			const cb = callback as unknown as CallbackStore[E][0];
-			if (subscribers.includes(cb)) {
-				const updated = store[eventType].filter((c) => c !== cb);
-				store[eventType] = updated as unknown as CallbackStore[E];
-			}
-		},
-
-		close: () => {
-			closed = true;
-		},
-	};
-
-	const publisher: MockPublisher = {
-		publishOpen: (event) => {
-			if (closed) {
-				return;
-			}
-			for (const sub of store.open) {
-				sub(event);
-			}
-		},
-
-		publishError: (event) => {
-			if (closed) {
-				return;
-			}
-			for (const sub of store.error) {
-				sub(event);
-			}
-		},
-
-		publishMessage: (event) => {
-			if (closed) {
-				return;
-			}
-			for (const sub of store.message) {
-				sub(event);
-			}
-		},
-
-		publishClose: (event) => {
-			if (closed) {
-				return;
-			}
-			for (const sub of store.close) {
-				sub(event);
-			}
-		},
-	};
-
-	return [mockSocket, publisher] as const;
-}
+	type MockWebSocketServer,
+	createMockWebSocket,
+} from "testHelpers/websockets";
+import { type OneWayMessageEvent, OneWayWebSocket } from "./OneWayWebSocket";
 
 describe(OneWayWebSocket.name, () => {
 	const dummyRoute = "/api/v2/blah";
@@ -167,12 +33,12 @@ describe(OneWayWebSocket.name, () => {
 	});
 
 	it("Lets a consumer add an event listener of each type", () => {
-		let publisher!: MockPublisher;
+		let mockServer!: MockWebSocketServer;
 		const oneWay = new OneWayWebSocket({
 			apiRoute: dummyRoute,
 			websocketInit: (url, protocols) => {
-				const [socket, pub] = createMockWebSocket(url, protocols);
-				publisher = pub;
+				const [socket, server] = createMockWebSocket(url, protocols);
+				mockServer = server;
 				return socket;
 			},
 		});
@@ -187,14 +53,14 @@ describe(OneWayWebSocket.name, () => {
 		oneWay.addEventListener("error", onError);
 		oneWay.addEventListener("message", onMessage);
 
-		publisher.publishOpen(new Event("open"));
-		publisher.publishClose(new CloseEvent("close"));
-		publisher.publishError(
+		mockServer.publishOpen(new Event("open"));
+		mockServer.publishClose(new CloseEvent("close"));
+		mockServer.publishError(
 			new ErrorEvent("error", {
 				error: new Error("Whoops - connection broke"),
 			}),
 		);
-		publisher.publishMessage(
+		mockServer.publishMessage(
 			new MessageEvent("message", {
 				data: "null",
 			}),
@@ -207,12 +73,12 @@ describe(OneWayWebSocket.name, () => {
 	});
 
 	it("Lets a consumer remove an event listener of each type", () => {
-		let publisher!: MockPublisher;
+		let mockServer!: MockWebSocketServer;
 		const oneWay = new OneWayWebSocket({
 			apiRoute: dummyRoute,
 			websocketInit: (url, protocols) => {
-				const [socket, pub] = createMockWebSocket(url, protocols);
-				publisher = pub;
+				const [socket, server] = createMockWebSocket(url, protocols);
+				mockServer = server;
 				return socket;
 			},
 		});
@@ -232,14 +98,14 @@ describe(OneWayWebSocket.name, () => {
 		oneWay.removeEventListener("error", onError);
 		oneWay.removeEventListener("message", onMessage);
 
-		publisher.publishOpen(new Event("open"));
-		publisher.publishClose(new CloseEvent("close"));
-		publisher.publishError(
+		mockServer.publishOpen(new Event("open"));
+		mockServer.publishClose(new CloseEvent("close"));
+		mockServer.publishError(
 			new ErrorEvent("error", {
 				error: new Error("Whoops - connection broke"),
 			}),
 		);
-		publisher.publishMessage(
+		mockServer.publishMessage(
 			new MessageEvent("message", {
 				data: "null",
 			}),
@@ -252,12 +118,12 @@ describe(OneWayWebSocket.name, () => {
 	});
 
 	it("Only calls each callback once if callback is added multiple times", () => {
-		let publisher!: MockPublisher;
+		let mockServer!: MockWebSocketServer;
 		const oneWay = new OneWayWebSocket({
 			apiRoute: dummyRoute,
 			websocketInit: (url, protocols) => {
-				const [socket, pub] = createMockWebSocket(url, protocols);
-				publisher = pub;
+				const [socket, server] = createMockWebSocket(url, protocols);
+				mockServer = server;
 				return socket;
 			},
 		});
@@ -274,14 +140,14 @@ describe(OneWayWebSocket.name, () => {
 			oneWay.addEventListener("message", onMessage);
 		}
 
-		publisher.publishOpen(new Event("open"));
-		publisher.publishClose(new CloseEvent("close"));
-		publisher.publishError(
+		mockServer.publishOpen(new Event("open"));
+		mockServer.publishClose(new CloseEvent("close"));
+		mockServer.publishError(
 			new ErrorEvent("error", {
 				error: new Error("Whoops - connection broke"),
 			}),
 		);
-		publisher.publishMessage(
+		mockServer.publishMessage(
 			new MessageEvent("message", {
 				data: "null",
 			}),
@@ -294,12 +160,12 @@ describe(OneWayWebSocket.name, () => {
 	});
 
 	it("Lets consumers register multiple callbacks for each event type", () => {
-		let publisher!: MockPublisher;
+		let mockServer!: MockWebSocketServer;
 		const oneWay = new OneWayWebSocket({
 			apiRoute: dummyRoute,
 			websocketInit: (url, protocols) => {
-				const [socket, pub] = createMockWebSocket(url, protocols);
-				publisher = pub;
+				const [socket, server] = createMockWebSocket(url, protocols);
+				mockServer = server;
 				return socket;
 			},
 		});
@@ -322,14 +188,14 @@ describe(OneWayWebSocket.name, () => {
 		oneWay.addEventListener("error", onError2);
 		oneWay.addEventListener("message", onMessage2);
 
-		publisher.publishOpen(new Event("open"));
-		publisher.publishClose(new CloseEvent("close"));
-		publisher.publishError(
+		mockServer.publishOpen(new Event("open"));
+		mockServer.publishClose(new CloseEvent("close"));
+		mockServer.publishError(
 			new ErrorEvent("error", {
 				error: new Error("Whoops - connection broke"),
 			}),
 		);
-		publisher.publishMessage(
+		mockServer.publishMessage(
 			new MessageEvent("message", {
 				data: "null",
 			}),
@@ -375,12 +241,12 @@ describe(OneWayWebSocket.name, () => {
 	});
 
 	it("Gives consumers pre-parsed versions of message events", () => {
-		let publisher!: MockPublisher;
+		let mockServer!: MockWebSocketServer;
 		const oneWay = new OneWayWebSocket({
 			apiRoute: dummyRoute,
 			websocketInit: (url, protocols) => {
-				const [socket, pub] = createMockWebSocket(url, protocols);
-				publisher = pub;
+				const [socket, server] = createMockWebSocket(url, protocols);
+				mockServer = server;
 				return socket;
 			},
 		});
@@ -396,7 +262,7 @@ describe(OneWayWebSocket.name, () => {
 			data: JSON.stringify(payload),
 		});
 
-		publisher.publishMessage(event);
+		mockServer.publishMessage(event);
 		expect(onMessage).toHaveBeenCalledWith({
 			sourceEvent: event,
 			parsedMessage: payload,
@@ -405,12 +271,12 @@ describe(OneWayWebSocket.name, () => {
 	});
 
 	it("Exposes parsing error if message payload could not be parsed as JSON", () => {
-		let publisher!: MockPublisher;
+		let mockServer!: MockWebSocketServer;
 		const oneWay = new OneWayWebSocket({
 			apiRoute: dummyRoute,
 			websocketInit: (url, protocols) => {
-				const [socket, pub] = createMockWebSocket(url, protocols);
-				publisher = pub;
+				const [socket, server] = createMockWebSocket(url, protocols);
+				mockServer = server;
 				return socket;
 			},
 		});
@@ -422,7 +288,7 @@ describe(OneWayWebSocket.name, () => {
 		const event = new MessageEvent("message", {
 			data: payload,
 		});
-		publisher.publishMessage(event);
+		mockServer.publishMessage(event);
 
 		const arg: OneWayMessageEvent<never> = onMessage.mock.lastCall[0];
 		expect(arg.sourceEvent).toEqual(event);