pacifica/tests/unit/test_risk_manager.ts

/**
 * Unit tests for RiskManager
 */

import { RiskManager } from '../../src/core/RiskManager';
import { RiskBreach, RiskCategory, RiskSeverity } from '../../src/types/hedging';
import { Logger } from '../../src/utils/Logger';

// Mock dependencies
jest.mock('../../src/utils/Logger');

describe('RiskManager', () => {
  let riskManager: RiskManager;
  let mockConfig: any;

  beforeEach(() => {
    mockConfig = {
      riskCheckInterval: 1000,
      maxBreaches: 1000,
      breachRetentionTime: 3600000
    };

    riskManager = new 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: RiskBreach = {
        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: RiskBreach = {
        id: 'breach-1',
        sessionId: 'session-1',
        category: 'position_size',
        severity: 'high',
        timestamp: new Date(),
        details: 'Position size exceeded limit',
        acknowledged: false
      };

      const breach2: RiskBreach = {
        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: RiskBreach = {
        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: RiskBreach = {
        id: 'breach-1',
        sessionId: 'session-1',
        category: 'position_size',
        severity: 'high',
        timestamp: new Date(),
        details: 'Position size exceeded limit',
        acknowledged: false
      };

      const breach2: RiskBreach = {
        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: RiskBreach = {
        id: 'breach-1',
        sessionId: 'session-1',
        category: 'position_size',
        severity: 'high',
        timestamp: new Date(),
        details: 'Position size exceeded limit',
        acknowledged: false
      };

      const breach2: RiskBreach = {
        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: RiskBreach = {
        id: 'breach-1',
        sessionId: 'session-1',
        category: 'position_size',
        severity: 'high',
        timestamp: new Date(),
        details: 'Position size exceeded limit',
        acknowledged: false
      };

      const breach2: RiskBreach = {
        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: RiskBreach = {
        id: 'breach-1',
        sessionId: 'session-1',
        category: 'position_size',
        severity: 'high',
        timestamp: new Date(),
        details: 'Position size exceeded limit',
        acknowledged: true
      };

      const breach2: RiskBreach = {
        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: RiskBreach = {
        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: RiskBreach = {
        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(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: RiskBreach = {
        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: RiskBreach = {
        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: RiskBreach = {
          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
    });
  });
});