elysium/apps/api/test/services/resetHelpers.spec.ts

import { describe, expect, it } from "vitest";
import {
  preserveBossHistory,
  preserveEquipmentHistory,
  preserveQuestHistory,
} from "../../src/services/resetHelpers.js";
import type { Boss, Equipment, Quest } from "@elysium/types";

const makeItem = (overrides: Partial<Equipment> = {}): Equipment => ({
  bonus:       {},
  description: "An item",
  equipped:    false,
  id:          "item_1",
  name:        "Item",
  owned:       false,
  rarity:      "common",
  type:        "weapon",
  ...overrides,
});

const makeQuest = (overrides: Partial<Quest> = {}): Quest => ({
  description:      "A quest",
  durationSeconds:  60,
  id:               "quest_1",
  name:             "Quest",
  prerequisiteIds:  [],
  rewards:          [],
  status:           "available",
  zoneId:           "zone_1",
  ...overrides,
});

const makeBoss = (overrides: Partial<Boss> = {}): Boss => ({
  bountyRunestones:  0,
  crystalReward:     0,
  currentHp:         100,
  damagePerSecond:   1,
  description:       "A boss",
  equipmentRewards:  [],
  essenceReward:     0,
  goldReward:        0,
  id:                "boss_1",
  maxHp:             100,
  name:              "Boss",
  prestigeRequirement: 0,
  status:            "available",
  upgradeRewards:    [],
  zoneId:            "zone_1",
  ...overrides,
});

describe("preserveEquipmentHistory", () => {
  it("marks everOwned when the current item has everOwned true", () => {
    const fresh = [ makeItem() ];
    const current = [ makeItem({ everOwned: true, owned: false }) ];
    const result = preserveEquipmentHistory(fresh, current);
    expect(result[0]?.everOwned).toBe(true);
  });

  it("marks everOwned when the current item is owned but everOwned is unset", () => {
    const fresh = [ makeItem() ];
    const current = [ makeItem({ owned: true }) ];
    const result = preserveEquipmentHistory(fresh, current);
    expect(result[0]?.everOwned).toBe(true);
  });

  it("leaves the fresh item unchanged when the current item is neither owned nor everOwned", () => {
    const fresh = [ makeItem() ];
    const current = [ makeItem({ owned: false, everOwned: false }) ];
    const result = preserveEquipmentHistory(fresh, current);
    expect(result[0]?.everOwned).toBeUndefined();
  });

  it("leaves the fresh item unchanged when no matching id exists in current equipment", () => {
    const fresh = [ makeItem({ id: "item_1" }) ];
    const current = [ makeItem({ id: "item_2", owned: true, everOwned: true }) ];
    const result = preserveEquipmentHistory(fresh, current);
    expect(result[0]?.everOwned).toBeUndefined();
  });
});

describe("preserveQuestHistory", () => {
  it("marks everCompleted when the current quest has everCompleted true", () => {
    const fresh = [ makeQuest() ];
    const current = [ makeQuest({ everCompleted: true, status: "available" }) ];
    const result = preserveQuestHistory(fresh, current);
    expect(result[0]?.everCompleted).toBe(true);
  });

  it("marks everCompleted when the current quest is completed but everCompleted is unset", () => {
    const fresh = [ makeQuest() ];
    const current = [ makeQuest({ status: "completed" }) ];
    const result = preserveQuestHistory(fresh, current);
    expect(result[0]?.everCompleted).toBe(true);
  });

  it("leaves the fresh quest unchanged when the current quest is neither completed nor everCompleted", () => {
    const fresh = [ makeQuest() ];
    const current = [ makeQuest({ everCompleted: false, status: "locked" }) ];
    const result = preserveQuestHistory(fresh, current);
    expect(result[0]?.everCompleted).toBeUndefined();
  });

  it("leaves the fresh quest unchanged when no matching id exists in current quests", () => {
    const fresh = [ makeQuest({ id: "quest_1" }) ];
    const current = [
      makeQuest({ everCompleted: true, id: "quest_2", status: "completed" }),
    ];
    const result = preserveQuestHistory(fresh, current);
    expect(result[0]?.everCompleted).toBeUndefined();
  });
});

describe("preserveBossHistory", () => {
  it("marks everDefeated when the current boss has everDefeated true", () => {
    const fresh = [ makeBoss() ];
    const current = [ makeBoss({ everDefeated: true, status: "available" }) ];
    const result = preserveBossHistory(fresh, current);
    expect(result[0]?.everDefeated).toBe(true);
  });

  it("marks everDefeated when the current boss is defeated but everDefeated is unset", () => {
    const fresh = [ makeBoss() ];
    const current = [ makeBoss({ status: "defeated" }) ];
    const result = preserveBossHistory(fresh, current);
    expect(result[0]?.everDefeated).toBe(true);
  });

  it("leaves the fresh boss unchanged when the current boss is neither defeated nor everDefeated", () => {
    const fresh = [ makeBoss() ];
    const current = [ makeBoss({ everDefeated: false, status: "locked" }) ];
    const result = preserveBossHistory(fresh, current);
    expect(result[0]?.everDefeated).toBeUndefined();
  });

  it("leaves the fresh boss unchanged when no matching id exists in current bosses", () => {
    const fresh = [ makeBoss({ id: "boss_1" }) ];
    const current = [
      makeBoss({ everDefeated: true, id: "boss_2", status: "defeated" }),
    ];
    const result = preserveBossHistory(fresh, current);
    expect(result[0]?.everDefeated).toBeUndefined();
  });
});