pacifica/tests/performance/test_order_execution_latency.js

"use strict";
/**
 * Performance tests for order execution latency
 * Tests that order execution meets the <100ms requirement
 */
Object.defineProperty(exports, "__esModule", { value: true });
const HedgingManager_1 = require("../../src/core/HedgingManager");
const OrderCoordinator_1 = require("../../src/core/OrderCoordinator");
// Mock dependencies
jest.mock('../../src/utils/Logger');
jest.mock('../../src/core/RiskManager');
jest.mock('../../src/core/HedgingStrategyEngine');
jest.mock('../../src/core/HedgingConfigManager');
jest.mock('../../src/core/OrderExecutor');
describe('Order Execution Performance Tests', () => {
    let hedgingManager;
    let orderCoordinator;
    let orderExecutorAdapter;
    let mockConfig;
    beforeEach(() => {
        mockConfig = {
            maxConcurrentSessions: 10,
            sessionTimeout: 60000,
            riskCheckInterval: 1000
        };
        hedgingManager = new HedgingManager_1.HedgingManager(mockConfig);
        orderCoordinator = new OrderCoordinator_1.OrderCoordinator({
            maxConcurrentOrders: 20,
            orderTimeout: 30000,
            retryAttempts: 3,
            retryDelay: 1000
        });
    });
    afterEach(() => {
        jest.clearAllMocks();
    });
    describe('Order Execution Latency Tests', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
            await orderCoordinator.initialize();
        });
        it('should execute single order pair within 100ms', async () => {
            const hedgingOrder = {
                id: 'perf-test-order',
                sessionId: 'perf-test-session',
                strategyId: 'perf-test-strategy',
                orderPair: {
                    buyOrder: {
                        accountId: 'account1',
                        side: 'buy',
                        type: 'limit',
                        size: 100,
                        price: 2500
                    },
                    sellOrder: {
                        accountId: 'account2',
                        side: 'sell',
                        type: 'limit',
                        size: 100,
                        price: 2500
                    }
                },
                status: 'pending',
                fees: 0,
                slippage: 0,
                createdAt: new Date(),
                updatedAt: new Date()
            };
            const startTime = performance.now();
            const result = await orderCoordinator.executeHedgingOrderPair(hedgingOrder);
            const endTime = performance.now();
            const executionTime = endTime - startTime;
            expect(executionTime).toBeLessThan(100); // Must be under 100ms
            expect(result).toBeDefined();
            expect(result.success).toBeDefined();
            console.log(`Single order pair execution time: ${executionTime.toFixed(2)}ms`);
        });
        it('should execute multiple order pairs concurrently within 100ms', async () => {
            const orders = [];
            // Create 5 concurrent orders
            for (let i = 0; i < 5; i++) {
                orders.push({
                    id: `perf-concurrent-order-${i}`,
                    sessionId: 'perf-concurrent-session',
                    strategyId: 'perf-concurrent-strategy',
                    orderPair: {
                        buyOrder: {
                            accountId: `account${i * 2 + 1}`,
                            side: 'buy',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        },
                        sellOrder: {
                            accountId: `account${i * 2 + 2}`,
                            side: 'sell',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        }
                    },
                    status: 'pending',
                    fees: 0,
                    slippage: 0,
                    createdAt: new Date(),
                    updatedAt: new Date()
                });
            }
            const startTime = performance.now();
            const results = await Promise.all(orders.map(order => orderCoordinator.executeHedgingOrderPair(order)));
            const endTime = performance.now();
            const executionTime = endTime - startTime;
            expect(executionTime).toBeLessThan(100); // Must be under 100ms
            expect(results).toHaveLength(5);
            results.forEach(result => {
                expect(result).toBeDefined();
                expect(result.success).toBeDefined();
            });
            console.log(`5 concurrent order pairs execution time: ${executionTime.toFixed(2)}ms`);
        });
        it('should execute 10 order pairs within 100ms', async () => {
            const orders = [];
            // Create 10 orders
            for (let i = 0; i < 10; i++) {
                orders.push({
                    id: `perf-batch-order-${i}`,
                    sessionId: 'perf-batch-session',
                    strategyId: 'perf-batch-strategy',
                    orderPair: {
                        buyOrder: {
                            accountId: `account${i * 2 + 1}`,
                            side: 'buy',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        },
                        sellOrder: {
                            accountId: `account${i * 2 + 2}`,
                            side: 'sell',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        }
                    },
                    status: 'pending',
                    fees: 0,
                    slippage: 0,
                    createdAt: new Date(),
                    updatedAt: new Date()
                });
            }
            const startTime = performance.now();
            const results = await Promise.all(orders.map(order => orderCoordinator.executeHedgingOrderPair(order)));
            const endTime = performance.now();
            const executionTime = endTime - startTime;
            expect(executionTime).toBeLessThan(100); // Must be under 100ms
            expect(results).toHaveLength(10);
            results.forEach(result => {
                expect(result).toBeDefined();
                expect(result.success).toBeDefined();
            });
            console.log(`10 order pairs execution time: ${executionTime.toFixed(2)}ms`);
        });
        it('should execute 20 order pairs within 100ms', async () => {
            const orders = [];
            // Create 20 orders
            for (let i = 0; i < 20; i++) {
                orders.push({
                    id: `perf-stress-order-${i}`,
                    sessionId: 'perf-stress-session',
                    strategyId: 'perf-stress-strategy',
                    orderPair: {
                        buyOrder: {
                            accountId: `account${i * 2 + 1}`,
                            side: 'buy',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        },
                        sellOrder: {
                            accountId: `account${i * 2 + 2}`,
                            side: 'sell',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        }
                    },
                    status: 'pending',
                    fees: 0,
                    slippage: 0,
                    createdAt: new Date(),
                    updatedAt: new Date()
                });
            }
            const startTime = performance.now();
            const results = await Promise.all(orders.map(order => orderCoordinator.executeHedgingOrderPair(order)));
            const endTime = performance.now();
            const executionTime = endTime - startTime;
            expect(executionTime).toBeLessThan(100); // Must be under 100ms
            expect(results).toHaveLength(20);
            results.forEach(result => {
                expect(result).toBeDefined();
                expect(result.success).toBeDefined();
            });
            console.log(`20 order pairs execution time: ${executionTime.toFixed(2)}ms`);
        });
        it('should maintain performance under high load', async () => {
            const orders = [];
            // Create 50 orders for high load test
            for (let i = 0; i < 50; i++) {
                orders.push({
                    id: `perf-highload-order-${i}`,
                    sessionId: 'perf-highload-session',
                    strategyId: 'perf-highload-strategy',
                    orderPair: {
                        buyOrder: {
                            accountId: `account${i * 2 + 1}`,
                            side: 'buy',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        },
                        sellOrder: {
                            accountId: `account${i * 2 + 2}`,
                            side: 'sell',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        }
                    },
                    status: 'pending',
                    fees: 0,
                    slippage: 0,
                    createdAt: new Date(),
                    updatedAt: new Date()
                });
            }
            const startTime = performance.now();
            const results = await Promise.all(orders.map(order => orderCoordinator.executeHedgingOrderPair(order)));
            const endTime = performance.now();
            const executionTime = endTime - startTime;
            // High load test - allow up to 200ms for 50 orders
            expect(executionTime).toBeLessThan(200);
            expect(results).toHaveLength(50);
            results.forEach(result => {
                expect(result).toBeDefined();
                expect(result.success).toBeDefined();
            });
            console.log(`50 order pairs (high load) execution time: ${executionTime.toFixed(2)}ms`);
        });
    });
    describe('Session Creation Performance Tests', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should create session within 50ms', 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 startTime = performance.now();
            const session = await hedgingManager.createSession(sessionRequest);
            const endTime = performance.now();
            const creationTime = endTime - startTime;
            expect(creationTime).toBeLessThan(50); // Must be under 50ms
            expect(session).toBeDefined();
            expect(session.id).toBeDefined();
            console.log(`Session creation time: ${creationTime.toFixed(2)}ms`);
        });
        it('should create multiple sessions concurrently within 100ms', async () => {
            const sessionRequests = [];
            // Create 5 concurrent session requests
            for (let i = 0; i < 5; i++) {
                sessionRequests.push({
                    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: [`account${i * 2 + 1}`, `account${i * 2 + 2}`],
                    duration: 300000
                });
            }
            const startTime = performance.now();
            const sessions = await Promise.all(sessionRequests.map(request => hedgingManager.createSession(request)));
            const endTime = performance.now();
            const creationTime = endTime - startTime;
            expect(creationTime).toBeLessThan(100); // Must be under 100ms
            expect(sessions).toHaveLength(5);
            sessions.forEach(session => {
                expect(session).toBeDefined();
                expect(session.id).toBeDefined();
            });
            console.log(`5 concurrent session creation time: ${creationTime.toFixed(2)}ms`);
        });
    });
    describe('Risk Assessment Performance Tests', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should assess risk within 10ms', 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 startTime = performance.now();
            const riskStatus = hedgingManager.getSessionRiskStatus(session.id);
            const endTime = performance.now();
            const assessmentTime = endTime - startTime;
            expect(assessmentTime).toBeLessThan(10); // Must be under 10ms
            expect(riskStatus).toBeDefined();
            expect(riskStatus.overallRisk).toBeDefined();
            console.log(`Risk assessment time: ${assessmentTime.toFixed(2)}ms`);
        });
        it('should assess risk for multiple sessions within 50ms', async () => {
            const sessions = [];
            // Create 10 sessions
            for (let i = 0; i < 10; i++) {
                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: [`account${i * 2 + 1}`, `account${i * 2 + 2}`],
                    duration: 300000
                };
                const session = await hedgingManager.createSession(sessionRequest);
                sessions.push(session);
            }
            const startTime = performance.now();
            const riskStatuses = await Promise.all(sessions.map(session => hedgingManager.getSessionRiskStatus(session.id)));
            const endTime = performance.now();
            const assessmentTime = endTime - startTime;
            expect(assessmentTime).toBeLessThan(50); // Must be under 50ms
            expect(riskStatuses).toHaveLength(10);
            riskStatuses.forEach(riskStatus => {
                expect(riskStatus).toBeDefined();
                expect(riskStatus.overallRisk).toBeDefined();
            });
            console.log(`10 concurrent risk assessments time: ${assessmentTime.toFixed(2)}ms`);
        });
    });
    describe('Memory Usage Performance Tests', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
        });
        it('should not exceed memory limits during high volume operations', async () => {
            const initialMemory = process.memoryUsage();
            // Create 100 sessions
            const sessions = [];
            for (let i = 0; i < 100; i++) {
                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: [`account${i * 2 + 1}`, `account${i * 2 + 2}`],
                    duration: 300000
                };
                const session = await hedgingManager.createSession(sessionRequest);
                sessions.push(session);
            }
            const finalMemory = process.memoryUsage();
            const memoryIncrease = finalMemory.heapUsed - initialMemory.heapUsed;
            // Memory increase should be reasonable (less than 100MB)
            expect(memoryIncrease).toBeLessThan(100 * 1024 * 1024);
            console.log(`Memory increase for 100 sessions: ${(memoryIncrease / 1024 / 1024).toFixed(2)}MB`);
        });
        it('should clean up memory after session completion', 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 initialMemory = process.memoryUsage();
            const session = await hedgingManager.createSession(sessionRequest);
            await hedgingManager.startSession(session.id);
            await hedgingManager.stopSession(session.id);
            // Force garbage collection if available
            if (global.gc) {
                global.gc();
            }
            const finalMemory = process.memoryUsage();
            const memoryIncrease = finalMemory.heapUsed - initialMemory.heapUsed;
            // Memory increase should be minimal after cleanup
            expect(memoryIncrease).toBeLessThan(10 * 1024 * 1024); // Less than 10MB
            console.log(`Memory increase after session cleanup: ${(memoryIncrease / 1024 / 1024).toFixed(2)}MB`);
        });
    });
    describe('Throughput Performance Tests', () => {
        beforeEach(async () => {
            await hedgingManager.initialize();
            await orderCoordinator.initialize();
        });
        it('should handle 1000 orders per minute', async () => {
            const orders = [];
            // Create 1000 orders
            for (let i = 0; i < 1000; i++) {
                orders.push({
                    id: `throughput-order-${i}`,
                    sessionId: 'throughput-session',
                    strategyId: 'throughput-strategy',
                    orderPair: {
                        buyOrder: {
                            accountId: `account${i * 2 + 1}`,
                            side: 'buy',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        },
                        sellOrder: {
                            accountId: `account${i * 2 + 2}`,
                            side: 'sell',
                            type: 'limit',
                            size: 100,
                            price: 2500
                        }
                    },
                    status: 'pending',
                    fees: 0,
                    slippage: 0,
                    createdAt: new Date(),
                    updatedAt: new Date()
                });
            }
            const startTime = performance.now();
            const results = await Promise.all(orders.map(order => orderCoordinator.executeHedgingOrderPair(order)));
            const endTime = performance.now();
            const totalTime = endTime - startTime;
            const ordersPerSecond = (1000 / totalTime) * 1000;
            const ordersPerMinute = ordersPerSecond * 60;
            expect(ordersPerMinute).toBeGreaterThan(1000); // Must handle 1000+ orders per minute
            expect(results).toHaveLength(1000);
            console.log(`Throughput: ${ordersPerMinute.toFixed(0)} orders per minute`);
            console.log(`Total time for 1000 orders: ${totalTime.toFixed(2)}ms`);
        });
    });
});
//# sourceMappingURL=test_order_execution_latency.js.map