elysium/apps/api/test/services/apotheosis.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 { describe, expect, it } from "vitest";
import {
  buildPostApotheosisState,
  isEligibleForApotheosis,
} from "../../src/services/apotheosis.js";
import { defaultTranscendenceUpgrades } from "../../src/data/transcendenceUpgrades.js";
import type { GameState } from "@elysium/types";

const ALL_UPGRADE_IDS = defaultTranscendenceUpgrades.map((u) => u.id);

const makeMinimalState = (overrides: Partial<GameState> = {}): GameState =>
  ({
    player: { discordId: "t", 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("isEligibleForApotheosis", () => {
  it("returns true when all transcendence upgrades are purchased", () => {
    const state = makeMinimalState({
      transcendence: {
        count: 1, echoes: 0, purchasedUpgradeIds: ALL_UPGRADE_IDS,
        echoIncomeMultiplier: 1, echoCombatMultiplier: 1,
        echoPrestigeThresholdMultiplier: 1, echoPrestigeRunestoneMultiplier: 1, echoMetaMultiplier: 1,
      },
    });
    expect(isEligibleForApotheosis(state)).toBe(true);
  });

  it("returns false when one upgrade is missing", () => {
    const partialIds = ALL_UPGRADE_IDS.slice(0, -1);
    const state = makeMinimalState({
      transcendence: {
        count: 1, echoes: 0, purchasedUpgradeIds: partialIds,
        echoIncomeMultiplier: 1, echoCombatMultiplier: 1,
        echoPrestigeThresholdMultiplier: 1, echoPrestigeRunestoneMultiplier: 1, echoMetaMultiplier: 1,
      },
    });
    expect(isEligibleForApotheosis(state)).toBe(false);
  });

  it("returns false when transcendence is undefined", () => {
    const state = makeMinimalState({ transcendence: undefined });
    expect(isEligibleForApotheosis(state)).toBe(false);
  });

  it("returns false when purchasedUpgradeIds is empty", () => {
    const state = makeMinimalState({
      transcendence: {
        count: 1, echoes: 0, purchasedUpgradeIds: [],
        echoIncomeMultiplier: 1, echoCombatMultiplier: 1,
        echoPrestigeThresholdMultiplier: 1, echoPrestigeRunestoneMultiplier: 1, echoMetaMultiplier: 1,
      },
    });
    expect(isEligibleForApotheosis(state)).toBe(false);
  });
});

describe("buildPostApotheosisState", () => {
  it("increments apotheosis count from 0", () => {
    const state = makeMinimalState();
    const { updatedApotheosisData } = buildPostApotheosisState(state, "T");
    expect(updatedApotheosisData.count).toBe(1);
  });

  it("increments apotheosis count from existing value", () => {
    const state = makeMinimalState({ apotheosis: { count: 2 } });
    const { updatedApotheosisData } = buildPostApotheosisState(state, "T");
    expect(updatedApotheosisData.count).toBe(3);
  });

  it("persists codex", () => {
    const codex = { entries: [{ id: "e1", unlockedAt: 1000, sourceType: "exploration" as const }] };
    const state = makeMinimalState({ codex });
    const { updatedState } = buildPostApotheosisState(state, "T");
    expect(updatedState.codex).toEqual(codex);
  });

  it("persists story", () => {
    const story = { unlockedChapterIds: ["ch1"], completedChapters: [] };
    const state = makeMinimalState({ story });
    const { updatedState } = buildPostApotheosisState(state, "T");
    expect(updatedState.story).toEqual(story);
  });

  it("wipes prestige data", () => {
    const state = makeMinimalState({
      prestige: { count: 10, runestones: 1000, productionMultiplier: 3, purchasedUpgradeIds: [] },
    });
    const { updatedState } = buildPostApotheosisState(state, "T");
    expect(updatedState.prestige.count).toBe(0);
    expect(updatedState.prestige.runestones).toBe(0);
  });

  it("sets apotheosis count on new state", () => {
    const state = makeMinimalState({ apotheosis: { count: 0 } });
    const { updatedState } = buildPostApotheosisState(state, "T");
    expect(updatedState.apotheosis?.count).toBe(1);
  });

  it("initialises goddess state on first apotheosis (count goes to 1)", () => {
    const state = makeMinimalState();
    const { updatedState } = buildPostApotheosisState(state, "T");
    expect(updatedState.goddess).toBeDefined();
  });

  it("preserves existing goddess state on second apotheosis (count goes to 2)", () => {
    const goddessState: GameState["goddess"] = {
      achievements:            [],
      baseClickPower:          1,
      bosses:                  [],
      consecration:            { count: 0, divinity: 0, productionMultiplier: 1, purchasedUpgradeIds: [] },
      disciples:               [],
      enlightenment:           { count: 0, purchasedUpgradeIds: [], stardust: 0, stardustCombatMultiplier: 1, stardustConsecrationDivinityMultiplier: 1, stardustConsecrationThresholdMultiplier: 1, stardustMetaMultiplier: 1, stardustPrayersMultiplier: 1 },
      equipment:               [],
      exploration:             { areas: [], craftedCombatMultiplier: 1, craftedDivinityMultiplier: 1, craftedPrayersMultiplier: 1, craftedRecipeIds: [], materials: [] },
      lastTickAt:              0,
      lifetimeBossesDefeated:  0,
      lifetimePrayersEarned:   0,
      lifetimeQuestsCompleted: 0,
      quests:                  [],
      totalPrayersEarned:      0,
      upgrades:                [],
      zones:                   [],
    };
    const state = makeMinimalState({ apotheosis: { count: 1 }, goddess: goddessState });
    const { updatedState } = buildPostApotheosisState(state, "T");
    expect(updatedState.goddess).toEqual(goddessState);
  });

  it("does not add goddess when count goes to 2 but no goddess exists on current state", () => {
    const state = makeMinimalState({ apotheosis: { count: 1 } });
    const { updatedState } = buildPostApotheosisState(state, "T");
    expect(updatedState.goddess).toBeUndefined();
  });
});