test: add unit tests for controllers and web utilities to reach 80% coverage

Adds tests for the five server controllers (games, discord, config, env,
costs) and three web modules (api.service, useClickOutside, useFileManager)
— all previously untested. Also raises vitest coverage thresholds from the
baseline floor (64%/75%/67%/64%) to 80% across all four metrics.

Controllers are tested by instantiating them directly with typed vi.fn()
stubs — no Nest testing module needed. Web tests use @testing-library/react
renderHook for hooks and vi.stubGlobal('fetch') for the API service.

https://claude.ai/code/session_013coUXcACPpVfmbK9i2D86Z

Author: claude

app/packages/server/src/controllers/config.controller.test.ts

@@ -0,0 +1,72 @@
+import 'reflect-metadata';
+import { describe, it, expect, vi } from 'vitest';
+import { ConfigController } from './config.controller.js';
+import type { ConfigService, WatchdogConfig } from '../services/ConfigService.js';
+
+vi.mock('../logger.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+/** Default watchdog settings used by most tests. */
+const DEFAULT_CONFIG: WatchdogConfig = {
+  watchdog_interval_minutes: 15,
+  watchdog_idle_checks: 4,
+  watchdog_min_packets: 100,
+};
+
+/** Build a ConfigService stub wired up with the provided watchdog config. */
+function makeConfig(current: WatchdogConfig = DEFAULT_CONFIG): ConfigService {
+  return {
+    getConfig: vi.fn().mockReturnValue(current),
+    saveConfig: vi.fn(),
+  } as unknown as ConfigService;
+}
+
+describe('ConfigController', () => {
+  describe('get', () => {
+    it('should return the current watchdog config from ConfigService', () => {
+      const result = new ConfigController(makeConfig()).get();
+      expect(result).toEqual(DEFAULT_CONFIG);
+    });
+  });
+
+  describe('update', () => {
+    it('should merge a partial body with the current config and return success', () => {
+      const config = makeConfig();
+      const result = new ConfigController(config).update({ watchdog_interval_minutes: 30 });
+      expect(result.success).toBe(true);
+      expect(result.config.watchdog_interval_minutes).toBe(30);
+      // Fields not in the body should retain their current values.
+      expect(result.config.watchdog_idle_checks).toBe(4);
+      expect(result.config.watchdog_min_packets).toBe(100);
+    });
+
+    it('should persist the merged config to disk via ConfigService.saveConfig', () => {
+      const config = makeConfig();
+      new ConfigController(config).update({ watchdog_idle_checks: 6 });
+      expect(config.saveConfig).toHaveBeenCalledWith(
+        expect.objectContaining({ watchdog_idle_checks: 6 }),
+      );
+    });
+
+    it('should leave all fields unchanged when the body is empty', () => {
+      const config = makeConfig();
+      const result = new ConfigController(config).update({});
+      expect(result.config).toEqual(DEFAULT_CONFIG);
+    });
+
+    it('should update all three fields at once when all are supplied', () => {
+      const config = makeConfig();
+      const result = new ConfigController(config).update({
+        watchdog_interval_minutes: 5,
+        watchdog_idle_checks: 2,
+        watchdog_min_packets: 50,
+      });
+      expect(result.config).toEqual({
+        watchdog_interval_minutes: 5,
+        watchdog_idle_checks: 2,
+        watchdog_min_packets: 50,
+      });
+    });
+  });
+});

app/packages/server/src/controllers/costs.controller.test.ts

@@ -0,0 +1,109 @@
+import 'reflect-metadata';
+import { describe, it, expect, vi } from 'vitest';
+import { CostsController } from './costs.controller.js';
+import type { ConfigService, TfOutputs } from '../services/ConfigService.js';
+import type { CostService } from '../services/CostService.js';
+import type { EcsService } from '../services/EcsService.js';
+
+vi.mock('../logger.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+/** A canned estimate object returned by CostService stubs. */
+const MOCK_ESTIMATE = {
+  vcpu: 4,
+  memoryGb: 16,
+  costPerHour: 0.5,
+  costPerDay24h: 12,
+  costPerMonth4hpd: 60,
+};
+
+/** Build a ConfigService stub with a minimal set of Terraform outputs. */
+function makeConfig(outputs: Partial<TfOutputs> | null = { game_names: ['minecraft'] }): ConfigService {
+  return {
+    getTfOutputs: vi.fn().mockReturnValue(outputs),
+  } as unknown as ConfigService;
+}
+
+/** Build a CostService stub whose estimateForSpec returns the canned estimate. */
+function makeCosts(): CostService {
+  return {
+    estimateForSpec: vi.fn().mockReturnValue(MOCK_ESTIMATE),
+    getActualCosts: vi.fn().mockResolvedValue({ daily: [], total: 0, currency: 'USD', days: 7 }),
+  } as unknown as CostService;
+}
+
+/**
+ * Build an EcsService stub. Pass `null` to simulate a missing task definition
+ * (e.g. the game has never been deployed).
+ */
+function makeEcs(td: { cpu: number; memory: number } | null = { cpu: 4096, memory: 16384 }): EcsService {
+  return {
+    getTaskDefinition: vi.fn().mockResolvedValue(td),
+  } as unknown as EcsService;
+}
+
+describe('CostsController', () => {
+  describe('estimate', () => {
+    it('should return zeroed estimates when Terraform has not been applied', async () => {
+      const result = await new CostsController(makeConfig(null), makeCosts(), makeEcs()).estimate();
+      expect(result).toEqual({ games: {}, totalPerHourIfAllOn: 0 });
+    });
+
+    it('should call getTaskDefinition and estimateForSpec for each game', async () => {
+      const ecs = makeEcs();
+      const costs = makeCosts();
+      await new CostsController(makeConfig(), costs, ecs).estimate();
+      expect(ecs.getTaskDefinition).toHaveBeenCalledWith('minecraft');
+      expect(costs.estimateForSpec).toHaveBeenCalledWith(4096, 16384);
+    });
+
+    it('should fall back to 2048 cpu / 8192 memory when getTaskDefinition returns null', async () => {
+      const ecs = makeEcs(null);
+      const costs = makeCosts();
+      await new CostsController(makeConfig(), costs, ecs).estimate();
+      expect(costs.estimateForSpec).toHaveBeenCalledWith(2048, 8192);
+    });
+
+    it('should sum costPerHour across all games for totalPerHourIfAllOn', async () => {
+      const config = makeConfig({ game_names: ['minecraft', 'palworld'] });
+      const costs = makeCosts();
+      vi.mocked(costs.estimateForSpec).mockReturnValue({ ...MOCK_ESTIMATE, costPerHour: 0.25 });
+      const result = await new CostsController(config, costs, makeEcs()).estimate();
+      // 2 games × $0.25/hr = $0.50/hr, rounded to 4 decimal places
+      expect(result.totalPerHourIfAllOn).toBe(0.5);
+    });
+
+    it('should include an estimate entry for each game', async () => {
+      const config = makeConfig({ game_names: ['minecraft', 'palworld'] });
+      const result = await new CostsController(config, makeCosts(), makeEcs()).estimate();
+      expect(Object.keys(result.games)).toEqual(['minecraft', 'palworld']);
+    });
+  });
+
+  describe('actual', () => {
+    it('should default to 7 days when the query param is absent', () => {
+      const costs = makeCosts();
+      new CostsController(makeConfig(), costs, makeEcs()).actual(undefined);
+      expect(costs.getActualCosts).toHaveBeenCalledWith(7);
+    });
+
+    it('should parse the days string and forward the integer to CostService', () => {
+      const costs = makeCosts();
+      new CostsController(makeConfig(), costs, makeEcs()).actual('14');
+      expect(costs.getActualCosts).toHaveBeenCalledWith(14);
+    });
+
+    it('should return whatever CostService returns', async () => {
+      const costs = makeCosts();
+      vi.mocked(costs.getActualCosts).mockResolvedValue({
+        daily: [{ date: '2026-05-01', cost: 1.23 }],
+        total: 1.23,
+        currency: 'USD',
+        days: 7,
+      });
+      const result = await new CostsController(makeConfig(), costs, makeEcs()).actual('7');
+      expect(result).toMatchObject({ total: 1.23, currency: 'USD' });
+    });
+  });
+});