pacifica/tests/unit/test_risk_manager.js

"use strict";
/**
 * Unit tests for RiskManager
 */
Object.defineProperty(exports, "__esModule", { value: true });
const RiskManager_1 = require("../../src/core/RiskManager");
// Mock dependencies
jest.mock('../../src/utils/Logger');
describe('RiskManager', () => {
    let riskManager;
    let mockConfig;
    beforeEach(() => {
        mockConfig = {
            riskCheckInterval: 1000,
            maxBreaches: 1000,
            breachRetentionTime: 3600000
        };
        riskManager = new RiskManager_1.RiskManager(mockConfig);
    });
    afterEach(() => {
        jest.clearAllMocks();
    });
    describe('Initialization', () => {
        it('should initialize with correct configuration', async () => {
            await riskManager.initialize();
            const status = riskManager.getStatus();
            expect(status.isRunning).toBe(false);
            expect(status.totalBreaches).toBe(0);
        });
        it('should throw error if already initialized', async () => {
            await riskManager.initialize();
            await expect(riskManager.initialize()).rejects.toThrow('RiskManager is already initialized');
        });
    });
    describe('Risk Monitoring', () => {
        beforeEach(async () => {
            await riskManager.initialize();
        });
        it('should start risk monitoring', async () => {
            await riskManager.start();
            const status = riskManager.getStatus();
            expect(status.isRunning).toBe(true);
        });
        it('should stop risk monitoring', async () => {
            await riskManager.start();
            await riskManager.stop();
            const status = riskManager.getStatus();
            expect(status.isRunning).toBe(false);
        });
        it('should throw error when starting already running manager', async () => {
            await riskManager.start();
            await expect(riskManager.start()).rejects.toThrow();
        });
        it('should throw error when stopping non-running manager', async () => {
            await expect(riskManager.stop()).rejects.toThrow();
        });
    });
    describe('Risk Assessment', () => {
        beforeEach(async () => {
            await riskManager.initialize();
        });
        it('should assess position size risk', () => {
            const sessionId = 'test-session';
            const positionSize = 0.15; // 15% position size
            const maxPositionSize = 0.1; // 10% limit
            const riskLevel = riskManager.assessPositionSizeRisk(sessionId, positionSize, maxPositionSize);
            expect(riskLevel).toBe('high');
        });
        it('should assess portfolio loss risk', () => {
            const sessionId = 'test-session';
            const portfolioLoss = 0.06; // 6% loss
            const stopLossThreshold = 0.05; // 5% threshold
            const riskLevel = riskManager.assessPortfolioLossRisk(sessionId, portfolioLoss, stopLossThreshold);
            expect(riskLevel).toBe('high');
        });
        it('should assess slippage risk', () => {
            const sessionId = 'test-session';
            const slippage = 0.03; // 3% slippage
            const maxSlippage = 0.02; // 2% limit
            const riskLevel = riskManager.assessSlippageRisk(sessionId, slippage, maxSlippage);
            expect(riskLevel).toBe('high');
        });
        it('should assess market volatility risk', () => {
            const sessionId = 'test-session';
            const volatility = 0.08; // 8% volatility
            const maxVolatility = 0.05; // 5% limit
            const riskLevel = riskManager.assessMarketVolatilityRisk(sessionId, volatility, maxVolatility);
            expect(riskLevel).toBe('high');
        });
        it('should return low risk for acceptable values', () => {
            const sessionId = 'test-session';
            const positionRisk = riskManager.assessPositionSizeRisk(sessionId, 0.05, 0.1);
            const lossRisk = riskManager.assessPortfolioLossRisk(sessionId, 0.02, 0.05);
            const slippageRisk = riskManager.assessSlippageRisk(sessionId, 0.01, 0.02);
            const volatilityRisk = riskManager.assessMarketVolatilityRisk(sessionId, 0.03, 0.05);
            expect(positionRisk).toBe('low');
            expect(lossRisk).toBe('low');
            expect(slippageRisk).toBe('low');
            expect(volatilityRisk).toBe('low');
        });
        it('should return medium risk for borderline values', () => {
            const sessionId = 'test-session';
            const positionRisk = riskManager.assessPositionSizeRisk(sessionId, 0.08, 0.1);
            const lossRisk = riskManager.assessPortfolioLossRisk(sessionId, 0.04, 0.05);
            const slippageRisk = riskManager.assessSlippageRisk(sessionId, 0.018, 0.02);
            const volatilityRisk = riskManager.assessMarketVolatilityRisk(sessionId, 0.045, 0.05);
            expect(positionRisk).toBe('medium');
            expect(lossRisk).toBe('medium');
            expect(slippageRisk).toBe('medium');
            expect(volatilityRisk).toBe('medium');
        });
    });
    describe('Risk Breach Detection', () => {
        beforeEach(async () => {
            await riskManager.initialize();
        });
        it('should detect position size breach', () => {
            const sessionId = 'test-session';
            const positionSize = 0.15;
            const maxPositionSize = 0.1;
            const breach = riskManager.detectPositionSizeBreach(sessionId, positionSize, maxPositionSize);
            expect(breach).toBeDefined();
            expect(breach?.category).toBe('position_size');
            expect(breach?.severity).toBe('high');
            expect(breach?.sessionId).toBe(sessionId);
        });
        it('should detect portfolio loss breach', () => {
            const sessionId = 'test-session';
            const portfolioLoss = 0.06;
            const stopLossThreshold = 0.05;
            const breach = riskManager.detectPortfolioLossBreach(sessionId, portfolioLoss, stopLossThreshold);
            expect(breach).toBeDefined();
            expect(breach?.category).toBe('portfolio_loss');
            expect(breach?.severity).toBe('high');
            expect(breach?.sessionId).toBe(sessionId);
        });
        it('should detect slippage breach', () => {
            const sessionId = 'test-session';
            const slippage = 0.03;
            const maxSlippage = 0.02;
            const breach = riskManager.detectSlippageBreach(sessionId, slippage, maxSlippage);
            expect(breach).toBeDefined();
            expect(breach?.category).toBe('slippage');
            expect(breach?.severity).toBe('high');
            expect(breach?.sessionId).toBe(sessionId);
        });
        it('should detect market volatility breach', () => {
            const sessionId = 'test-session';
            const volatility = 0.08;
            const maxVolatility = 0.05;
            const breach = riskManager.detectMarketVolatilityBreach(sessionId, volatility, maxVolatility);
            expect(breach).toBeDefined();
            expect(breach?.category).toBe('market_volatility');
            expect(breach?.severity).toBe('high');
            expect(breach?.sessionId).toBe(sessionId);
        });
        it('should not detect breach for acceptable values', () => {
            const sessionId = 'test-session';
            const positionBreach = riskManager.detectPositionSizeBreach(sessionId, 0.05, 0.1);
            const lossBreach = riskManager.detectPortfolioLossBreach(sessionId, 0.02, 0.05);
            const slippageBreach = riskManager.detectSlippageBreach(sessionId, 0.01, 0.02);
            const volatilityBreach = riskManager.detectMarketVolatilityBreach(sessionId, 0.03, 0.05);
            expect(positionBreach).toBeNull();
            expect(lossBreach).toBeNull();
            expect(slippageBreach).toBeNull();
            expect(volatilityBreach).toBeNull();
        });
    });
    describe('Risk Breach Management', () => {
        beforeEach(async () => {
            await riskManager.initialize();
        });
        it('should add risk breach', () => {
            const breach = {
                id: 'test-breach',
                sessionId: 'test-session',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach);
            const breaches = riskManager.getSessionRiskBreaches('test-session');
            expect(breaches).toHaveLength(1);
            expect(breaches[0].id).toBe('test-breach');
        });
        it('should get session risk breaches', () => {
            const breach1 = {
                id: 'breach-1',
                sessionId: 'session-1',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: false
            };
            const breach2 = {
                id: 'breach-2',
                sessionId: 'session-2',
                category: 'portfolio_loss',
                severity: 'medium',
                timestamp: new Date(),
                details: 'Portfolio loss exceeded threshold',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach1);
            riskManager.addRiskBreach(breach2);
            const session1Breaches = riskManager.getSessionRiskBreaches('session-1');
            const session2Breaches = riskManager.getSessionRiskBreaches('session-2');
            expect(session1Breaches).toHaveLength(1);
            expect(session1Breaches[0].id).toBe('breach-1');
            expect(session2Breaches).toHaveLength(1);
            expect(session2Breaches[0].id).toBe('breach-2');
        });
        it('should acknowledge risk breach', () => {
            const breach = {
                id: 'test-breach',
                sessionId: 'test-session',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach);
            riskManager.acknowledgeRiskBreach('test-session', 'test-breach');
            const breaches = riskManager.getSessionRiskBreaches('test-session');
            expect(breaches[0].acknowledged).toBe(true);
        });
        it('should throw error when acknowledging non-existent breach', () => {
            expect(() => {
                riskManager.acknowledgeRiskBreach('test-session', 'non-existent');
            }).toThrow();
        });
        it('should get all risk breaches', () => {
            const breach1 = {
                id: 'breach-1',
                sessionId: 'session-1',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: false
            };
            const breach2 = {
                id: 'breach-2',
                sessionId: 'session-2',
                category: 'portfolio_loss',
                severity: 'medium',
                timestamp: new Date(),
                details: 'Portfolio loss exceeded threshold',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach1);
            riskManager.addRiskBreach(breach2);
            const allBreaches = riskManager.getAllRiskBreaches();
            expect(allBreaches).toHaveLength(2);
        });
        it('should get risk breaches by severity', () => {
            const breach1 = {
                id: 'breach-1',
                sessionId: 'session-1',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: false
            };
            const breach2 = {
                id: 'breach-2',
                sessionId: 'session-2',
                category: 'portfolio_loss',
                severity: 'medium',
                timestamp: new Date(),
                details: 'Portfolio loss exceeded threshold',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach1);
            riskManager.addRiskBreach(breach2);
            const highBreaches = riskManager.getRiskBreachesBySeverity('high');
            const mediumBreaches = riskManager.getRiskBreachesBySeverity('medium');
            expect(highBreaches).toHaveLength(1);
            expect(highBreaches[0].id).toBe('breach-1');
            expect(mediumBreaches).toHaveLength(1);
            expect(mediumBreaches[0].id).toBe('breach-2');
        });
        it('should get risk breaches by category', () => {
            const breach1 = {
                id: 'breach-1',
                sessionId: 'session-1',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: false
            };
            const breach2 = {
                id: 'breach-2',
                sessionId: 'session-2',
                category: 'portfolio_loss',
                severity: 'medium',
                timestamp: new Date(),
                details: 'Portfolio loss exceeded threshold',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach1);
            riskManager.addRiskBreach(breach2);
            const positionBreaches = riskManager.getRiskBreachesByCategory('position_size');
            const lossBreaches = riskManager.getRiskBreachesByCategory('portfolio_loss');
            expect(positionBreaches).toHaveLength(1);
            expect(positionBreaches[0].id).toBe('breach-1');
            expect(lossBreaches).toHaveLength(1);
            expect(lossBreaches[0].id).toBe('breach-2');
        });
    });
    describe('Risk Controls', () => {
        beforeEach(async () => {
            await riskManager.initialize();
        });
        it('should apply position size control', () => {
            const sessionId = 'test-session';
            const positionSize = 0.15;
            const maxPositionSize = 0.1;
            const controlledSize = riskManager.applyPositionSizeControl(sessionId, positionSize, maxPositionSize);
            expect(controlledSize).toBe(maxPositionSize);
        });
        it('should apply slippage control', () => {
            const sessionId = 'test-session';
            const slippage = 0.03;
            const maxSlippage = 0.02;
            const controlledSlippage = riskManager.applySlippageControl(sessionId, slippage, maxSlippage);
            expect(controlledSlippage).toBe(maxSlippage);
        });
        it('should not apply control for acceptable values', () => {
            const sessionId = 'test-session';
            const controlledSize = riskManager.applyPositionSizeControl(sessionId, 0.05, 0.1);
            const controlledSlippage = riskManager.applySlippageControl(sessionId, 0.01, 0.02);
            expect(controlledSize).toBe(0.05);
            expect(controlledSlippage).toBe(0.01);
        });
    });
    describe('Risk Statistics', () => {
        beforeEach(async () => {
            await riskManager.initialize();
        });
        it('should return correct status', () => {
            const status = riskManager.getStatus();
            expect(status).toBeDefined();
            expect(typeof status.isRunning).toBe('boolean');
            expect(typeof status.totalBreaches).toBe('number');
            expect(typeof status.activeBreaches).toBe('number');
            expect(typeof status.acknowledgedBreaches).toBe('number');
        });
        it('should return correct statistics', () => {
            const stats = riskManager.getStatistics();
            expect(stats).toBeDefined();
            expect(typeof stats.totalBreaches).toBe('number');
            expect(typeof stats.breachesByCategory).toBe('object');
            expect(typeof stats.breachesBySeverity).toBe('object');
            expect(typeof stats.acknowledgmentRate).toBe('number');
        });
        it('should calculate acknowledgment rate correctly', () => {
            const breach1 = {
                id: 'breach-1',
                sessionId: 'session-1',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: true
            };
            const breach2 = {
                id: 'breach-2',
                sessionId: 'session-2',
                category: 'portfolio_loss',
                severity: 'medium',
                timestamp: new Date(),
                details: 'Portfolio loss exceeded threshold',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach1);
            riskManager.addRiskBreach(breach2);
            const stats = riskManager.getStatistics();
            expect(stats.acknowledgmentRate).toBe(0.5); // 1 out of 2 acknowledged
        });
    });
    describe('Event Emission', () => {
        beforeEach(async () => {
            await riskManager.initialize();
        });
        it('should emit breach detected event', () => {
            const eventSpy = jest.fn();
            riskManager.on('breachDetected', eventSpy);
            const breach = {
                id: 'test-breach',
                sessionId: 'test-session',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach);
            expect(eventSpy).toHaveBeenCalledWith(breach);
        });
        it('should emit breach acknowledged event', () => {
            const breach = {
                id: 'test-breach',
                sessionId: 'test-session',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(),
                details: 'Position size exceeded limit',
                acknowledged: false
            };
            riskManager.addRiskBreach(breach);
            const eventSpy = jest.fn();
            riskManager.on('breachAcknowledged', eventSpy);
            riskManager.acknowledgeRiskBreach('test-session', 'test-breach');
            expect(eventSpy).toHaveBeenCalledWith(breach);
        });
    });
    describe('Error Handling', () => {
        it('should handle initialization errors gracefully', async () => {
            const invalidConfig = {
                riskCheckInterval: -1, // Invalid negative value
                maxBreaches: 1000,
                breachRetentionTime: 3600000
            };
            const invalidManager = new RiskManager_1.RiskManager(invalidConfig);
            await expect(invalidManager.initialize()).rejects.toThrow();
        });
        it('should handle invalid risk assessment parameters', () => {
            expect(() => {
                riskManager.assessPositionSizeRisk('', -1, 0.1);
            }).toThrow();
        });
        it('should handle invalid breach operations', () => {
            expect(() => {
                riskManager.acknowledgeRiskBreach('', '');
            }).toThrow();
        });
    });
    describe('Cleanup and Maintenance', () => {
        beforeEach(async () => {
            await riskManager.initialize();
        });
        it('should clean up old breaches', () => {
            const oldBreach = {
                id: 'old-breach',
                sessionId: 'test-session',
                category: 'position_size',
                severity: 'high',
                timestamp: new Date(Date.now() - 7200000), // 2 hours ago
                details: 'Old breach',
                acknowledged: true
            };
            const newBreach = {
                id: 'new-breach',
                sessionId: 'test-session',
                category: 'portfolio_loss',
                severity: 'medium',
                timestamp: new Date(),
                details: 'New breach',
                acknowledged: false
            };
            riskManager.addRiskBreach(oldBreach);
            riskManager.addRiskBreach(newBreach);
            riskManager.cleanupOldBreaches();
            const breaches = riskManager.getAllRiskBreaches();
            expect(breaches).toHaveLength(1);
            expect(breaches[0].id).toBe('new-breach');
        });
        it('should maintain breach count limit', () => {
            // Add more breaches than the limit
            for (let i = 0; i < 1500; i++) {
                const breach = {
                    id: `breach-${i}`,
                    sessionId: 'test-session',
                    category: 'position_size',
                    severity: 'high',
                    timestamp: new Date(),
                    details: `Breach ${i}`,
                    acknowledged: false
                };
                riskManager.addRiskBreach(breach);
            }
            const breaches = riskManager.getAllRiskBreaches();
            expect(breaches.length).toBeLessThanOrEqual(1000); // Should not exceed maxBreaches
        });
    });
});
//# sourceMappingURL=test_risk_manager.js.map