generated from nhcarrigan/template
hikari
e742c3a6ef
- fix: boss signature chain maintained through fight results (#148) - fix: militia cost curve smoothed (100g -> 65g) (#145) - fix: crystal_shard buffed to epic tier (1.65x/1.2x -> 1.9x/1.3x) (#144) - fix: click_power recipe ceiling raised and z13-18 progression smoothed (#142) - close: elder_bark_shield, void_fragment_amulet, soul_bound_catalyst already at target values (#143)
407 lines
18 KiB
TypeScript
407 lines
18 KiB
TypeScript
/* 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: {
|
|
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";
|
|
|
|
const makeBoss = (overrides: Record<string, unknown> = {}) => ({
|
|
id: "test_boss",
|
|
zoneId: "test_zone",
|
|
status: "available",
|
|
prestigeRequirement: 0,
|
|
currentHp: 100,
|
|
maxHp: 100,
|
|
damagePerSecond: 1,
|
|
goldReward: 50,
|
|
essenceReward: 10,
|
|
crystalReward: 0,
|
|
upgradeRewards: [] as string[],
|
|
equipmentRewards: [] as string[],
|
|
...overrides,
|
|
});
|
|
|
|
const makeAdventurer = (overrides: Record<string, unknown> = {}) => ({
|
|
id: "test_adventurer",
|
|
count: 1,
|
|
combatPower: 10000, // Very high DPS to guarantee win
|
|
level: 10,
|
|
unlocked: true,
|
|
goldPerSecond: 1,
|
|
essencePerSecond: 0,
|
|
...overrides,
|
|
});
|
|
|
|
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: [], 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("boss route", () => {
|
|
let app: Hono;
|
|
let prisma: { gameState: { findUnique: ReturnType<typeof vi.fn>; update: ReturnType<typeof vi.fn> } };
|
|
|
|
beforeEach(async () => {
|
|
vi.clearAllMocks();
|
|
const { bossRouter } = await import("../../src/routes/boss.js");
|
|
const { prisma: p } = await import("../../src/db/client.js");
|
|
prisma = p as typeof prisma;
|
|
app = new Hono();
|
|
app.route("/boss", bossRouter);
|
|
});
|
|
|
|
const challenge = (body: Record<string, unknown>) =>
|
|
app.fetch(new Request("http://localhost/boss/challenge", {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify(body),
|
|
}));
|
|
|
|
it("returns 400 when bossId is missing", async () => {
|
|
const res = await challenge({});
|
|
expect(res.status).toBe(400);
|
|
});
|
|
|
|
it("returns 404 when no save is found", async () => {
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce(null);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(404);
|
|
});
|
|
|
|
it("returns 404 when boss is not in state", async () => {
|
|
const state = makeState({ bosses: [] });
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(404);
|
|
});
|
|
|
|
it("returns 400 when boss is already defeated", async () => {
|
|
const state = makeState({ bosses: [makeBoss({ status: "defeated" })] as GameState["bosses"] });
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(400);
|
|
});
|
|
|
|
it("returns 403 when prestige requirement is not met", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ prestigeRequirement: 5 })] as GameState["bosses"],
|
|
prestige: { count: 0, runestones: 0, productionMultiplier: 1, purchasedUpgradeIds: [] },
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(403);
|
|
});
|
|
|
|
it("returns 400 when party has no adventurers", async () => {
|
|
const state = makeState({ bosses: [makeBoss()] as GameState["bosses"], adventurers: [] });
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(400);
|
|
});
|
|
|
|
it("returns won=true when party defeats boss", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 })] as GameState["bosses"],
|
|
adventurers: [makeAdventurer({ combatPower: 10000, count: 1, level: 10 })] as GameState["adventurers"],
|
|
zones: [{ id: "test_zone", status: "locked" }] as GameState["zones"],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean; rewards: { gold: number } };
|
|
expect(body.won).toBe(true);
|
|
expect(body.rewards.gold).toBe(50);
|
|
});
|
|
|
|
it("returns won=false when party is defeated", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 1_000_000, maxHp: 1_000_000, damagePerSecond: 1_000_000 })] as GameState["bosses"],
|
|
// Include an adventurer with count=0 to cover the casualty-loop skip branch
|
|
adventurers: [
|
|
makeAdventurer({ combatPower: 1, count: 10, level: 1 }),
|
|
makeAdventurer({ id: "zero_count_adventurer", combatPower: 0, count: 0, level: 1 }),
|
|
] as GameState["adventurers"],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean; casualties: Array<{ adventurerId: string }> };
|
|
expect(body.won).toBe(false);
|
|
expect(Array.isArray(body.casualties)).toBe(true);
|
|
});
|
|
|
|
it("skips zone unlock when zone is already unlocked and bossId matches", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 })] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
// Zone is already unlocked — the loop should skip it via the status==="unlocked" continue
|
|
zones: [{ id: "test_zone", status: "unlocked", unlockBossId: "test_boss", unlockQuestId: null }] as GameState["zones"],
|
|
quests: [],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean };
|
|
expect(body.won).toBe(true);
|
|
});
|
|
|
|
it("skips zone unlock when quest condition is not satisfied", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 })] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
// Zone has unlockBossId matching but the required quest is not completed
|
|
zones: [{ id: "test_zone", status: "locked", unlockBossId: "test_boss", unlockQuestId: "required_quest" }] as GameState["zones"],
|
|
quests: [{ id: "required_quest", status: "active" }] as GameState["quests"],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean };
|
|
expect(body.won).toBe(true);
|
|
});
|
|
|
|
it("unlocks next zone boss when boss is defeated and zone condition is met", async () => {
|
|
const nextBoss = makeBoss({ id: "next_boss", status: "locked", prestigeRequirement: 0 });
|
|
const state = makeState({
|
|
bosses: [
|
|
makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 }),
|
|
nextBoss,
|
|
] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
zones: [{ id: "test_zone", status: "locked", unlockBossId: "test_boss", unlockQuestId: null }] as GameState["zones"],
|
|
quests: [],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean };
|
|
expect(body.won).toBe(true);
|
|
});
|
|
|
|
it("handles boss with upgrade and equipment rewards on win", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({
|
|
upgradeRewards: ["some_upgrade"],
|
|
equipmentRewards: ["some_equipment"],
|
|
})] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
upgrades: [{ id: "some_upgrade", purchased: false, unlocked: false, target: "global", multiplier: 1 }] as GameState["upgrades"],
|
|
equipment: [{ id: "some_equipment", owned: false, equipped: false, type: "weapon", bonus: {} }] as GameState["equipment"],
|
|
zones: [],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean; rewards: { upgradeIds: string[]; equipmentIds: string[] } };
|
|
expect(body.won).toBe(true);
|
|
expect(body.rewards.upgradeIds).toContain("some_upgrade");
|
|
expect(body.rewards.equipmentIds).toContain("some_equipment");
|
|
});
|
|
|
|
it("updates daily challenge progress on boss defeat", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss()] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
zones: [],
|
|
dailyChallenges: {
|
|
date: "2024-01-01",
|
|
challenges: [{ id: "boss_challenge", type: "bossesDefeated", target: 3, progress: 0, completed: false, crystalReward: 5 }],
|
|
} as GameState["dailyChallenges"],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
});
|
|
|
|
it("applies adventurer-specific upgrade to party DPS", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 })] as GameState["bosses"],
|
|
adventurers: [makeAdventurer({ id: "test_adventurer" })] as GameState["adventurers"],
|
|
upgrades: [{ id: "adv_upgrade", purchased: true, unlocked: true, target: "adventurer", adventurerId: "test_adventurer", multiplier: 2 }] as GameState["upgrades"],
|
|
zones: [],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean };
|
|
expect(body.won).toBe(true);
|
|
});
|
|
|
|
it("applies global upgrade multiplier to party DPS when global upgrade is purchased", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 })] as GameState["bosses"],
|
|
adventurers: [makeAdventurer({ combatPower: 10000, count: 1 })] as GameState["adventurers"],
|
|
upgrades: [{ id: "global_1", purchased: true, unlocked: true, target: "global", multiplier: 2 }] as GameState["upgrades"],
|
|
zones: [],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean };
|
|
expect(body.won).toBe(true);
|
|
});
|
|
|
|
it("unlocks zone when boss defeated and quest condition is also satisfied", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 })] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
zones: [{ id: "test_zone", status: "locked", unlockBossId: "test_boss", unlockQuestId: "test_quest" }] as GameState["zones"],
|
|
quests: [{ id: "test_quest", status: "completed" }] as GameState["quests"],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean };
|
|
expect(body.won).toBe(true);
|
|
});
|
|
|
|
it("handles zone unlock gracefully when exploration state is undefined", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 })] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
zones: [{ id: "test_zone", status: "locked", unlockBossId: "test_boss", unlockQuestId: null }] as GameState["zones"],
|
|
quests: [],
|
|
exploration: undefined,
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean };
|
|
expect(body.won).toBe(true);
|
|
});
|
|
|
|
it("unlocks exploration areas when a zone is unlocked on boss defeat", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({ currentHp: 100, maxHp: 100, damagePerSecond: 1 })] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
zones: [{ id: "test_zone", status: "locked", unlockBossId: "test_boss", unlockQuestId: null }] as GameState["zones"],
|
|
quests: [],
|
|
exploration: {
|
|
areas: [{ id: "test_area", status: "locked" as const }],
|
|
materials: [],
|
|
craftedRecipeIds: [],
|
|
craftedGoldMultiplier: 1,
|
|
craftedEssenceMultiplier: 1,
|
|
craftedClickMultiplier: 1,
|
|
craftedCombatMultiplier: 1,
|
|
},
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
let savedState: GameState | undefined;
|
|
vi.mocked(prisma.gameState.update).mockImplementationOnce(async (args) => {
|
|
/* eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Test assertion */
|
|
savedState = (args as { data: { state: GameState } }).data.state;
|
|
return {} as never;
|
|
});
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
// Exploration area should remain locked — no matching defaultExploration for "test_area"
|
|
const area = savedState?.exploration?.areas.find((a) => a.id === "test_area");
|
|
expect(area?.status).toBe("locked");
|
|
});
|
|
|
|
it("includes HMAC signature in response when ANTI_CHEAT_SECRET is set", async () => {
|
|
process.env.ANTI_CHEAT_SECRET = "test_secret";
|
|
const state = makeState({
|
|
bosses: [makeBoss()] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
zones: [],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { signature: string | undefined };
|
|
expect(body.signature).toBeDefined();
|
|
delete process.env.ANTI_CHEAT_SECRET;
|
|
});
|
|
|
|
it("omits signature in response when ANTI_CHEAT_SECRET is not set", async () => {
|
|
delete process.env.ANTI_CHEAT_SECRET;
|
|
const state = makeState({
|
|
bosses: [makeBoss()] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
zones: [],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { signature: string | undefined };
|
|
expect(body.signature).toBeUndefined();
|
|
});
|
|
|
|
it("returns 500 when the database throws", async () => {
|
|
vi.mocked(prisma.gameState.findUnique).mockRejectedValueOnce(new Error("DB error"));
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
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 challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(500);
|
|
});
|
|
|
|
it("does not re-award bounty runestones when bountyRunestonesClaimed is true", async () => {
|
|
const state = makeState({
|
|
bosses: [makeBoss({
|
|
bountyRunestonesClaimed: true,
|
|
currentHp: 100,
|
|
damagePerSecond: 1,
|
|
maxHp: 100,
|
|
})] as GameState["bosses"],
|
|
adventurers: [makeAdventurer()] as GameState["adventurers"],
|
|
prestige: { count: 0, productionMultiplier: 1, purchasedUpgradeIds: [], runestones: 5 },
|
|
zones: [],
|
|
});
|
|
vi.mocked(prisma.gameState.findUnique).mockResolvedValueOnce({ state } as never);
|
|
vi.mocked(prisma.gameState.update).mockResolvedValueOnce({} as never);
|
|
const res = await challenge({ bossId: "test_boss" });
|
|
expect(res.status).toBe(200);
|
|
const body = await res.json() as { won: boolean; rewards: { bountyRunestones: number } };
|
|
expect(body.won).toBe(true);
|
|
expect(body.rewards.bountyRunestones).toBe(0);
|
|
});
|
|
});
|