test(rebirth): add 36 RebirthManager unit tests covering prestige system

Tests milestones, load/save persistence, canRebirth wave thresholds,
performRebirth progression, stat multipliers, weapon selection, and
getRebirthInfo display data. Total test count: 66 → 102.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 2 people

CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to Vibe Coder will be documented in this file.
 
+## [0.6.4] - 2026-02-11
+
+### Added
+- **36 RebirthManager unit tests** — Full coverage of the prestige/rebirth system:
+  - `MILESTONES` — shape validation, ascending wave order, sequential rebirth levels
+  - `load/save` — localStorage persistence, default state, corrupted JSON recovery
+  - `canRebirth` — wave threshold checks, milestone progression, max level guard
+  - `performRebirth` — level updates, kill accumulation, highest wave tracking
+  - `getAllStatsMultiplier / getXPMultiplier` — bonus scaling per rebirth level
+  - `getStartingWeaponCount / getStartingWeapons` — weapon cap, pool validation, no duplicates
+  - `getRebirthInfo` — display data, INTERN fallback, next milestone, lifetime stats
+
+### Changed
+- **Test count** — 66 → 102 total unit tests across 5 test suites
+
+---
+
 ## [0.6.3] - 2026-02-10
 
 ### Fixed
@@ -16,11 +33,12 @@ All notable changes to Vibe Coder will be documented in this file.
 
 ### Added
 - **Test infrastructure** — Vitest testing framework with `npm test` and `npm run test:watch` scripts
-- **66 unit tests** across 4 test suites covering core game systems:
+- **102 unit tests** across 5 test suites covering core game systems:
   - `SpatialHash` — cell key mapping, insert/clear, getNearby radius queries, cross-cell boundary lookups
   - `RunModifiers` — modifier selection, combined effect multiplier/flag merging, getById/getAll lookups
   - `SaveManager` — getTimeAgo time formatting across seconds/minutes/hours/days boundaries
   - `EventManager` — event definitions, active effects, effect application/clearing, trigger guards
+  - `RebirthManager` — milestones, load/save, canRebirth, performRebirth, multipliers, weapon selection, info display
 
 ### Changed
 - **README** — Expanded project structure to document all 6 systems (EventManager, MapManager, RebirthManager, RunModifiers, SaveManager, ShrineManager), all 3 utils (SpatialHash, audio, socket), and the test directory

README.md

@@ -152,11 +152,12 @@ The character reacts in real-time to your coding activity with speech bubbles an
 vibe-coder/
 ├── src/
 │   ├── main.js               # Game config, upgrades, legendaries
-│   ├── __tests__/             # Vitest unit tests (66 tests)
+│   ├── __tests__/             # Vitest unit tests (102 tests)
 │   │   ├── SpatialHash.test.js
 │   │   ├── RunModifiers.test.js
 │   │   ├── SaveManager.test.js
-│   │   └── EventManager.test.js
+│   │   ├── EventManager.test.js
+│   │   └── RebirthManager.test.js
 │   ├── scenes/
 │   │   ├── BootScene.js       # Procedural texture generation
 │   │   ├── TitleScene.js      # Menu, upgrades, weapon gallery
@@ -212,10 +213,12 @@ npm test            # Run all tests once
 npm run test:watch  # Watch mode (re-runs on file changes)
 ```
 
-66 unit tests cover core game systems: `SpatialHash`, `RunModifiers`, `SaveManager`, and `EventManager`.
+102 unit tests cover core game systems: `SpatialHash`, `RunModifiers`, `SaveManager`, `EventManager`, and `RebirthManager`.
 
 ## 📋 Changelog
 
+**v0.6.4** — Added 36 RebirthManager unit tests (milestones, bonuses, multipliers, weapon selection, prestige info). 102 total tests.
+
 **v0.6.3** — Fixed double hazard damage, MapManager tween memory leak, WebSocket reconnect race condition, negative health values.
 
 See [CHANGELOG.md](./CHANGELOG.md) for full version history.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coder",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Vampire Survivors-style idle game powered by your Claude Code activity",
   "type": "module",
   "main": "electron/main.js",

src/__tests__/RebirthManager.test.js

@@ -0,0 +1,295 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import RebirthManager from '../systems/RebirthManager.js';
+
+// Mock localStorage
+const store = {};
+const localStorageMock = {
+  getItem: vi.fn(key => store[key] ?? null),
+  setItem: vi.fn((key, val) => { store[key] = val; }),
+  removeItem: vi.fn(key => { delete store[key]; }),
+  clear: vi.fn(() => { Object.keys(store).forEach(k => delete store[k]); })
+};
+Object.defineProperty(globalThis, 'localStorage', { value: localStorageMock });
+
+describe('RebirthManager', () => {
+  beforeEach(() => {
+    localStorageMock.clear();
+    vi.clearAllMocks();
+  });
+
+  describe('MILESTONES', () => {
+    it('has 5 milestones', () => {
+      expect(RebirthManager.MILESTONES).toHaveLength(5);
+    });
+
+    it('milestones are in ascending wave order', () => {
+      for (let i = 1; i < RebirthManager.MILESTONES.length; i++) {
+        expect(RebirthManager.MILESTONES[i].wave).toBeGreaterThan(
+          RebirthManager.MILESTONES[i - 1].wave
+        );
+      }
+    });
+
+    it('each milestone has required fields', () => {
+      RebirthManager.MILESTONES.forEach(m => {
+        expect(m).toHaveProperty('wave');
+        expect(m).toHaveProperty('rebirth');
+        expect(m).toHaveProperty('name');
+        expect(typeof m.wave).toBe('number');
+        expect(typeof m.rebirth).toBe('number');
+        expect(typeof m.name).toBe('string');
+      });
+    });
+
+    it('rebirth levels are sequential 1-5', () => {
+      const levels = RebirthManager.MILESTONES.map(m => m.rebirth);
+      expect(levels).toEqual([1, 2, 3, 4, 5]);
+    });
+  });
+
+  describe('load', () => {
+    it('returns default state when nothing saved', () => {
+      const data = RebirthManager.load();
+      expect(data).toEqual({
+        rebirthLevel: 0,
+        highestWave: 0,
+        totalRebirths: 0,
+        lifetimeKills: 0
+      });
+    });
+
+    it('loads saved data from localStorage', () => {
+      const saved = { rebirthLevel: 3, highestWave: 160, totalRebirths: 5, lifetimeKills: 999 };
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify(saved);
+
+      const data = RebirthManager.load();
+      expect(data).toEqual(saved);
+    });
+
+    it('returns defaults on corrupted JSON', () => {
+      store[RebirthManager.STORAGE_KEY] = '{broken';
+      const data = RebirthManager.load();
+      expect(data.rebirthLevel).toBe(0);
+    });
+  });
+
+  describe('save', () => {
+    it('persists data to localStorage', () => {
+      const data = { rebirthLevel: 2, highestWave: 110, totalRebirths: 3, lifetimeKills: 500 };
+      RebirthManager.save(data);
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        RebirthManager.STORAGE_KEY,
+        JSON.stringify(data)
+      );
+    });
+  });
+
+  describe('canRebirth', () => {
+    it('returns first milestone when no rebirths and wave >= 50', () => {
+      const milestone = RebirthManager.canRebirth(50);
+      expect(milestone).not.toBeNull();
+      expect(milestone.rebirth).toBe(1);
+      expect(milestone.name).toBe('JUNIOR DEV');
+    });
+
+    it('returns null when wave is too low', () => {
+      expect(RebirthManager.canRebirth(10)).toBeNull();
+      expect(RebirthManager.canRebirth(49)).toBeNull();
+    });
+
+    it('returns highest available milestone for high waves', () => {
+      const milestone = RebirthManager.canRebirth(250);
+      expect(milestone.rebirth).toBe(5);
+      expect(milestone.name).toBe('ARCHITECT');
+    });
+
+    it('returns null when already at max rebirth level', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 5, highestWave: 300, totalRebirths: 10, lifetimeKills: 5000
+      });
+      expect(RebirthManager.canRebirth(300)).toBeNull();
+    });
+
+    it('returns next available milestone after current rebirth', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 2, highestWave: 100, totalRebirths: 2, lifetimeKills: 200
+      });
+      const milestone = RebirthManager.canRebirth(150);
+      expect(milestone.rebirth).toBe(3);
+      expect(milestone.name).toBe('SENIOR DEV');
+    });
+  });
+
+  describe('performRebirth', () => {
+    it('updates rebirth level to milestone', () => {
+      const result = RebirthManager.performRebirth(50, 100);
+      expect(result.rebirthLevel).toBe(1);
+      expect(result.totalRebirths).toBe(1);
+      expect(result.lifetimeKills).toBe(100);
+    });
+
+    it('tracks highest wave', () => {
+      const result = RebirthManager.performRebirth(75, 50);
+      expect(result.highestWave).toBe(75);
+    });
+
+    it('does not lower highest wave on subsequent rebirth', () => {
+      // First rebirth at wave 75
+      RebirthManager.performRebirth(75, 50);
+      // Second rebirth at wave 100 (lower than stored highest could hypothetically be higher)
+      const result = RebirthManager.performRebirth(100, 80);
+      expect(result.highestWave).toBe(100);
+    });
+
+    it('returns unchanged data when no milestone available', () => {
+      const result = RebirthManager.performRebirth(10, 5);
+      expect(result.rebirthLevel).toBe(0);
+      expect(result.totalRebirths).toBe(0);
+    });
+
+    it('accumulates lifetime kills', () => {
+      RebirthManager.performRebirth(50, 100);
+      const result = RebirthManager.performRebirth(100, 200);
+      expect(result.lifetimeKills).toBe(300);
+    });
+  });
+
+  describe('getAllStatsMultiplier', () => {
+    it('returns 1.0 with no rebirths', () => {
+      expect(RebirthManager.getAllStatsMultiplier()).toBe(1);
+    });
+
+    it('returns 1.05 at rebirth level 1', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 1, highestWave: 50, totalRebirths: 1, lifetimeKills: 0
+      });
+      expect(RebirthManager.getAllStatsMultiplier()).toBeCloseTo(1.05);
+    });
+
+    it('returns 1.25 at rebirth level 5', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 5, highestWave: 250, totalRebirths: 5, lifetimeKills: 0
+      });
+      expect(RebirthManager.getAllStatsMultiplier()).toBeCloseTo(1.25);
+    });
+  });
+
+  describe('getXPMultiplier', () => {
+    it('returns 1.0 with no rebirths', () => {
+      expect(RebirthManager.getXPMultiplier()).toBe(1);
+    });
+
+    it('scales by 10% per rebirth level', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 3, highestWave: 150, totalRebirths: 3, lifetimeKills: 0
+      });
+      expect(RebirthManager.getXPMultiplier()).toBeCloseTo(1.3);
+    });
+  });
+
+  describe('getStartingWeaponCount', () => {
+    it('returns 0 with no rebirths', () => {
+      expect(RebirthManager.getStartingWeaponCount()).toBe(0);
+    });
+
+    it('returns rebirth level up to cap of 3', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 2, highestWave: 100, totalRebirths: 2, lifetimeKills: 0
+      });
+      expect(RebirthManager.getStartingWeaponCount()).toBe(2);
+    });
+
+    it('caps at 3 for high rebirth levels', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 5, highestWave: 250, totalRebirths: 5, lifetimeKills: 0
+      });
+      expect(RebirthManager.getStartingWeaponCount()).toBe(3);
+    });
+  });
+
+  describe('getStartingWeapons', () => {
+    it('returns empty array with no rebirths', () => {
+      expect(RebirthManager.getStartingWeapons()).toEqual([]);
+    });
+
+    it('returns correct number of weapons', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 2, highestWave: 100, totalRebirths: 2, lifetimeKills: 0
+      });
+      const weapons = RebirthManager.getStartingWeapons();
+      expect(weapons).toHaveLength(2);
+    });
+
+    it('returns weapons from the valid pool', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 3, highestWave: 150, totalRebirths: 3, lifetimeKills: 0
+      });
+      const validPool = ['spread', 'pierce', 'rapid', 'homing', 'bounce', 'aoe', 'freeze'];
+      const weapons = RebirthManager.getStartingWeapons();
+      weapons.forEach(w => {
+        expect(validPool).toContain(w);
+      });
+    });
+
+    it('returns no duplicate weapons', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 5, highestWave: 250, totalRebirths: 5, lifetimeKills: 0
+      });
+      const weapons = RebirthManager.getStartingWeapons();
+      expect(new Set(weapons).size).toBe(weapons.length);
+    });
+  });
+
+  describe('getRebirthInfo', () => {
+    it('returns INTERN name at level 0', () => {
+      const info = RebirthManager.getRebirthInfo();
+      expect(info.name).toBe('INTERN');
+      expect(info.level).toBe(0);
+    });
+
+    it('returns correct milestone name', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 3, highestWave: 160, totalRebirths: 4, lifetimeKills: 800
+      });
+      const info = RebirthManager.getRebirthInfo();
+      expect(info.name).toBe('SENIOR DEV');
+      expect(info.level).toBe(3);
+    });
+
+    it('calculates bonus percentages correctly', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 2, highestWave: 110, totalRebirths: 3, lifetimeKills: 500
+      });
+      const info = RebirthManager.getRebirthInfo();
+      expect(info.allStatsBonus).toBe(10); // 2 * 5%
+      expect(info.xpBonus).toBe(20);       // 2 * 10%
+    });
+
+    it('includes next milestone info', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 2, highestWave: 100, totalRebirths: 2, lifetimeKills: 0
+      });
+      const info = RebirthManager.getRebirthInfo();
+      expect(info.nextMilestone).toBeDefined();
+      expect(info.nextMilestone.rebirth).toBe(3);
+    });
+
+    it('has no next milestone at max level', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 5, highestWave: 300, totalRebirths: 10, lifetimeKills: 5000
+      });
+      const info = RebirthManager.getRebirthInfo();
+      expect(info.nextMilestone).toBeUndefined();
+    });
+
+    it('includes lifetime stats', () => {
+      store[RebirthManager.STORAGE_KEY] = JSON.stringify({
+        rebirthLevel: 1, highestWave: 55, totalRebirths: 2, lifetimeKills: 300
+      });
+      const info = RebirthManager.getRebirthInfo();
+      expect(info.totalRebirths).toBe(2);
+      expect(info.lifetimeKills).toBe(300);
+      expect(info.highestWave).toBe(55);
+    });
+  });
+});