add unit tests for untested jobs, controllers, and services

Cover match jobs (CleanAbandonedMatches, CancelInvalidTournaments,
CheckForScheduledMatches), matchmaking jobs (CancelMatchMaking,
MarkPlayerOffline), matches controller actions/events (schedule, start,
cancel, forfeit, setWinner, join/leave/switch lineup, delete, checkIn,
server availability, veto pick, lineup players), tournaments controller,
auth controller, and encryption service. 70 new test cases total.

Author: Flegma

src/auth/auth.controller.spec.ts

@@ -0,0 +1,161 @@
+jest.mock("@kubernetes/client-node", () => ({
+  KubeConfig: jest.fn(),
+  BatchV1Api: jest.fn(),
+  CoreV1Api: jest.fn(),
+  Exec: jest.fn(),
+}));
+
+import { Logger, BadRequestException } from "@nestjs/common";
+import { AuthController } from "./auth.controller";
+
+function createController() {
+  const cache = {
+    get: jest.fn().mockResolvedValue(undefined),
+  };
+  const hasura = {
+    mutation: jest.fn().mockResolvedValue({}),
+  };
+  const redisConnection = {
+    del: jest.fn().mockResolvedValue(1),
+  };
+  const redis = {
+    getConnection: jest.fn().mockReturnValue(redisConnection),
+  };
+  const apiKeys = {
+    createApiKey: jest.fn().mockResolvedValue("generated-key-123"),
+  };
+  const logger = {
+    log: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+  } as unknown as Logger;
+
+  const controller = new AuthController(
+    cache as any,
+    hasura as any,
+    redis as any,
+    apiKeys as any,
+    logger,
+  );
+
+  return { controller, cache, hasura, redis, redisConnection, apiKeys, logger };
+}
+
+function makeRequest(overrides: Record<string, any> = {}) {
+  return {
+    user: {
+      steam_id: "76561198000000001",
+      name: "TestPlayer",
+      role: "user",
+      discord_id: "discord-123",
+      ...overrides.user,
+    },
+    session: {
+      id: "session-id-1",
+      save: jest.fn(),
+      destroy: jest.fn((cb) => cb(null)),
+      ...overrides.session,
+    },
+    ...overrides,
+  } as any;
+}
+
+describe("AuthController", () => {
+  describe("me", () => {
+    it("returns user with cached name and role", async () => {
+      const { controller, cache } = createController();
+
+      cache.get
+        .mockResolvedValueOnce("CachedName")
+        .mockResolvedValueOnce("admin");
+
+      const request = makeRequest();
+      const result = await controller.me(request);
+
+      expect(result.name).toBe("CachedName");
+      expect(result.role).toBe("admin");
+    });
+  });
+
+  describe("unlinkDiscord", () => {
+    it("removes discord_id via Hasura mutation", async () => {
+      const { controller, hasura } = createController();
+      const request = makeRequest();
+
+      await controller.unlinkDiscord(request);
+
+      expect(hasura.mutation).toHaveBeenCalledWith(
+        expect.objectContaining({
+          update_players_by_pk: expect.objectContaining({
+            __args: expect.objectContaining({
+              pk_columns: { steam_id: "76561198000000001" },
+              _set: { discord_id: null },
+            }),
+          }),
+        }),
+      );
+    });
+
+    it("clears discord_id from session user", async () => {
+      const { controller } = createController();
+      const request = makeRequest();
+
+      await controller.unlinkDiscord(request);
+
+      expect(request.user.discord_id).toBeNull();
+      expect(request.session.save).toHaveBeenCalled();
+    });
+  });
+
+  describe("logout", () => {
+    it("destroys session and deletes Redis latency key", async () => {
+      const { controller, redisConnection } = createController();
+      const request = makeRequest();
+
+      await controller.logout(request);
+
+      expect(redisConnection.del).toHaveBeenCalledWith(
+        expect.stringContaining("session-id-1"),
+      );
+      expect(request.session.destroy).toHaveBeenCalled();
+    });
+
+    it("handles missing session gracefully", async () => {
+      const { controller } = createController();
+      const request = { session: null } as any;
+
+      const result = await controller.logout(request);
+
+      expect(result).toEqual({ success: true });
+    });
+  });
+
+  describe("createApiKey", () => {
+    it("throws BadRequestException when label is empty", async () => {
+      const { controller } = createController();
+
+      await expect(
+        controller.createApiKey({
+          user: { steam_id: "76561198000000001" } as any,
+          label: "",
+        }),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it("returns key from ApiKeys service", async () => {
+      const { controller, apiKeys } = createController();
+      apiKeys.createApiKey.mockResolvedValueOnce("my-api-key");
+
+      const result = await controller.createApiKey({
+        user: { steam_id: "76561198000000001" } as any,
+        label: "My Key",
+      });
+
+      expect(result).toEqual({ key: "my-api-key" });
+      expect(apiKeys.createApiKey).toHaveBeenCalledWith(
+        "My Key",
+        "76561198000000001",
+      );
+    });
+  });
+});

src/encryption/encryption.service.spec.ts

@@ -0,0 +1,87 @@
+jest.mock("openpgp", () => ({
+  readMessage: jest.fn(),
+  decrypt: jest.fn(),
+}));
+
+import { Logger } from "@nestjs/common";
+import { EncryptionService } from "./encryption.service";
+import { readMessage, decrypt } from "openpgp";
+
+const mockReadMessage = readMessage as jest.MockedFunction<typeof readMessage>;
+const mockDecrypt = decrypt as jest.MockedFunction<typeof decrypt>;
+
+function createService() {
+  const config = {
+    get: jest.fn().mockReturnValue({ appKey: "test-app-key" }),
+  };
+  const logger = {
+    log: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+  } as unknown as Logger;
+
+  const service = new EncryptionService(logger, config as any);
+
+  return { service, logger };
+}
+
+describe("EncryptionService", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("decrypt", () => {
+    it("strips \\x prefix from Hasura hex", async () => {
+      const { service } = createService();
+      const fakeMessage = { type: "message" };
+
+      mockReadMessage.mockResolvedValueOnce(fakeMessage as any);
+      mockDecrypt.mockResolvedValueOnce({ data: "decrypted-value" } as any);
+
+      await service.decrypt("\\x48656c6c6f");
+
+      expect(mockReadMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          binaryMessage: expect.any(Uint8Array),
+        }),
+      );
+
+      // Verify the hex was decoded correctly (48656c6c6f = "Hello")
+      const callArg = mockReadMessage.mock.calls[0][0] as any;
+      expect(callArg.binaryMessage).toEqual(
+        new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]),
+      );
+    });
+
+    it("calls openpgp decrypt with correct password", async () => {
+      const { service } = createService();
+      const fakeMessage = { type: "message" };
+
+      mockReadMessage.mockResolvedValueOnce(fakeMessage as any);
+      mockDecrypt.mockResolvedValueOnce({
+        data: "decrypted-result",
+      } as any);
+
+      const result = await service.decrypt("aabbcc");
+
+      expect(mockDecrypt).toHaveBeenCalledWith({
+        format: "utf8",
+        message: fakeMessage,
+        passwords: ["test-app-key"],
+      });
+      expect(result).toBe("decrypted-result");
+    });
+
+    it("throws and logs on decryption failure", async () => {
+      const { service, logger } = createService();
+
+      mockReadMessage.mockRejectedValueOnce(new Error("bad data"));
+
+      await expect(service.decrypt("invalid-hex")).rejects.toThrow("bad data");
+      expect(logger.error).toHaveBeenCalledWith(
+        "Error decrypting data:",
+        expect.any(Error),
+      );
+    });
+  });
+});

src/matches/jobs/CancelInvalidTournaments.spec.ts

@@ -0,0 +1,79 @@
+import { Logger } from "@nestjs/common";
+import { CancelInvalidTournaments } from "./CancelInvalidTournaments";
+
+function createProcessor() {
+  const hasura = {
+    mutation: jest
+      .fn()
+      .mockResolvedValue({ update_tournaments: { affected_rows: 0 } }),
+  };
+  const logger = {
+    log: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+  } as unknown as Logger;
+
+  const processor = new CancelInvalidTournaments(logger, hasura as any);
+
+  return { processor, hasura, logger };
+}
+
+describe("CancelInvalidTournaments", () => {
+  it("cancels tournaments without min teams past start date", async () => {
+    const { processor, hasura } = createProcessor();
+
+    hasura.mutation.mockResolvedValueOnce({
+      update_tournaments: { affected_rows: 2 },
+    });
+
+    const count = await processor.process();
+
+    expect(count).toBe(2);
+    expect(hasura.mutation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        update_tournaments: expect.objectContaining({
+          __args: expect.objectContaining({
+            where: expect.objectContaining({
+              _and: expect.arrayContaining([
+                expect.objectContaining({
+                  status: { _eq: "RegistrationOpen" },
+                }),
+                expect.objectContaining({
+                  has_min_teams: { _eq: false },
+                }),
+                expect.objectContaining({
+                  start: { _gte: expect.any(Date) },
+                }),
+              ]),
+            }),
+          }),
+        }),
+      }),
+    );
+  });
+
+  it("logs count when tournaments are cancelled", async () => {
+    const { processor, hasura, logger } = createProcessor();
+
+    hasura.mutation.mockResolvedValueOnce({
+      update_tournaments: { affected_rows: 4 },
+    });
+
+    await processor.process();
+
+    expect(logger.log).toHaveBeenCalledWith("4 matches started");
+  });
+
+  it("returns 0 and does not log when none found", async () => {
+    const { processor, hasura, logger } = createProcessor();
+
+    hasura.mutation.mockResolvedValueOnce({
+      update_tournaments: { affected_rows: 0 },
+    });
+
+    const count = await processor.process();
+
+    expect(count).toBe(0);
+    expect(logger.log).not.toHaveBeenCalled();
+  });
+});