pacifica/tests/integration/test_order_pair_execution.js

"use strict";
/**
 * Integration test for order pair execution
 * Tests the complete flow of executing coordinated buy/sell order pairs
 */
Object.defineProperty(exports, "__esModule", { value: true });
const globals_1 = require("@jest/globals");
const HedgingManager_1 = require("../../src/core/HedgingManager");
const OrderCoordinator_1 = require("../../src/core/OrderCoordinator");
(0, globals_1.describe)('Order Pair Execution Integration', () => {
    let hedgingManager;
    let orderCoordinator;
    let testSessionId;
    (0, globals_1.beforeAll)(async () => {
        // Initialize hedging manager
        hedgingManager = new HedgingManager_1.HedgingManager({
            accounts: './config/accounts.json',
            hedging: './config/hedging-config.json',
            marketData: './config/market-data-config.json'
        });
        // Initialize order coordinator
        orderCoordinator = new OrderCoordinator_1.OrderCoordinator({
            maxConcurrentOrders: 20,
            orderTimeout: 30000,
            retryAttempts: 3,
            retryDelay: 1000,
            atomicExecution: true
        });
        await hedgingManager.initialize();
        await orderCoordinator.initialize();
    });
    (0, globals_1.afterAll)(async () => {
        if (hedgingManager) {
            await hedgingManager.shutdown();
        }
        if (orderCoordinator) {
            await orderCoordinator.shutdown();
        }
    });
    (0, globals_1.beforeEach)(async () => {
        // Create a test session for each test
        const sessionRequest = {
            name: 'Order Pair Test Session',
            accountIds: ['account-1', 'account-2'],
            volumeTarget: 10000,
            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' }
            }
        };
        try {
            const session = await hedgingManager.createSession(sessionRequest);
            testSessionId = session.id;
        }
        catch (error) {
            testSessionId = 'mock-session-id';
        }
    });
    (0, globals_1.describe)('Order Pair Creation', () => {
        (0, globals_1.it)('should create a coordinated buy/sell order pair', async () => {
            const orderPairRequest = {
                sessionId: testSessionId,
                buyAccountId: 'account-1',
                sellAccountId: 'account-2',
                symbol: 'ETH/USD',
                size: 100,
                price: 2500,
                orderType: 'limit'
            };
            try {
                const orderPair = await orderCoordinator.createOrderPair(orderPairRequest);
                (0, globals_1.expect)(orderPair).toBeDefined();
                (0, globals_1.expect)(orderPair.id).toBeDefined();
                (0, globals_1.expect)(orderPair.sessionId).toBe(testSessionId);
                (0, globals_1.expect)(orderPair.status).toBe('pending');
                (0, globals_1.expect)(orderPair.volume).toBe(100);
                (0, globals_1.expect)(orderPair.price).toBe(2500);
                // Verify order pair structure
                (0, globals_1.expect)(orderPair.orderPair).toBeDefined();
                (0, globals_1.expect)(orderPair.orderPair.buyOrder).toBeDefined();
                (0, globals_1.expect)(orderPair.orderPair.sellOrder).toBeDefined();
                // Verify buy order
                const buyOrder = orderPair.orderPair.buyOrder;
                (0, globals_1.expect)(buyOrder.accountId).toBe('account-1');
                (0, globals_1.expect)(buyOrder.side).toBe('buy');
                (0, globals_1.expect)(buyOrder.type).toBe('limit');
                (0, globals_1.expect)(buyOrder.size).toBe(100);
                (0, globals_1.expect)(buyOrder.price).toBe(2500);
                (0, globals_1.expect)(buyOrder.status).toBe('pending');
                // Verify sell order
                const sellOrder = orderPair.orderPair.sellOrder;
                (0, globals_1.expect)(sellOrder.accountId).toBe('account-2');
                (0, globals_1.expect)(sellOrder.side).toBe('sell');
                (0, globals_1.expect)(sellOrder.type).toBe('limit');
                (0, globals_1.expect)(sellOrder.size).toBe(100);
                (0, globals_1.expect)(sellOrder.price).toBe(2500);
                (0, globals_1.expect)(sellOrder.status).toBe('pending');
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
        (0, globals_1.it)('should validate order pair neutrality', async () => {
            const orderPairRequest = {
                sessionId: testSessionId,
                buyAccountId: 'account-1',
                sellAccountId: 'account-2',
                symbol: 'ETH/USD',
                size: 100,
                price: 2500,
                orderType: 'limit'
            };
            try {
                const orderPair = await orderCoordinator.createOrderPair(orderPairRequest);
                // Verify position neutrality
                (0, globals_1.expect)(orderPair.orderPair.buyOrder.size).toBe(orderPair.orderPair.sellOrder.size);
                (0, globals_1.expect)(orderPair.orderPair.buyOrder.price).toBe(orderPair.orderPair.sellOrder.price);
                (0, globals_1.expect)(orderPair.orderPair.buyOrder.side).not.toBe(orderPair.orderPair.sellOrder.side);
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
        (0, globals_1.it)('should reject order pair with same account for buy and sell', async () => {
            const invalidOrderPairRequest = {
                sessionId: testSessionId,
                buyAccountId: 'account-1',
                sellAccountId: 'account-1', // Same account for both sides
                symbol: 'ETH/USD',
                size: 100,
                price: 2500,
                orderType: 'limit'
            };
            try {
                await orderCoordinator.createOrderPair(invalidOrderPairRequest);
                fail('Should have rejected order pair with same account');
            }
            catch (error) {
                (0, globals_1.expect)(error.message).toContain('same account');
            }
        });
        (0, globals_1.it)('should reject order pair with different sizes', async () => {
            const invalidOrderPairRequest = {
                sessionId: testSessionId,
                buyAccountId: 'account-1',
                sellAccountId: 'account-2',
                symbol: 'ETH/USD',
                buySize: 100,
                sellSize: 150, // Different sizes
                price: 2500,
                orderType: 'limit'
            };
            try {
                await orderCoordinator.createOrderPair(invalidOrderPairRequest);
                fail('Should have rejected order pair with different sizes');
            }
            catch (error) {
                (0, globals_1.expect)(error.message).toContain('size');
            }
        });
    });
    (0, globals_1.describe)('Order Pair Execution', () => {
        let testOrderPairId;
        (0, globals_1.beforeEach)(async () => {
            const orderPairRequest = {
                sessionId: testSessionId,
                buyAccountId: 'account-1',
                sellAccountId: 'account-2',
                symbol: 'ETH/USD',
                size: 100,
                price: 2500,
                orderType: 'limit'
            };
            try {
                const orderPair = await orderCoordinator.createOrderPair(orderPairRequest);
                testOrderPairId = orderPair.id;
            }
            catch (error) {
                testOrderPairId = 'mock-order-pair-id';
            }
        });
        (0, globals_1.it)('should execute order pair atomically', async () => {
            try {
                const result = await orderCoordinator.executeOrderPair(testOrderPairId);
                (0, globals_1.expect)(result).toBeDefined();
                (0, globals_1.expect)(result.success).toBe(true);
                (0, globals_1.expect)(result.orderPairId).toBe(testOrderPairId);
                (0, globals_1.expect)(result.executionTime).toBeDefined();
                (0, globals_1.expect)(result.executionTime).toBeGreaterThan(0);
                // Verify both orders were executed
                const orderPair = await orderCoordinator.getOrderPair(testOrderPairId);
                (0, globals_1.expect)(orderPair.status).toBe('filled');
                (0, globals_1.expect)(orderPair.orderPair.buyOrder.status).toBe('filled');
                (0, globals_1.expect)(orderPair.orderPair.sellOrder.status).toBe('filled');
                (0, globals_1.expect)(orderPair.executedAt).toBeDefined();
                (0, globals_1.expect)(orderPair.completedAt).toBeDefined();
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
        (0, globals_1.it)('should handle partial fills correctly', async () => {
            try {
                // Mock partial fill scenario
                const result = await orderCoordinator.executeOrderPair(testOrderPairId);
                if (result.partialFill) {
                    const orderPair = await orderCoordinator.getOrderPair(testOrderPairId);
                    (0, globals_1.expect)(orderPair.status).toBe('partial');
                    (0, globals_1.expect)(orderPair.orderPair.buyOrder.fillSize).toBeLessThan(orderPair.orderPair.buyOrder.size);
                    (0, globals_1.expect)(orderPair.orderPair.sellOrder.fillSize).toBeLessThan(orderPair.orderPair.sellOrder.size);
                }
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
        (0, globals_1.it)('should handle execution failures gracefully', async () => {
            try {
                // Mock execution failure scenario
                const result = await orderCoordinator.executeOrderPair(testOrderPairId);
                if (!result.success) {
                    const orderPair = await orderCoordinator.getOrderPair(testOrderPairId);
                    (0, globals_1.expect)(orderPair.status).toBe('failed');
                    (0, globals_1.expect)(result.error).toBeDefined();
                    (0, globals_1.expect)(result.error.message).toBeDefined();
                }
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
        (0, globals_1.it)('should retry failed orders according to configuration', async () => {
            try {
                const result = await orderCoordinator.executeOrderPair(testOrderPairId);
                if (!result.success && result.retryCount) {
                    (0, globals_1.expect)(result.retryCount).toBeGreaterThan(0);
                    (0, globals_1.expect)(result.retryCount).toBeLessThanOrEqual(3); // Max retry attempts
                }
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
    });
    (0, globals_1.describe)('Order Pair Monitoring', () => {
        let testOrderPairId;
        (0, globals_1.beforeEach)(async () => {
            const orderPairRequest = {
                sessionId: testSessionId,
                buyAccountId: 'account-1',
                sellAccountId: 'account-2',
                symbol: 'ETH/USD',
                size: 100,
                price: 2500,
                orderType: 'limit'
            };
            try {
                const orderPair = await orderCoordinator.createOrderPair(orderPairRequest);
                testOrderPairId = orderPair.id;
            }
            catch (error) {
                testOrderPairId = 'mock-order-pair-id';
            }
        });
        (0, globals_1.it)('should track order pair status changes', async () => {
            try {
                const initialOrderPair = await orderCoordinator.getOrderPair(testOrderPairId);
                (0, globals_1.expect)(initialOrderPair.status).toBe('pending');
                // Execute the order pair
                await orderCoordinator.executeOrderPair(testOrderPairId);
                const executedOrderPair = await orderCoordinator.getOrderPair(testOrderPairId);
                (0, globals_1.expect)(executedOrderPair.status).toBe('submitted');
                // Wait for execution to complete
                await new Promise(resolve => setTimeout(resolve, 100));
                const completedOrderPair = await orderCoordinator.getOrderPair(testOrderPairId);
                (0, globals_1.expect)(['filled', 'failed', 'partial']).toContain(completedOrderPair.status);
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
        (0, globals_1.it)('should calculate execution metrics', async () => {
            try {
                const result = await orderCoordinator.executeOrderPair(testOrderPairId);
                if (result.success) {
                    (0, globals_1.expect)(result.executionTime).toBeDefined();
                    (0, globals_1.expect)(result.slippage).toBeDefined();
                    (0, globals_1.expect)(result.fees).toBeDefined();
                    (0, globals_1.expect)(result.executionTime).toBeGreaterThan(0);
                }
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
        (0, globals_1.it)('should emit order pair events', async () => {
            const events = [];
            try {
                orderCoordinator.on('orderPairCreated', (orderPair) => {
                    events.push('orderPairCreated');
                    (0, globals_1.expect)(orderPair.id).toBe(testOrderPairId);
                });
                orderCoordinator.on('orderPairExecuted', (orderPair) => {
                    events.push('orderPairExecuted');
                    (0, globals_1.expect)(orderPair.id).toBe(testOrderPairId);
                });
                orderCoordinator.on('orderPairCompleted', (orderPair) => {
                    events.push('orderPairCompleted');
                    (0, globals_1.expect)(orderPair.id).toBe(testOrderPairId);
                });
                await orderCoordinator.executeOrderPair(testOrderPairId);
                (0, globals_1.expect)(events).toContain('orderPairCreated');
                (0, globals_1.expect)(events).toContain('orderPairExecuted');
                (0, globals_1.expect)(events).toContain('orderPairCompleted');
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
    });
    (0, globals_1.describe)('Concurrent Order Execution', () => {
        (0, globals_1.it)('should handle multiple concurrent order pairs', async () => {
            const orderPairRequests = [
                {
                    sessionId: testSessionId,
                    buyAccountId: 'account-1',
                    sellAccountId: 'account-2',
                    symbol: 'ETH/USD',
                    size: 100,
                    price: 2500,
                    orderType: 'limit'
                },
                {
                    sessionId: testSessionId,
                    buyAccountId: 'account-2',
                    sellAccountId: 'account-1',
                    symbol: 'ETH/USD',
                    size: 150,
                    price: 2501,
                    orderType: 'limit'
                }
            ];
            try {
                const orderPairs = await Promise.all(orderPairRequests.map(request => orderCoordinator.createOrderPair(request)));
                (0, globals_1.expect)(orderPairs).toHaveLength(2);
                (0, globals_1.expect)(orderPairs[0].id).not.toBe(orderPairs[1].id);
                // Execute both order pairs concurrently
                const results = await Promise.all(orderPairs.map(orderPair => orderCoordinator.executeOrderPair(orderPair.id)));
                (0, globals_1.expect)(results).toHaveLength(2);
                results.forEach(result => {
                    (0, globals_1.expect)(result).toBeDefined();
                    (0, globals_1.expect)(result.orderPairId).toBeDefined();
                });
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
        (0, globals_1.it)('should respect maximum concurrent orders limit', async () => {
            const orderPairRequests = Array(25).fill(null).map((_, index) => ({
                sessionId: testSessionId,
                buyAccountId: 'account-1',
                sellAccountId: 'account-2',
                symbol: 'ETH/USD',
                size: 100,
                price: 2500 + index,
                orderType: 'limit'
            }));
            try {
                const orderPairs = await Promise.all(orderPairRequests.map(request => orderCoordinator.createOrderPair(request)));
                // Try to execute all order pairs
                const results = await Promise.allSettled(orderPairs.map(orderPair => orderCoordinator.executeOrderPair(orderPair.id)));
                // Some should succeed, some should be rejected due to concurrency limit
                const successful = results.filter(r => r.status === 'fulfilled');
                const rejected = results.filter(r => r.status === 'rejected');
                (0, globals_1.expect)(successful.length + rejected.length).toBe(25);
                (0, globals_1.expect)(successful.length).toBeLessThanOrEqual(20); // Max concurrent orders
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
    });
    (0, globals_1.describe)('Error Handling', () => {
        (0, globals_1.it)('should handle non-existent order pair operations gracefully', async () => {
            const nonExistentOrderPairId = 'non-existent-order-pair-id';
            try {
                await orderCoordinator.getOrderPair(nonExistentOrderPairId);
                fail('Should have thrown error for non-existent order pair');
            }
            catch (error) {
                (0, globals_1.expect)(error.message).toContain('not found');
            }
        });
        (0, globals_1.it)('should handle execution timeout', async () => {
            const orderPairRequest = {
                sessionId: testSessionId,
                buyAccountId: 'account-1',
                sellAccountId: 'account-2',
                symbol: 'ETH/USD',
                size: 100,
                price: 2500,
                orderType: 'limit'
            };
            try {
                const orderPair = await orderCoordinator.createOrderPair(orderPairRequest);
                // Mock timeout scenario
                const result = await orderCoordinator.executeOrderPair(orderPair.id);
                if (!result.success && result.timeout) {
                    (0, globals_1.expect)(result.error.message).toContain('timeout');
                }
            }
            catch (error) {
                // This test should fail initially since OrderCoordinator doesn't exist yet
                (0, globals_1.expect)(error.message).toContain('OrderCoordinator');
            }
        });
    });
});
//# sourceMappingURL=test_order_pair_execution.js.map