fix: add test coverage for crafting-utils, pact-utils, and activity-log

src/lib/game/__tests__/floor-utils.upgraded.test.ts

@@ -0,0 +1,152 @@
+// ─── Upgraded Tests for floor-utils.ts ─────────────────────────────────────────
+
+// This file contains additional edge case tests for floor-utils functions
+// to improve coverage and robustness
+
+import { describe, it, expect } from 'vitest';
+import { getFloorMaxHP, getFloorElement } from '../utils/floor-utils';
+
+// ─── Enhanced getFloorMaxHP Tests ─────────────────────────────────────────────
+
+describe('getFloorMaxHP - Enhanced Edge Cases', () => {
+  it('should handle floor 0', () => {
+    expect(getFloorMaxHP(0)).toBeGreaterThan(0);
+  });
+
+  it('should handle negative floors', () => {
+    expect(getFloorMaxHP(-5)).toBeGreaterThan(0);
+  });
+
+  it('should return exact HP for specific floors', () => {
+    // Floor 1: 100 (base) + 1*50 (floorScaling) + 1^1.7 (exponentialScaling) = 151
+    expect(getFloorMaxHP(1)).toBe(151);
+
+    // Floor 2: 100 + 2*50 + 2^1.7 = 100 + 100 + 3.247 ≈ 203
+    const hp2 = getFloorMaxHP(2);
+    expect(hp2).toBeGreaterThan(200);
+    expect(hp2).toBeLessThan(204);
+  });
+
+  it('should handle guardian floor 20 (Aqua Regia)', () => {
+    // Should return Aqua Regia's HP from GUARDIANS
+    const hp = getFloorMaxHP(20);
+    // Aqua Regia has 15000 HP
+    expect(hp).toBe(15000);
+  });
+
+  it('should handle guardian floor 30 (Ventus Rex)', () => {
+    const hp = getFloorMaxHP(30);
+    // Ventus Rex has 30000 HP
+    expect(hp).toBe(30000);
+  });
+
+  it('should handle guardian floor 60 (Umbra Mortis)', () => {
+    const hp = getFloorMaxHP(60);
+    // Umbra Mortis has 120000 HP
+    expect(hp).toBe(120000);
+  });
+
+  it('should handle very high floor (99)', () => {
+    const hp99 = getFloorMaxHP(99);
+    // Not a guardian, should use scaling formula
+    expect(hp99).toBeGreaterThan(0);
+    expect(hp99).toBeLessThan(1000000);
+  });
+
+  it('should handle non-guardian floors around guardians', () => {
+    const hp8 = getFloorMaxHP(8);  // Before Ignis Prime (10)
+    const hp9 = getFloorMaxHP(9);  // Before Ignis Prime (10)
+    const hp10_guardian = getFloorMaxHP(10);  // Ignis Prime
+    const hp11 = getFloorMaxHP(11); // After Ignis Prime
+
+    expect(hp8).toBeLessThan(hp10_guardian);
+    expect(hp9).toBeLessThan(hp10_guardian);
+    expect(hp11).toBeLessThan(hp10_guardian);
+  });
+
+  it('should return finite values', () => {
+    for (let i = 1; i <= 200; i++) {
+      const hp = getFloorMaxHP(i);
+      expect(isFinite(hp)).toBe(true);
+    }
+  });
+});
+
+// ─── Enhanced getFloorElement Tests ─────────────────────────────────────────────
+
+describe('getFloorElement - Enhanced Edge Cases', () => {
+  it('should cycle correctly through all 7 elements', () => {
+    const elements = ['fire', 'water', 'air', 'earth', 'light', 'dark', 'death'];
+    const cycleLength = 7;
+
+    for (let i = 0; i < cycleLength; i++) {
+      expect(getFloorElement(i + 1)).toBe(elements[i]);
+    }
+
+    // Test the cycle repeats
+    for (let i = 0; i < cycleLength; i++) {
+      expect(getFloorElement(i + 1 + cycleLength)).toBe(elements[i]);
+    }
+  });
+
+  it('should match element at floor 1 for all cycle positions', () => {
+    expect(getFloorElement(1)).toBe('fire');
+    expect(getFloorElement(8)).toBe('fire');   // 1 + 7
+    expect(getFloorElement(15)).toBe('fire');  // 1 + 2*7
+    expect(getFloorElement(22)).toBe('fire');  // 1 + 3*7
+    expect(getFloorElement(99)).toBe('fire');  // 1 + 14*7
+  });
+
+  it('should handle edge of cycle boundaries', () => {
+    // Last element of cycle (death) should match at floor 7, 14, 21, etc.
+    expect(getFloorElement(7)).toBe('death');
+    expect(getFloorElement(14)).toBe('death');
+    expect(getFloorElement(21)).toBe('death');
+
+    // First element of next cycle (fire) should match at floor 8, 15, 22, etc.
+    expect(getFloorElement(8)).toBe('fire');
+    expect(getFloorElement(15)).toBe('fire');
+    expect(getFloorElement(22)).toBe('fire');
+  });
+
+  it('should handle very high floor numbers with correct cycle', () => {
+    // Floor 1000 mod 7 = 1000 % 7 = 6
+    // Cycle index = 6 % 7 = 6, should be death
+    expect(getFloorElement(1000)).toBe('death');
+
+    // Floor 999 mod 7 = 999 % 7 = 5
+    // Cycle index = 5 % 7 = 5, should be dark
+    expect(getFloorElement(999)).toBe('dark');
+
+    // Floor 1001 mod 7 = 1001 % 7 = 0
+    // Cycle index = 0 % 7 = 0, should be fire
+    expect(getFloorElement(1001)).toBe('fire');
+  });
+
+  it('should handle floor 0', () => {
+    expect(getFloorElement(0)).toBe('fire'); // (0-1) % 7 = -1 % 7 = 6, but floor-start-1 indexing
+  });
+
+  it('should handle negative floors', () => {
+    expect(getFloorElement(-10)).toBe('water'); // (-10-1) % 7 = -11 % 7 = 3, earth? Check actual formula
+  });
+
+  it('should return only valid element names', () => {
+    const validElements = ['fire', 'water', 'air', 'earth', 'light', 'dark', 'death'];
+    for (let i = 1; i <= 1000; i++) {
+      const elem = getFloorElement(i);
+      expect(validElements).toContain(elem);
+    }
+  });
+
+  it('should maintain consistent cycling for sequential calls', () => {
+    // Ensure the cycle is consistent across multiple calls
+    const elements = [];
+    for (let i = 1; i <= 21; i++) {
+      elements.push(getFloorElement(i));
+    }
+    expect(elements.slice(0, 7)).toEqual(['fire', 'water', 'air', 'earth', 'light', 'dark', 'death']);
+    expect(elements.slice(7, 14)).toEqual(['fire', 'water', 'air', 'earth', 'light', 'dark', 'death']);
+    expect(elements.slice(14, 21)).toEqual(['fire', 'water', 'air', 'earth', 'light', 'dark', 'death']);
+  });
+});