Bulk refactor - increase test coverage and add integration tests, extract some difficult to test methods

.gitignore

@@ -6,3 +6,7 @@
 /coverage/
 *.vsix
 yarn-error.log
+/reports/
+/.stryker-tmp/
+stryker.log
+.DS_Store

CLAUDE.md

@@ -1,27 +1,31 @@
 # Coder Extension Development Guidelines
 
-## Build and Test Commands
-
-- Build: `yarn build`
-- Watch mode: `yarn watch`
-- Package: `yarn package`
-- Lint: `yarn lint`
-- Lint with auto-fix: `yarn lint:fix`
-- Run all tests: `yarn test`
-- Run specific test: `vitest ./src/filename.test.ts`
-- CI test mode: `yarn test:ci`
-- Integration tests: `yarn test:integration`
-
-## Code Style Guidelines
-
-- TypeScript with strict typing
-- No semicolons (see `.prettierrc`)
-- Trailing commas for all multi-line lists
-- 120 character line width
-- Use ES6 features (arrow functions, destructuring, etc.)
-- Use `const` by default; `let` only when necessary
-- Prefix unused variables with underscore (e.g., `_unused`)
-- Sort imports alphabetically in groups: external → parent → sibling
-- Error handling: wrap and type errors appropriately
-- Use async/await for promises, avoid explicit Promise construction where possible
-- Test files must be named `*.test.ts` and use Vitest
+## Core Philosophy
+
+**First-Principles + KISS**: Question every assumption aggressively, then build the simplest solution from fundamental truths. If there's a straight line, take it, otherwise ask questions and gather any information necessary to determine the right path forward.
+
+## Commands
+
+```bash
+yarn lint:fix                                   # Lint with auto-fix
+yarn test:ci --coverage                         # Run ALL unit tests (ALWAYS use this)
+yarn pretest && yarn test:integration           # Integration tests
+yarn mutate                                     # Mutation testing (may take up to 180s - run occasionally)
+```
+
+## Key Rules
+
+- **TypeScript strict mode**, no semicolons, 120 char lines
+- **Test files**: `*.test.ts` (Vitest for unit, VS Code API for integration)
+- **Use test-helpers.ts**: 30+ mock factories available - NEVER create inline mocks, instead create a new factory in that file and import it
+- **TDD always**: Write test → implement → refactor
+- **Never use any**: Always try to use at least a decently close Partial type or equivalent
+- **Never delete tests**: Only delete or skip tests if directly asked, otherwise ask the user for help if fixing the tests does not work.
+
+## Testing Approach
+
+1. Use `yarn test:ci --coverage` before and after EVERY change
+2. Import factories and mocks from test-helpers.ts (createMock* and *Factory)
+3. Write a test, make sure it fails, and only then make it pass
+4. Use proper types, NEVER use eslint-disable to make mocks work
+5. If mocking is too complicated, consider whether the function under test needs a minor refactoring that passes existing tests first, to make it easier to test.

package.json

@@ -22,6 +22,7 @@
 		"fmt": "prettier --write .",
 		"lint": "eslint . --ext ts,md,json",
 		"lint:fix": "yarn lint --fix",
+		"mutate": "npx stryker run",
 		"package": "webpack --mode production --devtool hidden-source-map",
 		"package:prerelease": "npx vsce package --pre-release",
 		"pretest": "tsc -p . --outDir out && yarn run build && yarn run lint",
@@ -60,6 +61,16 @@
 					"type": "string",
 					"default": ""
 				},
+				"coder.binaryPath": {
+					"markdownDescription": "The full path to the Coder CLI binary. If not specified, the extension will attempt to download it automatically.",
+					"type": "string",
+					"default": ""
+				},
+				"coder.verbose": {
+					"markdownDescription": "Enable verbose logging for debugging purposes.",
+					"type": "boolean",
+					"default": false
+				},
 				"coder.enableDownloads": {
 					"markdownDescription": "Allow the plugin to download the CLI when missing or out of date.",
 					"type": "boolean",
@@ -109,6 +120,11 @@
 					"markdownDescription": "Automatically log into the default URL when the extension is activated. coder.defaultUrl is preferred, otherwise the CODER_URL environment variable will be used. This setting has no effect if neither is set.",
 					"type": "boolean",
 					"default": false
+				},
+				"coder.url": {
+					"markdownDescription": "The URL of the Coder deployment. This can be used to automatically configure the connection.",
+					"type": "string",
+					"default": ""
 				}
 			}
 		},
@@ -292,6 +308,8 @@
 		"zod": "^3.25.65"
 	},
 	"devDependencies": {
+		"@stryker-mutator/core": "^9.0.1",
+		"@stryker-mutator/vitest-runner": "^9.0.1",
 		"@types/eventsource": "^3.0.0",
 		"@types/glob": "^7.1.3",
 		"@types/node": "^22.14.1",
@@ -301,10 +319,12 @@
 		"@types/ws": "^8.18.1",
 		"@typescript-eslint/eslint-plugin": "^7.0.0",
 		"@typescript-eslint/parser": "^6.21.0",
+		"@vitest/coverage-v8": "^2.1.0",
 		"@vscode/test-cli": "^0.0.10",
 		"@vscode/test-electron": "^2.5.2",
 		"@vscode/vsce": "^2.21.1",
 		"bufferutil": "^4.0.9",
+		"c8": "^10.1.3",
 		"coder": "https://github.com/coder/coder#main",
 		"dayjs": "^1.11.13",
 		"eslint": "^8.57.1",
@@ -321,7 +341,7 @@
 		"tsc-watch": "^6.2.1",
 		"typescript": "^5.4.5",
 		"utf-8-validate": "^6.0.5",
-		"vitest": "^0.34.6",
+		"vitest": "^2.1.0",
 		"vscode-test": "^1.5.0",
 		"webpack": "^5.99.6",
 		"webpack-cli": "^5.1.4"

src/api-helper.test.ts

@@ -0,0 +1,242 @@
+import { ErrorEvent } from "eventsource";
+import { describe, expect, it } from "vitest";
+import * as apiHelper from "./api-helper";
+import {
+	AgentMetadataEventSchema,
+	AgentMetadataEventSchemaArray,
+	errToStr,
+	extractAgents,
+} from "./api-helper";
+import {
+	createMockAgent,
+	createMockWorkspace,
+	createWorkspaceWithAgents,
+} from "./test-helpers";
+
+// Test helpers
+const createMockResource = (
+	id: string,
+	agents?: ReturnType<typeof createMockAgent>[],
+) => ({
+	id,
+	created_at: new Date().toISOString(),
+	job_id: "job-id",
+	workspace_transition: "start" as const,
+	type: "docker_container",
+	name: id,
+	hide: false,
+	icon: "",
+	agents,
+	metadata: [],
+	daily_cost: 0,
+});
+
+const createValidMetadataEvent = (overrides: Record<string, unknown> = {}) => ({
+	result: {
+		collected_at: "2024-01-01T00:00:00Z",
+		age: 60,
+		value: "test-value",
+		error: "",
+		...overrides,
+	},
+	description: {
+		display_name: "Test Metric",
+		key: "test_metric",
+		script: "echo 'test'",
+		interval: 30,
+		timeout: 10,
+	},
+});
+
+describe("api-helper", () => {
+	describe("errToStr", () => {
+		it.each([
+			["Error instance", new Error("Test error message"), "Test error message"],
+			["Error with empty message", new Error(""), ""],
+			["non-empty string", "String error message", "String error message"],
+			["empty string", "", "default"],
+			["whitespace-only string", "   \n\t  ", "default"],
+			["null", null, "default"],
+			["undefined", undefined, "default"],
+			["number", 42, "default"],
+			["object", { unknown: "object" }, "default"],
+		])("should handle %s", (_, input, expected) => {
+			expect(errToStr(input, "default")).toBe(expected);
+		});
+
+		it.each([
+			["with message", { message: "Connection failed" }, "Connection failed"],
+			["without message", {}, "default"],
+		])("should handle ErrorEvent %s", (_, eventInit, expected) => {
+			const errorEvent = new ErrorEvent("error", eventInit);
+			expect(errToStr(errorEvent, "default")).toBe(expected);
+		});
+
+		it("should handle API error response", () => {
+			const apiError = {
+				isAxiosError: true,
+				response: {
+					data: {
+						message: "API request failed",
+						detail: "API request failed",
+					},
+				},
+			};
+			expect(errToStr(apiError, "default")).toBe("API request failed");
+		});
+
+		it("should handle API error response object", () => {
+			const apiErrorResponse = {
+				detail: "Invalid authentication",
+				message: "Invalid authentication",
+			};
+			expect(errToStr(apiErrorResponse, "default")).toBe(
+				"Invalid authentication",
+			);
+		});
+	});
+
+	describe("extractAgents", () => {
+		it.each([
+			[
+				"multiple resources with agents",
+				[
+					createMockResource("resource-1", [
+						createMockAgent({ id: "agent1", name: "main" }),
+						createMockAgent({ id: "agent2", name: "secondary" }),
+					]),
+					createMockResource("resource-2", [
+						createMockAgent({ id: "agent3", name: "tertiary" }),
+					]),
+				],
+				3,
+				["agent1", "agent2", "agent3"],
+			],
+			["empty resources", [], 0, []],
+			[
+				"resources with undefined agents",
+				[createMockResource("resource-1", undefined)],
+				0,
+				[],
+			],
+			[
+				"resources with empty agents",
+				[createMockResource("resource-1", [])],
+				0,
+				[],
+			],
+		])("should handle %s", (_, resources, expectedCount, expectedIds) => {
+			const mockWorkspace = createMockWorkspace({
+				latest_build: {
+					...createMockWorkspace().latest_build,
+					resources,
+				},
+			});
+
+			const agents = extractAgents(mockWorkspace);
+			expect(agents).toHaveLength(expectedCount);
+			expect(agents.map((a) => a.id)).toEqual(expectedIds);
+		});
+	});
+
+	describe("extractAllAgents", () => {
+		it("should extract agents from multiple workspaces", () => {
+			const workspaces = [
+				createWorkspaceWithAgents([
+					createMockAgent({ id: "agent1", name: "main" }),
+				]),
+				createWorkspaceWithAgents([
+					createMockAgent({ id: "agent2", name: "secondary" }),
+				]),
+			];
+
+			const agents = apiHelper.extractAllAgents(workspaces);
+			expect(agents).toHaveLength(2);
+			expect(agents.map((a) => a.id)).toEqual(["agent1", "agent2"]);
+		});
+
+		it("should handle empty workspaces array", () => {
+			const agents = apiHelper.extractAllAgents([]);
+			expect(agents).toHaveLength(0);
+			expect(agents).toEqual([]);
+		});
+
+		it("should handle workspaces with no agents", () => {
+			const workspaces = [createMockWorkspace(), createMockWorkspace()];
+			const agents = apiHelper.extractAllAgents(workspaces);
+			expect(agents).toHaveLength(0);
+		});
+	});
+
+	describe("AgentMetadataEventSchema", () => {
+		it("should validate correct event", () => {
+			const validEvent = createValidMetadataEvent();
+			const result = AgentMetadataEventSchema.safeParse(validEvent);
+			expect(result.success).toBe(true);
+			if (result.success) {
+				expect(result.data.result.collected_at).toBe("2024-01-01T00:00:00Z");
+				expect(result.data.result.age).toBe(60);
+				expect(result.data.result.value).toBe("test-value");
+				expect(result.data.result.error).toBe("");
+				expect(result.data.description.display_name).toBe("Test Metric");
+				expect(result.data.description.key).toBe("test_metric");
+				expect(result.data.description.script).toBe("echo 'test'");
+				expect(result.data.description.interval).toBe(30);
+				expect(result.data.description.timeout).toBe(10);
+			}
+		});
+
+		it("should reject invalid event", () => {
+			const event = createValidMetadataEvent({ age: "invalid" });
+			const result = AgentMetadataEventSchema.safeParse(event);
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				expect(result.error.issues[0].code).toBe("invalid_type");
+				expect(result.error.issues[0].path).toEqual(["result", "age"]);
+			}
+		});
+
+		it("should validate array of events", () => {
+			const events = [
+				createValidMetadataEvent(),
+				createValidMetadataEvent({ value: "different-value" }),
+			];
+			const result = AgentMetadataEventSchemaArray.safeParse(events);
+			expect(result.success).toBe(true);
+			if (result.success) {
+				expect(result.data).toHaveLength(2);
+				expect(result.data[0].result.value).toBe("test-value");
+				expect(result.data[1].result.value).toBe("different-value");
+			}
+		});
+
+		it("should reject array with invalid events", () => {
+			const events = [createValidMetadataEvent(), { invalid: "structure" }];
+			const result = AgentMetadataEventSchemaArray.safeParse(events);
+			expect(result.success).toBe(false);
+		});
+
+		it("should handle missing required fields", () => {
+			const incompleteEvent = {
+				result: {
+					collected_at: "2024-01-01T00:00:00Z",
+					// missing age, value, error
+				},
+				description: {
+					display_name: "Test",
+					// missing other fields
+				},
+			};
+			const result = AgentMetadataEventSchema.safeParse(incompleteEvent);
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				const missingFields = result.error.issues.map(
+					(issue) => issue.path[issue.path.length - 1],
+				);
+				expect(missingFields).toContain("age");
+				expect(missingFields).toContain("value");
+				expect(missingFields).toContain("error");
+			}
+		});
+	});
+});