pacifica/tests/unit/test_hedging_manager.js

"use strict";
/**
 * Unit tests for HedgingManager
 */
Object.defineProperty(exports, "__esModule", { value: true });
const HedgingManager_1 = require("../../src/core/HedgingManager");
// Mock dependencies
jest.mock('../../src/utils/Logger');
jest.mock('../../src/core/RiskManager');
jest.mock('../../src/core/OrderCoordinator');
jest.mock('../../src/core/HedgingStrategyEngine');
jest.mock('../../src/core/HedgingConfigManager');
describe('HedgingManager', () => {
    let hedgingManager;
    let mockConfig;
    beforeEach(() => {
        mockConfig = {
            maxConcurrentSessions: 5,
            sessionTimeout: 60000,
            riskCheckInterval: 1000
        };
        hedgingManager = new HedgingManager_1.HedgingManager(mockConfig);
    });
    afterEach(() => {
        jest.clearAllMocks();
    });
    describe('Initialization', () => {
        it('should initialize with correct configuration', async () => {
            await hedgingManager.initialize();
            const status = hedgingManager.getStatus();
            expect(status.isRunning).toBe(false);
            expect(status.totalSessions).toBe(0);
        });
        it('should throw error if already initialized', async () => {
            await hedgingManager.initialize();
            await expect(hedgingManager.initialize()).rejects.toThrow('HedgingManager is already initialized');
        });
    });
    describe('Session Management', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should create a new hedging session', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            expect(session).toBeDefined();
            expect(session.id).toBeDefined();
            expect(session.status).toBe('created');
            expect(session.strategy.symbol).toBe('ETH/USD');
            expect(session.accounts).toEqual(['account1', 'account2']);
        });
        it('should throw error when creating session with invalid request', async () => {
            const invalidRequest = {
                strategy: {
                    symbol: '', // Invalid empty symbol
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: [],
                duration: 300000
            };
            await expect(hedgingManager.createSession(invalidRequest)).rejects.toThrow();
        });
        it('should start a hedging session', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            await hedgingManager.startSession(session.id);
            const updatedSession = hedgingManager.getSession(session.id);
            expect(updatedSession?.status).toBe('running');
        });
        it('should pause a running session', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            await hedgingManager.startSession(session.id);
            await hedgingManager.pauseSession(session.id);
            const updatedSession = hedgingManager.getSession(session.id);
            expect(updatedSession?.status).toBe('paused');
        });
        it('should resume a paused session', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            await hedgingManager.startSession(session.id);
            await hedgingManager.pauseSession(session.id);
            await hedgingManager.resumeSession(session.id);
            const updatedSession = hedgingManager.getSession(session.id);
            expect(updatedSession?.status).toBe('running');
        });
        it('should stop a session', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            await hedgingManager.startSession(session.id);
            await hedgingManager.stopSession(session.id);
            const updatedSession = hedgingManager.getSession(session.id);
            expect(updatedSession?.status).toBe('stopped');
        });
        it('should throw error when operating on non-existent session', async () => {
            await expect(hedgingManager.startSession('non-existent')).rejects.toThrow();
            await expect(hedgingManager.pauseSession('non-existent')).rejects.toThrow();
            await expect(hedgingManager.resumeSession('non-existent')).rejects.toThrow();
            await expect(hedgingManager.stopSession('non-existent')).rejects.toThrow();
        });
        it('should throw error when starting already running session', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            await hedgingManager.startSession(session.id);
            await expect(hedgingManager.startSession(session.id)).rejects.toThrow();
        });
    });
    describe('Session Retrieval', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should get all sessions', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session1 = await hedgingManager.createSession(sessionRequest);
            const session2 = await hedgingManager.createSession(sessionRequest);
            const allSessions = hedgingManager.getAllSessions();
            expect(allSessions).toHaveLength(2);
            expect(allSessions.map(s => s.id)).toContain(session1.id);
            expect(allSessions.map(s => s.id)).toContain(session2.id);
        });
        it('should get session by ID', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            const retrievedSession = hedgingManager.getSession(session.id);
            expect(retrievedSession).toBeDefined();
            expect(retrievedSession?.id).toBe(session.id);
        });
        it('should return null for non-existent session', () => {
            const session = hedgingManager.getSession('non-existent');
            expect(session).toBeNull();
        });
    });
    describe('Order Management', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should get session orders', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            const orders = hedgingManager.getSessionOrders(session.id);
            expect(orders).toBeDefined();
            expect(Array.isArray(orders)).toBe(true);
        });
        it('should return empty array for non-existent session orders', () => {
            const orders = hedgingManager.getSessionOrders('non-existent');
            expect(orders).toEqual([]);
        });
    });
    describe('Risk Management', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should get session risk status', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            const riskStatus = hedgingManager.getSessionRiskStatus(session.id);
            expect(riskStatus).toBeDefined();
            expect(riskStatus.overallRisk).toBeDefined();
            expect(riskStatus.activeBreaches).toBeDefined();
            expect(riskStatus.acknowledgedBreaches).toBeDefined();
        });
        it('should get session risk breaches', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            const breaches = hedgingManager.getSessionRiskBreaches(session.id);
            expect(breaches).toBeDefined();
            expect(Array.isArray(breaches)).toBe(true);
        });
        it('should acknowledge risk breach', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            const breaches = hedgingManager.getSessionRiskBreaches(session.id);
            if (breaches.length > 0) {
                const breach = breaches[0];
                await hedgingManager.acknowledgeRiskBreach(session.id, breach.id);
                const updatedBreaches = hedgingManager.getSessionRiskBreaches(session.id);
                const updatedBreach = updatedBreaches.find(b => b.id === breach.id);
                expect(updatedBreach?.acknowledged).toBe(true);
            }
        });
        it('should throw error when acknowledging non-existent breach', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            await expect(hedgingManager.acknowledgeRiskBreach(session.id, 'non-existent')).rejects.toThrow();
        });
    });
    describe('Lifecycle Management', () => {
        it('should start and stop the manager', async () => {
            await hedgingManager.initialize();
            await hedgingManager.start();
            const status = hedgingManager.getStatus();
            expect(status.isRunning).toBe(true);
            await hedgingManager.stop();
            const stoppedStatus = hedgingManager.getStatus();
            expect(stoppedStatus.isRunning).toBe(false);
        });
        it('should throw error when starting already running manager', async () => {
            await hedgingManager.initialize();
            await hedgingManager.start();
            await expect(hedgingManager.start()).rejects.toThrow();
        });
        it('should throw error when stopping non-running manager', async () => {
            await hedgingManager.initialize();
            await expect(hedgingManager.stop()).rejects.toThrow();
        });
    });
    describe('Status and Statistics', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should return correct status', () => {
            const status = hedgingManager.getStatus();
            expect(status).toBeDefined();
            expect(typeof status.isRunning).toBe('boolean');
            expect(typeof status.totalSessions).toBe('number');
            expect(typeof status.activeSessions).toBe('number');
            expect(typeof status.pausedSessions).toBe('number');
            expect(typeof status.stoppedSessions).toBe('number');
        });
        it('should return correct statistics', () => {
            const stats = hedgingManager.getStatistics();
            expect(stats).toBeDefined();
            expect(typeof stats.totalSessions).toBe('number');
            expect(typeof stats.totalOrders).toBe('number');
            expect(typeof stats.totalVolume).toBe('number');
            expect(typeof stats.averageExecutionTime).toBe('number');
            expect(typeof stats.successRate).toBe('number');
        });
    });
    describe('Error Handling', () => {
        it('should handle initialization errors gracefully', async () => {
            const invalidConfig = {
                maxConcurrentSessions: -1, // Invalid negative value
                sessionTimeout: 60000,
                riskCheckInterval: 1000
            };
            const invalidManager = new HedgingManager_1.HedgingManager(invalidConfig);
            await expect(invalidManager.initialize()).rejects.toThrow();
        });
        it('should handle session creation errors gracefully', async () => {
            await hedgingManager.initialize();
            const invalidRequest = {
                strategy: null, // Invalid null strategy
                accounts: ['account1'],
                duration: 300000
            };
            await expect(hedgingManager.createSession(invalidRequest)).rejects.toThrow();
        });
    });
    describe('Event Emission', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should emit session created event', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const eventSpy = jest.fn();
            hedgingManager.on('sessionCreated', eventSpy);
            await hedgingManager.createSession(sessionRequest);
            expect(eventSpy).toHaveBeenCalled();
        });
        it('should emit session started event', async () => {
            const sessionRequest = {
                strategy: {
                    symbol: 'ETH/USD',
                    volumeDistribution: 'equal',
                    priceRange: { min: 0.001, max: 0.01 },
                    timing: { minInterval: 30, maxInterval: 120, orderSize: { min: 100, max: 500 } },
                    riskLimits: { maxPositionSize: 0.1, stopLossThreshold: 0.05, maxSlippage: 0.02 },
                    orderTypes: { primary: 'limit', fallback: 'market' }
                },
                accounts: ['account1', 'account2'],
                duration: 300000
            };
            const session = await hedgingManager.createSession(sessionRequest);
            const eventSpy = jest.fn();
            hedgingManager.on('sessionStarted', eventSpy);
            await hedgingManager.startSession(session.id);
            expect(eventSpy).toHaveBeenCalled();
        });
    });
});
//# sourceMappingURL=test_hedging_manager.js.map