@omnitronix/bonnys-fortune-game-engine 1.3.2 → 1.5.0

package/dist/__tests__/comprehensive.test.js

@@ -0,0 +1,747 @@
+"use strict";
+/**
+ * Comprehensive Test Suite for Bonny's Fortune Game Engine
+ *
+ * Coverage:
+ * - Session initialization
+ * - Base game spins with bonus meter accumulation
+ * - bonusGame1 (Treasure Hunt) flow
+ * - bonusGame2 (Free Spins) flow
+ * - bonusGame3 (Steering to the Fortune) flow
+ * - collectFeature flow
+ * - Bonus meter progression
+ * - Spin/Bonus combinations
+ * - State persistence
+ * - Error handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const bonnys_fortune_v1_game_engine_1 = require("../bonnys-fortune-v1.game-engine");
+describe("Bonny's Fortune - Comprehensive Test Suite", () => {
+    let engine;
+    beforeEach(() => {
+        engine = new bonnys_fortune_v1_game_engine_1.BonnysFortuneV1GameEngine();
+    });
+    // ============================================================
+    // SESSION INITIALIZATION
+    // ============================================================
+    describe('Session Initialization', () => {
+        it('should initialize session with default config', async () => {
+            const command = {
+                id: 'init-1',
+                type: 'INIT_SESSION_STATE',
+                payload: {
+                    betAmount: 1.0,
+                    currency: 'EUR',
+                },
+            };
+            const result = await engine.processCommand(null, null, command);
+            expect(result.success).toBe(true);
+            expect(result.publicState).toBeDefined();
+            expect(result.privateState).toBeDefined();
+        });
+        it('should initialize with bonus meters', async () => {
+            const result = await engine.processCommand(null, null, {
+                id: 'init-meters',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            expect(result.success).toBe(true);
+            expect(result.publicState.bonusMeters).toBeDefined();
+        });
+        it('should initialize session with various bet amounts', async () => {
+            const betAmounts = [0.5, 1.0, 2.0, 5.0, 10.0];
+            for (const betAmount of betAmounts) {
+                const result = await engine.processCommand(null, null, {
+                    id: `init-${betAmount}`,
+                    type: 'INIT_SESSION_STATE',
+                    payload: { betAmount },
+                });
+                expect(result.success).toBe(true);
+            }
+        });
+        it('should return game engine info', () => {
+            const info = engine.getGameEngineInfo();
+            expect(info.gameCode).toBe('bonnys-fortune');
+            expect(info.version).toBeDefined();
+            expect(info.rtp).toBeGreaterThan(90);
+            expect(info.gameType).toBe('slot');
+        });
+    });
+    // ============================================================
+    // BASE GAME SPINS
+    // ============================================================
+    describe('Base Game Spins', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should execute a base game spin', async () => {
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'spin-1',
+                type: 'SPIN',
+                payload: {
+                    sessionId: 'test-session',
+                    betAmount: 1.0,
+                },
+            });
+            expect(result.success).toBe(true);
+            expect(result.publicState).toBeDefined();
+            expect(result.privateState).toBeDefined();
+            expect(result.outcome).toBeDefined();
+        });
+        it('should update bonus meters on spin', async () => {
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'spin-meter',
+                type: 'SPIN',
+                payload: {
+                    sessionId: 'test',
+                    betAmount: 1.0,
+                },
+            });
+            expect(result.success).toBe(true);
+            expect(result.publicState.bonusMeters).toBeDefined();
+        });
+        it('should handle multiple consecutive spins', async () => {
+            let currentPublic = publicState;
+            let currentPrivate = privateState;
+            for (let i = 0; i < 10; i++) {
+                const result = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `spin-${i}`,
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(result.success).toBe(true);
+                currentPublic = result.publicState;
+                currentPrivate = result.privateState;
+            }
+        });
+        it('should accumulate bonus meter progress across spins', async () => {
+            let currentPublic = publicState;
+            let currentPrivate = privateState;
+            // Perform multiple spins to accumulate meter progress
+            for (let i = 0; i < 10; i++) {
+                const result = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `spin-${i}`,
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(result.success).toBe(true);
+                currentPublic = result.publicState;
+                currentPrivate = result.privateState;
+            }
+            // Bonus meters should exist
+            expect(currentPublic.bonusMeters).toBeDefined();
+        });
+    });
+    // ============================================================
+    // BONUS GAME 1 - TREASURE HUNT
+    // ============================================================
+    describe('bonusGame1 (Treasure Hunt) Flow', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should trigger bonusGame1 via debug command', async () => {
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'debug-bg1',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test-session',
+                    bonusType: 'bonusGame1',
+                    betAmount: 1.0,
+                },
+            });
+            expect(result.success).toBe(true);
+        });
+        it('should complete full bonusGame1 flow: trigger → continue spinning', async () => {
+            // Trigger bonus
+            const triggerResult = await engine.processCommand(publicState, privateState, {
+                id: 'trigger-bg1',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test',
+                    bonusType: 'bonusGame1',
+                    betAmount: 1.0,
+                },
+            });
+            expect(triggerResult.success).toBe(true);
+            // Continue with spins after bonus trigger
+            let currentPublic = triggerResult.publicState;
+            let currentPrivate = triggerResult.privateState;
+            for (let i = 0; i < 3; i++) {
+                const spinResult = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `spin-bg1-${i}`,
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(spinResult.success).toBe(true);
+                currentPublic = spinResult.publicState;
+                currentPrivate = spinResult.privateState;
+            }
+        });
+        it('should handle multiple bonusGame1 triggers', async () => {
+            let currentPublic = publicState;
+            let currentPrivate = privateState;
+            for (let i = 0; i < 3; i++) {
+                const result = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `trigger-bg1-${i}`,
+                    type: 'DEBUG_TRIGGER_BONUS',
+                    payload: {
+                        sessionId: 'test',
+                        bonusType: 'bonusGame1',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(result.success).toBe(true);
+                currentPublic = result.publicState;
+                currentPrivate = result.privateState;
+            }
+        });
+    });
+    // ============================================================
+    // BONUS GAME 2 - FREE SPINS
+    // ============================================================
+    describe('bonusGame2 (Free Spins) Flow', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should trigger bonusGame2 via debug command', async () => {
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'debug-bg2',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test-session',
+                    bonusType: 'bonusGame2',
+                    betAmount: 1.0,
+                },
+            });
+            expect(result.success).toBe(true);
+        });
+        it('should complete full bonusGame2 flow: trigger → continue with spins', async () => {
+            // Trigger bonus
+            const triggerResult = await engine.processCommand(publicState, privateState, {
+                id: 'trigger-bg2',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test',
+                    bonusType: 'bonusGame2',
+                    betAmount: 1.0,
+                },
+            });
+            expect(triggerResult.success).toBe(true);
+            // Continue with spins after bonus trigger
+            let currentPublic = triggerResult.publicState;
+            let currentPrivate = triggerResult.privateState;
+            for (let i = 0; i < 3; i++) {
+                const spinResult = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `spin-bg2-${i}`,
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(spinResult.success).toBe(true);
+                currentPublic = spinResult.publicState;
+                currentPrivate = spinResult.privateState;
+            }
+        });
+    });
+    // ============================================================
+    // BONUS GAME 3 - STEERING TO THE FORTUNE
+    // ============================================================
+    describe('bonusGame3 (Steering to the Fortune) Flow', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should trigger bonusGame3 via debug command', async () => {
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'debug-bg3',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test-session',
+                    bonusType: 'bonusGame3',
+                    betAmount: 1.0,
+                },
+            });
+            expect(result.success).toBe(true);
+        });
+        it('should complete full bonusGame3 flow: trigger → continue with spins', async () => {
+            // Trigger bonus
+            const triggerResult = await engine.processCommand(publicState, privateState, {
+                id: 'trigger-bg3',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test',
+                    bonusType: 'bonusGame3',
+                    betAmount: 1.0,
+                },
+            });
+            expect(triggerResult.success).toBe(true);
+            // Continue with spins after bonus trigger
+            let currentPublic = triggerResult.publicState;
+            let currentPrivate = triggerResult.privateState;
+            for (let i = 0; i < 3; i++) {
+                const spinResult = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `spin-bg3-${i}`,
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(spinResult.success).toBe(true);
+                currentPublic = spinResult.publicState;
+                currentPrivate = spinResult.privateState;
+            }
+        });
+    });
+    // ============================================================
+    // COLLECT FEATURE
+    // ============================================================
+    describe('collectFeature Flow', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should trigger collectFeature via debug command', async () => {
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'debug-collect',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test-session',
+                    bonusType: 'collectFeature',
+                    betAmount: 1.0,
+                },
+            });
+            expect(result.success).toBe(true);
+        });
+        it('should handle collectFeature with various bet amounts', async () => {
+            const betAmounts = [1.0, 2.0, 5.0];
+            for (const betAmount of betAmounts) {
+                const init = await engine.processCommand(null, null, {
+                    id: `init-${betAmount}`,
+                    type: 'INIT_SESSION_STATE',
+                    payload: { betAmount },
+                });
+                const result = await engine.processCommand(init.publicState, init.privateState, {
+                    id: `collect-${betAmount}`,
+                    type: 'DEBUG_TRIGGER_BONUS',
+                    payload: {
+                        sessionId: 'test',
+                        bonusType: 'collectFeature',
+                        betAmount,
+                    },
+                });
+                expect(result.success).toBe(true);
+            }
+        });
+    });
+    // ============================================================
+    // BONUS METER MANIPULATION
+    // ============================================================
+    describe('Bonus Meter Manipulation', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should update bonus meter progress via debug command', async () => {
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'update-meter',
+                type: 'DEBUG_UPDATE_BONUS_METER_PROGRESS',
+                payload: {
+                    sessionId: 'test',
+                    bonusType: 'bonusGame1',
+                    progress: 50,
+                },
+            });
+            expect(result).toBeDefined();
+            expect(result.success).toBe(true);
+        });
+        it('should track meter progress across multiple updates', async () => {
+            let currentPublic = publicState;
+            let currentPrivate = privateState;
+            const bonusTypes = ['bonusGame1', 'bonusGame2', 'bonusGame3'];
+            for (const bonusType of bonusTypes) {
+                const result = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `update-${bonusType}`,
+                    type: 'DEBUG_UPDATE_BONUS_METER_PROGRESS',
+                    payload: {
+                        sessionId: 'test',
+                        bonusType,
+                        progress: 25,
+                    },
+                });
+                expect(result).toBeDefined();
+                expect(result.success).toBe(true);
+                currentPublic = result.publicState || currentPublic;
+                currentPrivate = result.privateState || currentPrivate;
+            }
+        });
+    });
+    // ============================================================
+    // SPIN/BONUS COMBINATIONS
+    // ============================================================
+    describe('Spin/Bonus Combinations', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should handle spin → bonus → spin sequence', async () => {
+            // Initial spins
+            let current = await engine.processCommand(publicState, privateState, {
+                id: 'spin-1',
+                type: 'SPIN',
+                payload: {
+                    sessionId: 'test',
+                    betAmount: 1.0,
+                },
+            });
+            expect(current.success).toBe(true);
+            current = await engine.processCommand(current.publicState, current.privateState, {
+                id: 'spin-2',
+                type: 'SPIN',
+                payload: {
+                    sessionId: 'test',
+                    betAmount: 1.0,
+                },
+            });
+            expect(current.success).toBe(true);
+            // Trigger bonus
+            const bonusResult = await engine.processCommand(current.publicState, current.privateState, {
+                id: 'trigger-bonus',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test',
+                    bonusType: 'bonusGame1',
+                    betAmount: 1.0,
+                },
+            });
+            expect(bonusResult.success).toBe(true);
+            // Continue with more spins
+            const afterBonus = await engine.processCommand(bonusResult.publicState, bonusResult.privateState, {
+                id: 'spin-after',
+                type: 'SPIN',
+                payload: {
+                    sessionId: 'test',
+                    betAmount: 1.0,
+                },
+            });
+            expect(afterBonus).toBeDefined();
+        });
+        it('should handle all bonus types in sequence', async () => {
+            const bonusTypes = ['bonusGame1', 'bonusGame2', 'bonusGame3', 'collectFeature'];
+            let currentPublic = publicState;
+            let currentPrivate = privateState;
+            for (const bonusType of bonusTypes) {
+                // Spin first
+                const spin = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `spin-${bonusType}`,
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(spin.success).toBe(true);
+                // Trigger bonus
+                const bonus = await engine.processCommand(spin.publicState, spin.privateState, {
+                    id: `trigger-${bonusType}`,
+                    type: 'DEBUG_TRIGGER_BONUS',
+                    payload: {
+                        sessionId: 'test',
+                        bonusType,
+                        betAmount: 1.0,
+                    },
+                });
+                expect(bonus.success).toBe(true);
+                currentPublic = bonus.publicState;
+                currentPrivate = bonus.privateState;
+            }
+        });
+        it('should handle rapid bonus type switching', async () => {
+            const bonusSequence = [
+                'bonusGame1',
+                'bonusGame2',
+                'bonusGame1',
+                'bonusGame3',
+                'collectFeature',
+                'bonusGame2',
+            ];
+            let currentPublic = publicState;
+            let currentPrivate = privateState;
+            for (let i = 0; i < bonusSequence.length; i++) {
+                const result = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `rapid-${i}`,
+                    type: 'DEBUG_TRIGGER_BONUS',
+                    payload: {
+                        sessionId: 'test',
+                        bonusType: bonusSequence[i],
+                        betAmount: 1.0,
+                    },
+                });
+                expect(result.success).toBe(true);
+                currentPublic = result.publicState;
+                currentPrivate = result.privateState;
+            }
+        });
+        it('should handle mixed bet amounts with different bonus types', async () => {
+            const configs = [
+                { betAmount: 1.0, bonusType: 'bonusGame1' },
+                { betAmount: 2.0, bonusType: 'bonusGame2' },
+                { betAmount: 5.0, bonusType: 'bonusGame3' },
+                { betAmount: 10.0, bonusType: 'collectFeature' },
+            ];
+            for (const { betAmount, bonusType } of configs) {
+                const init = await engine.processCommand(null, null, {
+                    id: `init-${betAmount}`,
+                    type: 'INIT_SESSION_STATE',
+                    payload: { betAmount },
+                });
+                // Spin
+                const spin = await engine.processCommand(init.publicState, init.privateState, {
+                    id: `spin-${betAmount}`,
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount,
+                    },
+                });
+                expect(spin.success).toBe(true);
+                // Trigger bonus
+                const bonus = await engine.processCommand(spin.publicState, spin.privateState, {
+                    id: `bonus-${betAmount}`,
+                    type: 'DEBUG_TRIGGER_BONUS',
+                    payload: {
+                        sessionId: 'test',
+                        bonusType,
+                        betAmount,
+                    },
+                });
+                expect(bonus.success).toBe(true);
+            }
+        });
+    });
+    // ============================================================
+    // DEBUG TRIGGER ERROR CASES
+    // ============================================================
+    describe('Debug Trigger Error Cases', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should accept any bonus type in debug mode', async () => {
+            // Note: DEBUG_TRIGGER_BONUS does not validate bonus types
+            // It accepts any string as bonusType for flexibility
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'any-bonus',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test',
+                    bonusType: 'CUSTOM_BONUS_TYPE',
+                    betAmount: 1.0,
+                },
+            });
+            expect(result.success).toBe(true);
+        });
+        it('should throw error without initialized state', async () => {
+            // Engine throws TypeError when state is null
+            // This is expected behavior - state must be initialized
+            await expect(engine.processCommand(null, null, {
+                id: 'no-state',
+                type: 'DEBUG_TRIGGER_BONUS',
+                payload: {
+                    sessionId: 'test',
+                    bonusType: 'bonusGame1',
+                    betAmount: 1.0,
+                },
+            })).rejects.toThrow();
+        });
+    });
+    // ============================================================
+    // SESSION MANAGEMENT
+    // ============================================================
+    describe('Session Management', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should handle get symbols command', async () => {
+            const result = await engine.processCommand(publicState, privateState, {
+                id: 'symbols',
+                type: 'GET_SYMBOLS',
+                payload: {},
+            });
+            expect(result).toBeDefined();
+        });
+    });
+    // ============================================================
+    // STATE PERSISTENCE
+    // ============================================================
+    describe('State Persistence', () => {
+        let publicState;
+        let privateState;
+        beforeEach(async () => {
+            const initResult = await engine.processCommand(null, null, {
+                id: 'init',
+                type: 'INIT_SESSION_STATE',
+                payload: { betAmount: 1.0 },
+            });
+            publicState = initResult.publicState;
+            privateState = initResult.privateState;
+        });
+        it('should serialize and deserialize state correctly', async () => {
+            // Spin to have meaningful state
+            const spin = await engine.processCommand(publicState, privateState, {
+                id: 'spin',
+                type: 'SPIN',
+                payload: {
+                    sessionId: 'test',
+                    betAmount: 1.0,
+                },
+            });
+            // Serialize
+            const serializedPublic = JSON.stringify(spin.publicState);
+            const serializedPrivate = JSON.stringify(spin.privateState);
+            // Deserialize
+            const restoredPublic = JSON.parse(serializedPublic);
+            const restoredPrivate = JSON.parse(serializedPrivate);
+            // Verify serialization round-trip preserves data
+            expect(restoredPublic).toEqual(spin.publicState);
+            expect(restoredPrivate).toEqual(spin.privateState);
+            // Continue with restored state only if base game spin is expected
+            // (DummyRng may trigger bonus meters, changing nextSpinType)
+            if (restoredPrivate.nextSpinType === 'BASE_GAME_SPIN') {
+                const result = await engine.processCommand(restoredPublic, restoredPrivate, {
+                    id: 'spin-2',
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(result.success).toBe(true);
+            }
+        });
+        it('should preserve bonus meters across reconnection', async () => {
+            // Spin to accumulate meter
+            const spin = await engine.processCommand(publicState, privateState, {
+                id: 'spin',
+                type: 'SPIN',
+                payload: { sessionId: 'test', betAmount: 1.0 },
+            });
+            // Serialize and restore
+            const serialized = JSON.stringify(spin.publicState);
+            const restored = JSON.parse(serialized);
+            expect(restored.bonusMeters).toBeDefined();
+        });
+        it('should maintain state across multiple operations', async () => {
+            let currentPublic = publicState;
+            let currentPrivate = privateState;
+            // Multiple spins
+            for (let i = 0; i < 5; i++) {
+                const result = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `spin-${i}`,
+                    type: 'SPIN',
+                    payload: {
+                        sessionId: 'test',
+                        betAmount: 1.0,
+                    },
+                });
+                expect(result.success).toBe(true);
+                currentPublic = result.publicState;
+                currentPrivate = result.privateState;
+            }
+            // Trigger various bonuses
+            for (const bonusType of ['bonusGame1', 'bonusGame2']) {
+                const bonus = await engine.processCommand(currentPublic, currentPrivate, {
+                    id: `bonus-${bonusType}`,
+                    type: 'DEBUG_TRIGGER_BONUS',
+                    payload: {
+                        sessionId: 'test',
+                        bonusType,
+                        betAmount: 1.0,
+                    },
+                });
+                expect(bonus.success).toBe(true);
+                currentPublic = bonus.publicState;
+                currentPrivate = bonus.privateState;
+            }
+        });
+    });
+});
+//# sourceMappingURL=comprehensive.test.js.map