@lgriffin/esi.ts 1.0.0 → 2.0.0

package/tests/bdd-scenarios/performance/bdd-performance.test.ts

@@ -0,0 +1,463 @@
+/**
+ * BDD Scenarios: Performance Testing
+ * 
+ * Comprehensive behavior-driven tests focused on performance characteristics,
+ * load handling, response times, and system scalability.
+ */
+
+import { EsiClient } from '../../../src/EsiClient';
+import { ApiError, ApiErrorType } from '../../../src/core/errors/ApiError';
+import { TestDataFactory } from '../../../src/testing/TestDataFactory';
+
+describe('BDD Scenarios: Performance Testing', () => {
+  let client: EsiClient;
+
+  beforeEach(() => {
+    client = new EsiClient({
+      clientId: 'test-performance-client',
+      baseUrl: 'https://esi.evetech.net',
+      timeout: 30000 // Extended timeout for performance tests
+    });
+  });
+
+  describe('Feature: Response Time Performance', () => {
+    describe('Scenario: API response time benchmarking', () => {
+      it('Given normal system load, When I make API requests, Then response times should be within acceptable limits', async () => {
+        // Given: Normal system load
+        const testCases = [
+          { client: 'alliance', method: 'getAllianceById', args: [99005338], expectedMaxTime: 2000 },
+          { client: 'characters', method: 'getCharacterPublicInfo', args: [1689391488], expectedMaxTime: 1500 },
+          { client: 'corporations', method: 'getCorporationInfo', args: [1344654522], expectedMaxTime: 1500 },
+          { client: 'market', method: 'getMarketPrices', args: [], expectedMaxTime: 3000 },
+          { client: 'universe', method: 'getSystemById', args: [30000142], expectedMaxTime: 1000 }
+        ];
+
+        // Mock responses with simulated network delays
+        jest.spyOn(client.alliance, 'getAllianceById').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 200));
+          return TestDataFactory.createAllianceInfo({ alliance_id: 99005338 });
+        });
+        jest.spyOn(client.characters, 'getCharacterPublicInfo').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 150));
+          return TestDataFactory.createCharacterInfo({ character_id: 1689391488 });
+        });
+        jest.spyOn(client.corporations, 'getCorporationInfo').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 180));
+          return TestDataFactory.createCorporationInfo({ corporation_id: 1344654522 });
+        });
+        jest.spyOn(client.market, 'getMarketPrices').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 300));
+          return [TestDataFactory.createMarketPrice({ type_id: 34 })];
+        });
+        jest.spyOn(client.universe, 'getSystemById').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 100));
+          return TestDataFactory.createSolarSystem({ system_id: 30000142 });
+        });
+
+        // When: I make API requests and measure response times
+        const results = [];
+        for (const testCase of testCases) {
+          const startTime = Date.now();
+          
+          // Dynamic method invocation
+          const apiClient = (client as any)[testCase.client];
+          await apiClient[testCase.method](...testCase.args);
+          
+          const endTime = Date.now();
+          const responseTime = endTime - startTime;
+          
+          results.push({
+            api: `${testCase.client}.${testCase.method}`,
+            responseTime,
+            expectedMaxTime: testCase.expectedMaxTime
+          });
+        }
+
+        // Then: Response times should be within acceptable limits
+        results.forEach(result => {
+          expect(result.responseTime).toBeLessThan(result.expectedMaxTime);
+          expect(result.responseTime).toBeGreaterThan(50); // Should take some time due to mock delays
+        });
+
+        // Verify overall performance characteristics
+        const averageResponseTime = results.reduce((sum, r) => sum + r.responseTime, 0) / results.length;
+        expect(averageResponseTime).toBeLessThan(500); // Average should be under 500ms
+      });
+    });
+
+    describe('Scenario: Performance under varying network conditions', () => {
+      it('Given different network latencies, When I make requests, Then the system should handle varying conditions gracefully', async () => {
+        // Given: Different network latencies
+        const networkConditions = [
+          { name: 'fast', delay: 50 },
+          { name: 'normal', delay: 200 },
+          { name: 'slow', delay: 500 },
+          { name: 'very_slow', delay: 1000 }
+        ];
+
+        const results = [];
+
+        // When: I make requests under different network conditions
+        for (const condition of networkConditions) {
+          jest.spyOn(client.characters, 'getCharacterPublicInfo').mockImplementation(async () => {
+            await new Promise(resolve => setTimeout(resolve, condition.delay));
+            return TestDataFactory.createCharacterInfo({ character_id: 1689391488 });
+          });
+
+          const startTime = Date.now();
+          const result = await client.characters.getCharacterPublicInfo(1689391488);
+          const endTime = Date.now();
+          const responseTime = endTime - startTime;
+
+          results.push({
+            condition: condition.name,
+            expectedDelay: condition.delay,
+            actualResponseTime: responseTime
+          });
+
+          expect(result).toBeDefined();
+        }
+
+        // Then: The system should handle varying conditions gracefully
+        results.forEach(result => {
+          // Response time should be close to expected delay (within 100ms tolerance)
+          expect(result.actualResponseTime).toBeGreaterThanOrEqual(result.expectedDelay);
+          expect(result.actualResponseTime).toBeLessThan(result.expectedDelay + 100);
+        });
+
+        // Verify performance scaling
+        const fastResponse = results.find(r => r.condition === 'fast')!;
+        const slowResponse = results.find(r => r.condition === 'very_slow')!;
+        expect(slowResponse.actualResponseTime).toBeGreaterThan(fastResponse.actualResponseTime * 10);
+      });
+    });
+  });
+
+  describe('Feature: Concurrent Request Handling', () => {
+    describe('Scenario: High concurrency load testing', () => {
+      it('Given high concurrent load, When I make simultaneous requests, Then the system should handle them efficiently', async () => {
+        // Given: High concurrent load
+        const concurrentRequests = 50;
+        const characterIds = Array.from({ length: concurrentRequests }, (_, i) => 1689391488 + i);
+
+        // Mock response with consistent delay
+        jest.spyOn(client.characters, 'getCharacterPublicInfo').mockImplementation(async (id: number) => {
+          await new Promise(resolve => setTimeout(resolve, 100)); // 100ms delay per request
+          return TestDataFactory.createCharacterInfo({ character_id: id, name: `Character ${id}` });
+        });
+
+        // When: I make simultaneous requests
+        const startTime = Date.now();
+        const promises = characterIds.map(id => client.characters.getCharacterPublicInfo(id));
+        const results = await Promise.all(promises);
+        const endTime = Date.now();
+        const totalTime = endTime - startTime;
+
+        // Then: The system should handle them efficiently
+        expect(results).toHaveLength(concurrentRequests);
+        expect(totalTime).toBeLessThan(1000); // Should complete much faster than sequential (5000ms)
+        
+        // Verify all results are correct
+        results.forEach((result, index) => {
+          expect(result.character_id).toBe(characterIds[index]);
+          expect(result.name).toBe(`Character ${characterIds[index]}`);
+        });
+
+        // Calculate efficiency metrics
+        const theoreticalSequentialTime = concurrentRequests * 100; // 5000ms if sequential
+        const efficiencyRatio = theoreticalSequentialTime / totalTime;
+        expect(efficiencyRatio).toBeGreaterThan(10); // Should be at least 10x faster than sequential
+      });
+    });
+
+    describe('Scenario: Mixed API concurrent requests', () => {
+      it('Given mixed API types, When I make concurrent requests across different APIs, Then all should complete successfully', async () => {
+        // Given: Mixed API types
+        const mixedRequests = [
+          { type: 'alliance', id: 99005338 },
+          { type: 'character', id: 1689391488 },
+          { type: 'corporation', id: 1344654522 },
+          { type: 'system', id: 30000142 },
+          { type: 'market', id: null } // Market prices don't need ID
+        ];
+
+        // Mock all different API responses
+        jest.spyOn(client.alliance, 'getAllianceById').mockImplementation(async (id) => {
+          await new Promise(resolve => setTimeout(resolve, 120));
+          return TestDataFactory.createAllianceInfo({ alliance_id: id });
+        });
+        jest.spyOn(client.characters, 'getCharacterPublicInfo').mockImplementation(async (id) => {
+          await new Promise(resolve => setTimeout(resolve, 100));
+          return TestDataFactory.createCharacterInfo({ character_id: id });
+        });
+        jest.spyOn(client.corporations, 'getCorporationInfo').mockImplementation(async (id) => {
+          await new Promise(resolve => setTimeout(resolve, 150));
+          return TestDataFactory.createCorporationInfo({ corporation_id: id });
+        });
+        jest.spyOn(client.universe, 'getSystemById').mockImplementation(async (id) => {
+          await new Promise(resolve => setTimeout(resolve, 80));
+          return TestDataFactory.createSolarSystem({ system_id: id });
+        });
+        jest.spyOn(client.market, 'getMarketPrices').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 200));
+          return [TestDataFactory.createMarketPrice({ type_id: 34 })];
+        });
+
+        // When: I make concurrent requests across different APIs
+        const startTime = Date.now();
+        const promises = mixedRequests.map(request => {
+          switch (request.type) {
+            case 'alliance':
+              return client.alliance.getAllianceById(request.id!);
+            case 'character':
+              return client.characters.getCharacterPublicInfo(request.id!);
+            case 'corporation':
+              return client.corporations.getCorporationInfo(request.id!);
+            case 'system':
+              return client.universe.getSystemById(request.id!);
+            case 'market':
+              return client.market.getMarketPrices();
+            default:
+              throw new Error('Unknown request type');
+          }
+        });
+        
+        const results = await Promise.all(promises);
+        const endTime = Date.now();
+        const totalTime = endTime - startTime;
+
+        // Then: All should complete successfully
+        expect(results).toHaveLength(5);
+        expect(totalTime).toBeLessThan(500); // Should be faster than sequential execution
+        
+        // Verify each result type
+        expect(results[0]).toHaveProperty('alliance_id');
+        expect(results[1]).toHaveProperty('character_id');
+        expect(results[2]).toHaveProperty('corporation_id');
+        expect(results[3]).toHaveProperty('system_id');
+        expect(results[4]).toBeInstanceOf(Array);
+        
+        // Performance should be dominated by slowest request (200ms) plus overhead
+        expect(totalTime).toBeLessThan(300);
+      });
+    });
+  });
+
+  describe('Feature: Large Dataset Handling', () => {
+    describe('Scenario: Processing large market datasets', () => {
+      it('Given large market data, When I process the dataset, Then performance should remain acceptable', async () => {
+        // Given: Large market data
+        const largeOrderCount = 10000;
+        const largeOrderSet = Array.from({ length: largeOrderCount }, (_, i) => 
+          TestDataFactory.createMarketOrder({
+            order_id: 5000000001 + i,
+            type_id: 34,
+            price: 4.00 + (Math.random() * 2),
+            volume_remain: Math.floor(Math.random() * 1000000),
+            is_buy_order: Math.random() > 0.5,
+            location_id: 60003760 + (i % 10) // Spread across 10 locations
+          })
+        );
+
+        // Mock large dataset response
+        jest.spyOn(client.market, 'getMarketOrders').mockResolvedValue(largeOrderSet);
+
+        // When: I process the dataset
+        const startTime = Date.now();
+        const orders = await client.market.getMarketOrders(10000002);
+        
+        // Perform typical market analysis operations
+        const buyOrders = orders.filter((order: any) => order.is_buy_order);
+        const sellOrders = orders.filter((order: any) => !order.is_buy_order);
+        const bestBuyPrice = Math.max(...buyOrders.map((order: any) => order.price));
+        const bestSellPrice = Math.min(...sellOrders.map((order: any) => order.price));
+        const totalVolume = orders.reduce((sum: any, order: any) => sum + order.volume_remain, 0);
+        const locationCounts = orders.reduce((acc: any, order: any) => {
+          acc[order.location_id] = (acc[order.location_id] || 0) + 1;
+          return acc;
+        }, {} as Record<number, number>);
+        
+        const endTime = Date.now();
+        const processingTime = endTime - startTime;
+
+        // Then: Performance should remain acceptable
+        expect(orders.length).toBe(largeOrderCount);
+        expect(processingTime).toBeLessThan(2000); // Should process within 2 seconds
+        
+        // Verify data processing accuracy
+        expect(buyOrders.length + sellOrders.length).toBe(largeOrderCount);
+        expect(bestBuyPrice).toBeGreaterThan(0);
+        expect(bestSellPrice).toBeGreaterThan(0);
+        expect(totalVolume).toBeGreaterThan(0);
+        expect(Object.keys(locationCounts)).toHaveLength(10);
+        
+        // Performance metrics
+        const ordersPerSecond = largeOrderCount / (processingTime / 1000);
+        expect(ordersPerSecond).toBeGreaterThan(5000); // Should process at least 5000 orders/second
+      });
+    });
+
+    describe('Scenario: Handling large corporation member lists', () => {
+      it('Given a large corporation, When I process member data, Then performance should scale appropriately', async () => {
+        // Given: A large corporation
+        const largeMemberCount = 5000;
+        const largeMemberList = Array.from({ length: largeMemberCount }, (_, i) => 1689391488 + i);
+        const memberRoles = Array.from({ length: 100 }, (_, i) => 
+          TestDataFactory.createCorporationMemberRoles({
+            character_id: 1689391488 + i,
+            roles: i < 10 ? ['Director'] : i < 50 ? ['Personnel_Manager'] : ['Member']
+          })
+        );
+
+        // Mock large dataset responses
+        jest.spyOn(client.corporations, 'getCorporationMembers').mockResolvedValue(largeMemberList);
+        jest.spyOn(client.corporations, 'getCorporationRoles').mockResolvedValue(memberRoles);
+
+        // When: I process member data
+        const startTime = Date.now();
+        const [members, roles] = await Promise.all([
+          client.corporations.getCorporationMembers(1344654522),
+          client.corporations.getCorporationRoles(1344654522)
+        ]);
+
+        // Perform typical member analysis
+        const directors = roles.filter((member: any) => member.roles.includes('Director'));
+        const managers = roles.filter((member: any) => member.roles.includes('Personnel_Manager'));
+        const regularMembers = roles.filter((member: any) => member.roles.includes('Member') && member.roles.length === 1);
+        const membershipGrowth = members.length;
+        
+        const endTime = Date.now();
+        const processingTime = endTime - startTime;
+
+        // Then: Performance should scale appropriately
+        expect(members.length).toBe(largeMemberCount);
+        expect(processingTime).toBeLessThan(1500); // Should process within 1.5 seconds
+        
+        // Verify data processing
+        expect(directors.length).toBe(10);
+        expect(managers.length).toBe(40); // 50 total managers minus 10 directors
+        expect(regularMembers.length).toBe(50);
+        expect(membershipGrowth).toBe(largeMemberCount);
+        
+        // Performance scaling
+        const membersPerSecond = largeMemberCount / (processingTime / 1000);
+        expect(membersPerSecond).toBeGreaterThan(3000); // Should process at least 3000 members/second
+      });
+    });
+  });
+
+  describe('Feature: Memory and Resource Management', () => {
+    describe('Scenario: Memory efficiency with large datasets', () => {
+      it('Given memory-intensive operations, When I process large amounts of data, Then memory usage should remain efficient', async () => {
+        // Given: Memory-intensive operations
+        const iterations = 100;
+        const datasetSize = 1000;
+
+        // Mock consistent dataset
+        const mockDataset = Array.from({ length: datasetSize }, (_, i) => 
+          TestDataFactory.createMarketOrder({ order_id: i, price: Math.random() * 100 })
+        );
+
+        jest.spyOn(client.market, 'getMarketOrders').mockResolvedValue(mockDataset);
+
+        // When: I process large amounts of data iteratively
+        const startTime = Date.now();
+        const results = [];
+
+        for (let i = 0; i < iterations; i++) {
+          const orders = await client.market.getMarketOrders(10000002);
+          
+          // Process data and keep only summary
+          const summary = {
+            iteration: i,
+            orderCount: orders.length,
+            averagePrice: orders.reduce((sum: any, order: any) => sum + order.price, 0) / orders.length,
+            maxPrice: Math.max(...orders.map((order: any) => order.price)),
+            minPrice: Math.min(...orders.map((order: any) => order.price))
+          };
+          
+          results.push(summary);
+          
+          // Clear large dataset reference (simulate proper memory management)
+          // In real scenarios, this would be handled by garbage collection
+        }
+
+        const endTime = Date.now();
+        const totalTime = endTime - startTime;
+
+        // Then: Memory usage should remain efficient
+        expect(results.length).toBe(iterations);
+        expect(totalTime).toBeLessThan(5000); // Should complete within 5 seconds
+        
+        // Verify data consistency across iterations
+        const firstIteration = results[0];
+        const lastIteration = results[iterations - 1];
+        
+        expect(firstIteration.orderCount).toBe(datasetSize);
+        expect(lastIteration.orderCount).toBe(datasetSize);
+        expect(firstIteration.averagePrice).toBeCloseTo(lastIteration.averagePrice, 2);
+        
+        // Performance should remain consistent (no memory leaks causing slowdowns)
+        const avgTimePerIteration = totalTime / iterations;
+        expect(avgTimePerIteration).toBeLessThan(50); // Should average under 50ms per iteration
+      });
+    });
+  });
+
+  describe('Feature: Error Handling Performance', () => {
+    describe('Scenario: Performance impact of error conditions', () => {
+      it('Given error conditions, When errors occur, Then error handling should not significantly impact performance', async () => {
+        // Given: Error conditions
+        const totalRequests = 20;
+        const errorRate = 0.3; // 30% error rate
+        const successfulRequests = Math.floor(totalRequests * (1 - errorRate));
+        const failedRequests = totalRequests - successfulRequests;
+
+        let requestCount = 0;
+        jest.spyOn(client.characters, 'getCharacterPublicInfo').mockImplementation(async (id: number) => {
+          requestCount++;
+          await new Promise(resolve => setTimeout(resolve, 100)); // Base delay
+          
+          // Simulate error rate - fail 30% of requests based on character ID
+          if (id % 10 < 3) { // This will fail roughly 30% of requests
+            throw TestDataFactory.createError(ApiErrorType.SERVER_ERROR, 500);
+          }
+          
+          return TestDataFactory.createCharacterInfo({ character_id: id });
+        });
+
+        // When: Errors occur during requests
+        const startTime = Date.now();
+        const promises = Array.from({ length: totalRequests }, (_, i) => 
+          client.characters.getCharacterPublicInfo(1689391488 + i)
+            .catch(error => ({ error: true, details: error }))
+        );
+        
+        const results = await Promise.all(promises);
+        const endTime = Date.now();
+        const totalTime = endTime - startTime;
+
+        // Then: Error handling should not significantly impact performance
+        const errors = results.filter((result: any) => result.error);
+        const successes = results.filter((result: any) => !result.error);
+        
+        // With our error logic (id % 10 < 3), we expect 6 errors out of 20 requests
+        const expectedErrors = Array.from({ length: totalRequests }, (_, i) => 1689391488 + i)
+          .filter(id => id % 10 < 3).length;
+        
+        expect(errors.length).toBe(expectedErrors);
+        expect(successes.length).toBe(totalRequests - expectedErrors);
+        expect(totalTime).toBeLessThan(1000); // Should still complete quickly despite errors
+        
+        // Error handling overhead should be minimal
+        const avgTimePerRequest = totalTime / totalRequests;
+        expect(avgTimePerRequest).toBeLessThan(150); // Should be close to base delay (100ms) plus minimal overhead
+        
+        // Verify error objects are properly formed
+        errors.forEach((errorResult: any) => {
+          expect(errorResult.details).toBeInstanceOf(ApiError);
+        });
+      });
+    });
+  });
+});