"use strict";
/**
 * Integration tests for account coordination
 * These tests MUST fail before implementation - TDD approach
 */
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const supertest_1 = __importDefault(require("supertest"));
// Mock Express app - this will fail until implementation
let app;
describe('Account Coordination Integration Tests', () => {
    beforeAll(() => {
        // This will fail until we implement the API
        // app = require('../../src/app').default;
    });
    describe('Multi-Account Coordination', () => {
        it('should coordinate orders across multiple accounts', async () => {
            // Create multiple accounts
            const accounts = [];
            for (let i = 1; i <= 5; i++) {
                const accountData = {
                    name: `Coordination Account ${i}`,
                    apiKey: `coord-api-key-${i}`,
                    privateKey: `coord-private-key-${i}-32-characters-long`,
                    address: `0x${i.toString().padStart(40, '0')}`
                };
                const response = await (0, supertest_1.default)(app)
                    .post('/api/v1/accounts')
                    .send(accountData)
                    .expect(201);
                accounts.push(response.body.data);
            }
            // Create session with all accounts
            const sessionData = {
                name: 'Account Coordination Test',
                strategyId: 'equal-volume-btc',
                accountIds: accounts.map(acc => acc.id),
                targetVolume: 2.0,
                duration: 60000
            };
            const sessionResponse = await (0, supertest_1.default)(app)
                .post('/api/v1/sessions')
                .send(sessionData)
                .expect(201);
            const session = sessionResponse.body.data;
            // Start session
            await (0, supertest_1.default)(app)
                .post(`/api/v1/sessions/${session.id}/start`)
                .expect(200);
            // Wait for execution
            await new Promise(resolve => setTimeout(resolve, 65000));
            // Verify orders were distributed across accounts
            const ordersResponse = await (0, supertest_1.default)(app)
                .get(`/api/v1/sessions/${session.id}/orders`)
                .expect(200);
            const orders = ordersResponse.body.data.orders;
            expect(orders.length).toBeGreaterThan(0);
            // Group orders by account
            const ordersByAccount = orders.reduce((acc, order) => {
                if (!acc[order.accountId]) {
                    acc[order.accountId] = [];
                }
                acc[order.accountId].push(order);
                return acc;
            }, {});
            // Verify all accounts participated
            expect(Object.keys(ordersByAccount).length).toBe(accounts.length);
            // Verify each account has both buy and sell orders
            for (const accountId of accounts.map(acc => acc.id)) {
                const accountOrders = ordersByAccount[accountId];
                expect(accountOrders.length).toBeGreaterThan(0);
                const buyOrders = accountOrders.filter(order => order.side === 'buy');
                const sellOrders = accountOrders.filter(order => order.side === 'sell');
                expect(buyOrders.length).toBeGreaterThan(0);
                expect(sellOrders.length).toBeGreaterThan(0);
            }
        });
        it('should handle account failures gracefully', async () => {
            // Create accounts with one inactive
            const accounts = [];
            for (let i = 1; i <= 3; i++) {
                const accountData = {
                    name: `Failure Test Account ${i}`,
                    apiKey: `fail-api-key-${i}`,
                    privateKey: `fail-private-key-${i}-32-characters-long`,
                    address: `0x${i.toString().padStart(40, '0')}`
                };
                const response = await (0, supertest_1.default)(app)
                    .post('/api/v1/accounts')
                    .send(accountData)
                    .expect(201);
                accounts.push(response.body.data);
                // Deactivate one account
                if (i === 2) {
                    await (0, supertest_1.default)(app)
                        .post(`/api/v1/accounts/${response.body.data.id}/deactivate`)
                        .expect(200);
                }
            }
            // Create session
            const sessionData = {
                name: 'Account Failure Test',
                strategyId: 'equal-volume-btc',
                accountIds: accounts.map(acc => acc.id),
                targetVolume: 1.0,
                duration: 30000
            };
            const sessionResponse = await (0, supertest_1.default)(app)
                .post('/api/v1/sessions')
                .send(sessionData)
                .expect(201);
            const session = sessionResponse.body.data;
            // Start session - should handle inactive account
            await (0, supertest_1.default)(app)
                .post(`/api/v1/sessions/${session.id}/start`)
                .expect(200);
            // Wait for completion
            await new Promise(resolve => setTimeout(resolve, 35000));
            // Verify session completed with available accounts
            const statusResponse = await (0, supertest_1.default)(app)
                .get(`/api/v1/sessions/${session.id}/status`)
                .expect(200);
            expect(['completed', 'failed']).toContain(statusResponse.body.data.status);
        });
        it('should balance volume across accounts', async () => {
            // Create accounts
            const accounts = [];
            for (let i = 1; i <= 4; i++) {
                const accountData = {
                    name: `Balance Account ${i}`,
                    apiKey: `balance-api-key-${i}`,
                    privateKey: `balance-private-key-${i}-32-characters-long`,
                    address: `0x${i.toString().padStart(40, '0')}`
                };
                const response = await (0, supertest_1.default)(app)
                    .post('/api/v1/accounts')
                    .send(accountData)
                    .expect(201);
                accounts.push(response.body.data);
            }
            // Create session with specific volume
            const sessionData = {
                name: 'Volume Balance Test',
                strategyId: 'equal-volume-btc',
                accountIds: accounts.map(acc => acc.id),
                targetVolume: 1.2, // Should be 0.3 per account
                duration: 45000
            };
            const sessionResponse = await (0, supertest_1.default)(app)
                .post('/api/v1/sessions')
                .send(sessionData)
                .expect(201);
            const session = sessionResponse.body.data;
            // Start session
            await (0, supertest_1.default)(app)
                .post(`/api/v1/sessions/${session.id}/start`)
                .expect(200);
            // Wait for completion
            await new Promise(resolve => setTimeout(resolve, 50000));
            // Verify volume distribution
            const ordersResponse = await (0, supertest_1.default)(app)
                .get(`/api/v1/sessions/${session.id}/orders`)
                .expect(200);
            const orders = ordersResponse.body.data.orders;
            // Calculate volume per account
            const volumeByAccount = orders.reduce((acc, order) => {
                if (!acc[order.accountId]) {
                    acc[order.accountId] = 0;
                }
                acc[order.accountId] += order.volume;
                return acc;
            }, {});
            // Verify each account has approximately equal volume
            const expectedVolumePerAccount = sessionData.targetVolume / accounts.length;
            const tolerance = 0.05; // 5% tolerance
            for (const accountId of accounts.map(acc => acc.id)) {
                const accountVolume = volumeByAccount[accountId] || 0;
                expect(accountVolume).toBeCloseTo(expectedVolumePerAccount, 2);
            }
        });
        it('should handle account reconnection', async () => {
            // Create accounts
            const accounts = [];
            for (let i = 1; i <= 3; i++) {
                const accountData = {
                    name: `Reconnect Account ${i}`,
                    apiKey: `reconnect-api-key-${i}`,
                    privateKey: `reconnect-private-key-${i}-32-characters-long`,
                    address: `0x${i.toString().padStart(40, '0')}`
                };
                const response = await (0, supertest_1.default)(app)
                    .post('/api/v1/accounts')
                    .send(accountData)
                    .expect(201);
                accounts.push(response.body.data);
            }
            // Create session
            const sessionData = {
                name: 'Reconnection Test',
                strategyId: 'equal-volume-btc',
                accountIds: accounts.map(acc => acc.id),
                targetVolume: 0.9,
                duration: 60000
            };
            const sessionResponse = await (0, supertest_1.default)(app)
                .post('/api/v1/sessions')
                .send(sessionData)
                .expect(201);
            const session = sessionResponse.body.data;
            // Start session
            await (0, supertest_1.default)(app)
                .post(`/api/v1/sessions/${session.id}/start`)
                .expect(200);
            // Simulate account disconnection by deactivating one
            await new Promise(resolve => setTimeout(resolve, 10000));
            await (0, supertest_1.default)(app)
                .post(`/api/v1/accounts/${accounts[1].id}/deactivate`)
                .expect(200);
            // Wait a bit
            await new Promise(resolve => setTimeout(resolve, 10000));
            // Reactivate account
            await (0, supertest_1.default)(app)
                .post(`/api/v1/accounts/${accounts[1].id}/activate`)
                .expect(200);
            // Wait for completion
            await new Promise(resolve => setTimeout(resolve, 45000));
            // Verify session handled reconnection
            const statusResponse = await (0, supertest_1.default)(app)
                .get(`/api/v1/sessions/${session.id}/status`)
                .expect(200);
            expect(['completed', 'failed']).toContain(statusResponse.body.data.status);
        });
        it('should maintain account isolation', async () => {
            // Create accounts with different risk limits
            const accounts = [];
            for (let i = 1; i <= 3; i++) {
                const accountData = {
                    name: `Isolation Account ${i}`,
                    apiKey: `isolation-api-key-${i}`,
                    privateKey: `isolation-private-key-${i}-32-characters-long`,
                    address: `0x${i.toString().padStart(40, '0')}`
                };
                const response = await (0, supertest_1.default)(app)
                    .post('/api/v1/accounts')
                    .send(accountData)
                    .expect(201);
                // Set different risk limits for each account
                const riskLimits = {
                    riskLimits: {
                        maxPositionSize: 0.05 + (i * 0.02), // Different limits
                        stopLossThreshold: 0.03 + (i * 0.01),
                        maxSlippage: 0.015 + (i * 0.005)
                    }
                };
                await (0, supertest_1.default)(app)
                    .put(`/api/v1/accounts/${response.body.data.id}`)
                    .send(riskLimits)
                    .expect(200);
                accounts.push(response.body.data);
            }
            // Create session
            const sessionData = {
                name: 'Isolation Test',
                strategyId: 'equal-volume-btc',
                accountIds: accounts.map(acc => acc.id),
                targetVolume: 0.6,
                duration: 30000
            };
            const sessionResponse = await (0, supertest_1.default)(app)
                .post('/api/v1/sessions')
                .send(sessionData)
                .expect(201);
            const session = sessionResponse.body.data;
            // Start session
            await (0, supertest_1.default)(app)
                .post(`/api/v1/sessions/${session.id}/start`)
                .expect(200);
            // Wait for completion
            await new Promise(resolve => setTimeout(resolve, 35000));
            // Verify each account respects its own risk limits
            for (const account of accounts) {
                const accountOrdersResponse = await (0, supertest_1.default)(app)
                    .get(`/api/v1/accounts/${account.id}/orders`)
                    .expect(200);
                const accountOrders = accountOrdersResponse.body.data.orders;
                // Verify no order exceeds account's position size limit
                for (const order of accountOrders) {
                    expect(order.volume).toBeLessThanOrEqual(0.05 + (accounts.indexOf(account) + 1) * 0.02);
                }
            }
        });
    });
});
//# sourceMappingURL=test-account-coordination.js.map