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

/* eslint-disable max-lines-per-function -- 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: {
    gameState: { findUnique: vi.fn(), update: 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();
  }),
}));

const DISCORD_ID = "test_discord_id";
// heartwood_tincture requires 5 verdant_sap + 3 forest_crystal
const TEST_RECIPE_ID = "heartwood_tincture";

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

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

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

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

  it("returns 400 when recipeId is missing", async () => {
    const res = await post({});
    expect(res.status).toBe(400);
  });

  it("returns 404 for unknown recipe", async () => {
    const res = await post({ recipeId: "nonexistent_recipe" });
    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({ recipeId: TEST_RECIPE_ID });
    expect(res.status).toBe(404);
  });

  it("returns 400 when no exploration state exists", async () => {
    const state = makeState({ exploration: undefined });
    vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
    const res = await post({ recipeId: TEST_RECIPE_ID });
    expect(res.status).toBe(400);
  });

  it("returns 400 when recipe is already crafted", async () => {
    const state = makeState({ exploration: { areas: [], materials: [], craftedRecipeIds: [TEST_RECIPE_ID], craftedGoldMultiplier: 1, craftedEssenceMultiplier: 1, craftedClickMultiplier: 1, craftedCombatMultiplier: 1 } });
    vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
    const res = await post({ recipeId: TEST_RECIPE_ID });
    expect(res.status).toBe(400);
  });

  it("returns 400 when not enough materials", async () => {
    const state = makeState({
      exploration: {
        areas: [],
        materials: [{ materialId: "verdant_sap", quantity: 1 }], // needs 5
        craftedRecipeIds: [],
        craftedGoldMultiplier: 1,
        craftedEssenceMultiplier: 1,
        craftedClickMultiplier: 1,
        craftedCombatMultiplier: 1,
      },
    });
    vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
    const res = await post({ recipeId: TEST_RECIPE_ID });
    expect(res.status).toBe(400);
  });

  it("returns 400 when second material is completely absent from list", async () => {
    // verdant_sap present (enough), but forest_crystal absent entirely — quantity ?? 0 = 0
    const state = makeState({
      exploration: {
        areas: [],
        materials: [{ materialId: "verdant_sap", quantity: 10 }],
        craftedRecipeIds: [],
        craftedGoldMultiplier: 1,
        craftedEssenceMultiplier: 1,
        craftedClickMultiplier: 1,
        craftedCombatMultiplier: 1,
      },
    });
    vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
    const res = await post({ recipeId: TEST_RECIPE_ID });
    expect(res.status).toBe(400);
  });

  it("returns craft result on success", async () => {
    const state = makeState();
    vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
    vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
    const res = await post({ recipeId: TEST_RECIPE_ID });
    expect(res.status).toBe(200);
    const body = await res.json() as { recipeId: string; bonusType: string };
    expect(body.recipeId).toBe(TEST_RECIPE_ID);
    expect(body.bonusType).toBe("gold_income");
  });

  it("updates crafting challenge progress and awards crystals when dailyChallenges is defined", async () => {
    const state = makeState({
      dailyChallenges: {
        date:       "2024-01-15",
        challenges: [
          {
            completed:      false,
            id:             "2024-01-15_crafting",
            label:          "Craft 1 recipe",
            progress:       0,
            rewardCrystals: 75,
            target:         1,
            type:           "crafting",
          },
        ],
      },
    });
    vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
    vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
    const res = await post({ recipeId: TEST_RECIPE_ID });
    expect(res.status).toBe(200);
    const updateArg = vi.mocked(prisma.gameState.update).mock.calls[0]![0] as {
      data: { state: GameState };
    };
    expect(updateArg.data.state.dailyChallenges?.challenges[0]?.completed).toBe(true);
    expect(updateArg.data.state.resources.crystals).toBe(75);
  });

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

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