elysium/apps/api/test/routes/prestige.spec.ts

/* eslint-disable max-lines-per-function -- Test suites naturally have many cases */
/* eslint-disable max-lines -- Test suites naturally have many cases */
/* eslint-disable @typescript-eslint/consistent-type-assertions -- Tests build minimal state objects */
import { beforeEach, describe, expect, it, vi } from "vitest";
import { Hono } from "hono";
import type { GameState } from "@elysium/types";

vi.mock("../../src/db/client.js", () => ({
  prisma: {
    player: { findUnique: vi.fn(), update: vi.fn() },
    gameState: { findUnique: vi.fn(), update: vi.fn(), updateMany: vi.fn() },
  },
}));

vi.mock("../../src/middleware/auth.js", () => ({
  authMiddleware: vi.fn(async (c: { set: (key: string, value: string) => void }, next: () => Promise<void>) => {
    c.set("discordId", "test_discord_id");
    await next();
  }),
}));

vi.mock("../../src/services/webhook.js", () => ({
  postMilestoneWebhook: vi.fn().mockResolvedValue(undefined),
}));

const DISCORD_ID = "test_discord_id";

const makeState = (overrides: Partial<GameState> = {}): GameState => ({
  player: { discordId: DISCORD_ID, username: "u", discriminator: "0", avatar: null, totalGoldEarned: 1_000_000, totalClicks: 0, characterName: "T" },
  resources: { gold: 0, essence: 0, crystals: 0, runestones: 0 },
  adventurers: [],
  upgrades: [],
  quests: [],
  bosses: [],
  equipment: [],
  achievements: [],
  zones: [],
  exploration: { areas: [], materials: [], craftedRecipeIds: [], craftedGoldMultiplier: 1, craftedEssenceMultiplier: 1, craftedClickMultiplier: 1, craftedCombatMultiplier: 1 },
  companions: { unlockedCompanionIds: [], activeCompanionId: null },
  prestige: { count: 0, runestones: 100, productionMultiplier: 1, purchasedUpgradeIds: [] },
  baseClickPower: 1,
  lastTickAt: 0,
  schemaVersion: 1,
  ...overrides,
} as GameState);

describe("prestige route", () => {
  let app: Hono;
  let prisma: {
    player: { findUnique: ReturnType<typeof vi.fn>; update: ReturnType<typeof vi.fn> };
    gameState: { findUnique: ReturnType<typeof vi.fn>; update: ReturnType<typeof vi.fn>; updateMany: ReturnType<typeof vi.fn> };
  };

  beforeEach(async () => {
    vi.clearAllMocks();
    const { prestigeRouter } = await import("../../src/routes/prestige.js");
    const { prisma: p } = await import("../../src/db/client.js");
    prisma = p as typeof prisma;
    app = new Hono();
    app.route("/prestige", prestigeRouter);
  });

  const post = (path: string, body?: Record<string, unknown>) =>
    app.fetch(new Request(`http://localhost/prestige${path}`, {
      method: "POST",
      headers: body ? { "Content-Type": "application/json" } : undefined,
      body: body ? JSON.stringify(body) : undefined,
    }));

  describe("POST /", () => {
    it("returns 404 when no save is found", async () => {
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce(null);
      const res = await post("");
      expect(res.status).toBe(404);
    });

    it("returns 400 when not eligible (not enough gold)", async () => {
      const state = makeState({ player: { discordId: DISCORD_ID, username: "u", discriminator: "0", avatar: null, totalGoldEarned: 0, totalClicks: 0, characterName: "T" } });
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
      const res = await post("");
      expect(res.status).toBe(400);
    });

    it("returns runestones on successful prestige", async () => {
      const state = makeState();
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state, updatedAt: 0 } as never);
      vi.mocked(prisma.gameState.updateMany).mockResolvedValueOnce({ count: 1 } as never);
      vi.mocked(prisma.player.update).mockResolvedValueOnce({} as never);
      const res = await post("");
      expect(res.status).toBe(200);
      const body = await res.json() as { runestones: number; newPrestigeCount: number };
      expect(body.newPrestigeCount).toBe(1);
      expect(body.runestones).toBeGreaterThanOrEqual(0);
    });

    it("returns 409 when a concurrent prestige already committed", async () => {
      const state = makeState();
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state, updatedAt: 0 } as never);
      vi.mocked(prisma.gameState.updateMany).mockResolvedValueOnce({ count: 0 } as never);
      const res = await post("");
      expect(res.status).toBe(409);
    });

    it("returns 500 when the database throws during prestige", async () => {
      vi.mocked(prisma.gameState.findUnique).mockRejectedValueOnce(new Error("DB error"));
      const res = await post("");
      expect(res.status).toBe(500);
    });

    it("returns 500 when the database throws a non-Error value during prestige", async () => {
      vi.mocked(prisma.gameState.findUnique).mockRejectedValueOnce("raw string error");
      const res = await post("");
      expect(res.status).toBe(500);
    });

    it("updates daily challenge progress when dailyChallenges are set", async () => {
      const state = makeState({
        dailyChallenges: {
          date: "2024-01-01",
          challenges: [{ id: "prestige_challenge", type: "prestige", target: 2, progress: 0, completed: false, crystalReward: 5 }],
        } as GameState["dailyChallenges"],
      });
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state, updatedAt: 0 } as never);
      vi.mocked(prisma.gameState.updateMany).mockResolvedValueOnce({ count: 1 } as never);
      vi.mocked(prisma.player.update).mockResolvedValueOnce({} as never);
      const res = await post("");
      expect(res.status).toBe(200);
      const body = await res.json() as { runestones: number; newPrestigeCount: number };
      expect(body.newPrestigeCount).toBe(1);
    });

    it("skips webhook when enablePrestigeAnnouncements is false", async () => {
      const { postMilestoneWebhook } = await import("../../src/services/webhook.js");
      const state = makeState();
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state, updatedAt: 0 } as never);
      vi.mocked(prisma.gameState.updateMany).mockResolvedValueOnce({ count: 1 } as never);
      vi.mocked(prisma.player.update).mockResolvedValueOnce({} as never);
      vi.mocked(prisma.player.findUnique).mockResolvedValueOnce({ profileSettings: { enablePrestigeAnnouncements: false } } as never);
      const res = await post("");
      expect(res.status).toBe(200);
      expect(postMilestoneWebhook).not.toHaveBeenCalledWith(expect.anything(), "prestige", expect.anything());
    });
  });

  describe("POST /buy-upgrade", () => {
    it("returns 400 when upgradeId is missing", async () => {
      const res = await post("/buy-upgrade", {});
      expect(res.status).toBe(400);
    });

    it("returns 404 for unknown upgrade", async () => {
      const res = await post("/buy-upgrade", { upgradeId: "nonexistent_upgrade" });
      expect(res.status).toBe(404);
    });

    it("returns 404 when no save is found", async () => {
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce(null);
      const res = await post("/buy-upgrade", { upgradeId: "income_1" });
      expect(res.status).toBe(404);
    });

    it("returns 400 when upgrade is already purchased", async () => {
      const state = makeState({ prestige: { count: 0, runestones: 100, productionMultiplier: 1, purchasedUpgradeIds: ["income_1"] } });
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
      const res = await post("/buy-upgrade", { upgradeId: "income_1" });
      expect(res.status).toBe(400);
    });

    it("returns 400 when not enough runestones", async () => {
      const state = makeState({ prestige: { count: 0, runestones: 0, productionMultiplier: 1, purchasedUpgradeIds: [] } });
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
      // income_1 costs 10 runestones but state has 0
      const res = await post("/buy-upgrade", { upgradeId: "income_1" });
      expect(res.status).toBe(400);
    });

    it("returns updated multipliers on successful purchase", async () => {
      const state = makeState({ prestige: { count: 0, runestones: 100, productionMultiplier: 1, purchasedUpgradeIds: [] } });
      vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
      vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
      const res = await post("/buy-upgrade", { upgradeId: "income_1" });
      expect(res.status).toBe(200);
      const body = await res.json() as { runestonesRemaining: number; purchasedUpgradeIds: string[] };
      expect(body.runestonesRemaining).toBe(90); // 100 - 10
      expect(body.purchasedUpgradeIds).toContain("income_1");
    });

    it("returns 500 when the database throws during buy-upgrade", async () => {
      vi.mocked(prisma.gameState.findUnique).mockRejectedValueOnce(new Error("DB error"));
      const res = await post("/buy-upgrade", { upgradeId: "income_1" });
      expect(res.status).toBe(500);
    });

    it("returns 500 when the database throws a non-Error value during buy-upgrade", async () => {
      vi.mocked(prisma.gameState.findUnique).mockRejectedValueOnce("raw string error");
      const res = await post("/buy-upgrade", { upgradeId: "income_1" });
      expect(res.status).toBe(500);
    });
  });
});