Feature: fix/hackathon-portal-finish to dev

packages/api/src/.internal-tests/hackathon-admin-edge.test.ts

@@ -12,6 +12,8 @@ const mockUpdate = vi.fn();
 const mockDelete = vi.fn();
 // Row count returned by `select({ count })...from(<table>)`, keyed by table.
 const mockCount = vi.fn();
+/** maxParticipants as the capacity check reads it; undefined = uncapped. */
+const mockMaxParticipants = vi.fn<() => number | undefined>(() => undefined);
 // Acceptance emails are sent through a dynamic import; intercept it so we can
 // see exactly who a mass-approval actually mailed.
 const mockSendAcceptanceEmail = vi.fn();
@@ -101,7 +103,17 @@ vi.mock("@query/db", () => {
         },
       }),
       select: vi.fn().mockImplementation(() => ({
-        from: (tbl: any) => thenable([{ count: mockCount(tbl?._t) ?? 0 }]),
+        from: (tbl: any) => {
+          const count = mockCount(tbl?._t) ?? 0;
+          return thenable([
+            {
+              count,
+              n: count,
+              max:
+                tbl?._t === "hackathons" ? mockMaxParticipants() : undefined,
+            },
+          ]);
+        },
       })),
     },
     admins: {
@@ -266,6 +278,7 @@ describe("Hackathon admin management edge cases", () => {
     vi.clearAllMocks();
     cache.clear();
     mockCount.mockReturnValue(0);
+    mockMaxParticipants.mockImplementation(() => undefined);
     mockFindMany.mockReturnValue([]);
     mockInsert.mockReturnValue([{}]);
     mockUpdate.mockReturnValue([{}]);
@@ -345,6 +358,43 @@ describe("Hackathon admin management edge cases", () => {
       ).rejects.toThrow(/Admin access required/);
     });
 
+    // maxParticipants caps acceptances. Two seats, both taken: accepting one
+    // more is refused whole rather than going over.
+    it("refuses to accept past capacity", async () => {
+      const caller = adminCaller({}, "admin");
+      mockMaxParticipants.mockImplementation(() => 2);
+      const counts = [2, 1]; // seated, then newly accepted by this call
+      mockCount.mockImplementation((table: string) =>
+        table === "hackathonParticipants" ? counts.shift() : 0,
+      );
+
+      await expect(
+        caller.hackathon.batchUpdateParticipantStatus({
+          hackathonId: HACK_A,
+          participantIds: [PART_A1],
+          status: "approved",
+        }),
+      ).rejects.toThrow(/Only 0 seats left of 2/);
+    });
+
+    it("accepts while seats remain", async () => {
+      const caller = adminCaller({}, "admin");
+      mockMaxParticipants.mockImplementation(() => 2);
+      const counts = [1, 1];
+      mockCount.mockImplementation((table: string) =>
+        table === "hackathonParticipants" ? counts.shift() : 0,
+      );
+      mockUpdate.mockReturnValue([{ id: PART_A1, userId: "u1" }]);
+
+      await expect(
+        caller.hackathon.batchUpdateParticipantStatus({
+          hackathonId: HACK_A,
+          participantIds: [PART_A1],
+          status: "approved",
+        }),
+      ).resolves.toBeDefined();
+    });
+
     it("lets a volunteer work a check-in desk", async () => {
       const caller = volunteerCaller({
         hackathonEvents: { id: EVENT_A, hackathonId: HACK_A },

packages/api/src/.internal-tests/hackathon-flow.test.ts

@@ -6,6 +6,8 @@ import { db } from "@query/db";
 // Fully mock the DB at the file level. vi.mock factories are hoisted and
 // file-scoped, so this mirrors the shape used by routers.test.ts.
 const mockFindFirst = vi.fn();
+/** Rows a bare `await select().from().where()` resolves to. */
+const mockWhereRows = vi.fn<() => unknown[]>(() => [{ n: 1 }]);
 const mockFindMany = vi.fn();
 const mockInsert = vi.fn();
 const mockUpdate = vi.fn();
@@ -74,6 +76,9 @@ vi.mock("@query/db", () => {
       select: vi.fn().mockImplementation(() => ({
         from: vi.fn().mockImplementation(() => ({
           where: vi.fn().mockImplementation(() => ({
+            // Awaited directly: a count such as the judging queue check.
+            then: (ok: any, err: any) =>
+              Promise.resolve(mockWhereRows()).then(ok, err),
             orderBy: vi.fn().mockResolvedValue([{ count: 0 }]),
             groupBy: vi.fn().mockResolvedValue([]),
             limit: vi.fn().mockResolvedValue([]),
@@ -305,17 +310,20 @@ describe("Hackathon end-to-end flow", () => {
       );
     });
 
-    it("rejects registration when the hackathon is at capacity", async () => {
+    // Capacity caps acceptances, not applications: a full house still takes
+    // applications, and the seat is enforced when an organiser accepts.
+    it("takes an application when every seat is already taken", async () => {
       mockFindFirst.mockImplementation((table) =>
         table === "hackathons"
           ? openHackathon({ maxParticipants: 500, currentParticipants: 500 })
           : undefined,
       );
       const caller = appRouter.createCaller(createMockCtx("user_a"));
 
-      await expect(caller.hackathon.register(registrationInput())).rejects.toThrow(
-        /full/,
-      );
+      const outcome = await caller.hackathon
+        .register(registrationInput())
+        .catch((error: unknown) => error);
+      expect(String((outcome as Error)?.message ?? "")).not.toMatch(/full/);
     });
   });
 
@@ -541,6 +549,7 @@ describe("Hackathon end-to-end flow", () => {
 
     it("only lets an admin toggle judging on", async () => {
       const caller = adminCaller();
+      mockWhereRows.mockReturnValueOnce([{ n: 12 }]);
       mockUpdate.mockReturnValue([{ judgingActive: true }]);
 
       const res = await caller.judge.toggleJudging({
@@ -550,6 +559,17 @@ describe("Hackathon end-to-end flow", () => {
       expect(res).toMatchObject({ success: true, judgingActive: true });
     });
 
+    // With nothing queued every judge opened straight onto "All done, 0 of 0".
+    it("refuses to open judging before any judge has a table", async () => {
+      const caller = adminCaller();
+      mockWhereRows.mockReturnValueOnce([{ n: 0 }]);
+
+      await expect(
+        caller.judge.toggleJudging({ hackathonId: HACK_A, active: true }),
+      ).rejects.toMatchObject({ code: "PRECONDITION_FAILED" });
+      expect(mockUpdate).not.toHaveBeenCalled();
+    });
+
     it("refuses to let a non-admin toggle judging", async () => {
       mockFindFirst.mockImplementation(() => undefined);
       const caller = appRouter.createCaller(createMockCtx("random_user"));
@@ -604,12 +624,14 @@ describe("Hackathon end-to-end flow", () => {
       maxMembers: 4 as const,
     };
 
-    it("refuses team creation before the window opens at +12h", async () => {
-      const caller = teamCaller(2);
+    // Accepted hackers can find teammates before kickoff.
+    it("allows team creation before hacking starts", async () => {
+      const caller = teamCaller(-48);
+      mockInsert.mockReturnValue([{ id: "team_1", name: "meow" }]);
 
-      await expect(caller.team.createTeam(newTeam)).rejects.toThrow(
-        /not open yet/,
-      );
+      await expect(caller.team.createTeam(newTeam)).resolves.toMatchObject({
+        name: "meow",
+      });
     });
 
     it("allows team creation inside the window", async () => {
@@ -649,18 +671,21 @@ describe("Hackathon end-to-end flow", () => {
       expect(res.canLeave).toBe(false);
     });
 
+    // Teams form from acceptance, not from +12h: two hours in, an accepted
+    // hacker can already create, join and leave.
     it("reports the window so the UI can disable instead of failing", async () => {
       const caller = teamCaller(2);
 
       const res = await caller.team.window({ hackathonId: HACK_A });
       expect(res).toMatchObject({
-        isOpen: false,
-        canCreate: false,
-        canJoin: false,
-        canLeave: false,
+        isOpen: true,
+        canCreate: true,
+        canJoin: true,
+        canLeave: true,
+        opensAt: null,
       });
-      expect(res.leaveLocksAt.getTime() - res.opensAt.getTime()).toBe(
-        12 * HOUR,
+      expect(res.closesAt.getTime() - res.leaveLocksAt.getTime()).toBe(
+        10 * HOUR,
       );
     });
   });

packages/api/src/.internal-tests/judge-edge.test.ts

@@ -1264,22 +1264,23 @@ describe("Judge edge cases", () => {
     });
 
     /**
-     * Activating and deactivating a person is the super-admin tier. A plain
-     * admin runs the event; deciding who holds a role does not come with that.
+     * Approving a judge is part of running the event, so any admin may; it
+     * was super-admin only while every admin saw the button. Deleting the
+     * judge, votes and all, stays super-admin.
      */
-    it("refuses a plain admin, and writes nothing", async () => {
+    it("lets a plain admin approve a judge but not remove one", async () => {
       mockFindFirst.mockImplementation((table: string) =>
         table === "admins" ? PLAIN_ADMIN_ROW : undefined,
       );
 
-      await expect(
-        adminCaller().judge.setActive({ judgeId: JUDGE_ID, isActive: true }),
-      ).rejects.toMatchObject({ code: "FORBIDDEN" });
+      const approval = await adminCaller()
+        .judge.setActive({ judgeId: JUDGE_ID, isActive: true })
+        .catch((error: unknown) => error);
+      expect((approval as { code?: string })?.code).not.toBe("FORBIDDEN");
+
       await expect(
         adminCaller().judge.remove({ judgeId: JUDGE_ID }),
       ).rejects.toMatchObject({ code: "FORBIDDEN" });
-
-      expect(mockUpdate).not.toHaveBeenCalled();
       expect(mockDelete).not.toHaveBeenCalled();
     });