@lgriffin/esi.ts 1.0.0 → 2.0.0

package/tests/bdd/simple-bdd-demo.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Simple BDD-Style Testing Demo
+ * 
+ * This demonstrates BDD principles using Jest with descriptive test names
+ * and Given/When/Then patterns in the test structure.
+ */
+
+import { EsiClient } from '../../src/EsiClient';
+import { ApiError, ApiErrorType } from '../../src/core/errors/ApiError';
+import { TestDataFactory } from '../../src/testing/TestDataFactory';
+
+describe('BDD Demo: Alliance Management', () => {
+  let client: EsiClient;
+
+  beforeEach(() => {
+    client = new EsiClient({
+      clientId: 'test-client',
+      baseUrl: 'https://esi.evetech.net',
+      timeout: 5000
+    });
+  });
+
+  describe('Feature: Retrieve Alliance Information', () => {
+    describe('Scenario: Get alliance details for valid alliance ID', () => {
+      it('Given a valid alliance ID, When I request alliance details, Then I should receive complete alliance information', async () => {
+        // Given: A valid alliance ID
+        const validAllianceId = 99005338;
+        const expectedAlliance = TestDataFactory.createAllianceInfo({
+          alliance_id: validAllianceId,
+          name: 'Goonswarm Federation'
+        });
+
+        // Mock the API response
+        jest.spyOn(client.alliance, 'getAllianceById').mockResolvedValue(expectedAlliance);
+
+        // When: I request alliance details
+        const result = await client.alliance.getAllianceById(validAllianceId);
+
+        // Then: I should receive complete alliance information
+        expect(result).toBeDefined();
+        expect(result.alliance_id).toBe(validAllianceId);
+        expect(result.name).toBe('Goonswarm Federation');
+        expect(result).toHaveProperty('ticker');
+        expect(result).toHaveProperty('creator_id');
+      });
+    });
+
+    describe('Scenario: Handle non-existent alliance ID', () => {
+      it('Given an invalid alliance ID, When I request alliance details, Then I should receive a not found error', async () => {
+        // Given: An invalid alliance ID
+        const invalidAllianceId = 999999999;
+        const expectedError = TestDataFactory.createError(ApiErrorType.NOT_FOUND_ERROR, 404);
+
+        // Mock the API to throw an error
+        jest.spyOn(client.alliance, 'getAllianceById').mockRejectedValue(expectedError);
+
+        // When & Then: I request alliance details and expect an error
+        await expect(client.alliance.getAllianceById(invalidAllianceId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+
+    describe('Scenario: Handle network connectivity issues', () => {
+      it('Given network connectivity problems, When I request alliance details, Then I should receive a network error with retry capability', async () => {
+        // Given: Network connectivity problems
+        const allianceId = 99005338;
+        const networkError = TestDataFactory.createError(ApiErrorType.NETWORK_ERROR);
+
+        // Mock the API to throw a network error
+        jest.spyOn(client.alliance, 'getAllianceById').mockRejectedValue(networkError);
+
+        // When & Then: I request alliance details and expect a network error
+        await expect(client.alliance.getAllianceById(allianceId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+  });
+
+  describe('Feature: Alliance Contact Management', () => {
+    describe('Scenario: Retrieve alliance contacts', () => {
+      it('Given a valid alliance with contacts, When I request contact list, Then I should receive an array of contacts', async () => {
+        // Given: A valid alliance with contacts
+        const allianceId = 99005338;
+        const expectedContacts = [
+          TestDataFactory.createAllianceContact({
+            contact_id: 1689391488,
+            contact_type: 'character',
+            standing: 10.0
+          }),
+          TestDataFactory.createAllianceContact({
+            contact_id: 1344654522,
+            contact_type: 'corporation',
+            standing: 5.0
+          })
+        ];
+
+        // Mock the API response
+        jest.spyOn(client.alliance, 'getContacts').mockResolvedValue(expectedContacts);
+
+        // When: I request the contact list
+        const result = await client.alliance.getContacts(allianceId);
+
+        // Then: I should receive an array of contacts
+        expect(result).toBeInstanceOf(Array);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toHaveProperty('contact_id');
+        expect(result[0]).toHaveProperty('contact_type');
+        expect(result[0]).toHaveProperty('standing');
+      });
+    });
+
+    describe('Scenario: Handle empty contact list', () => {
+      it('Given an alliance with no contacts, When I request contact list, Then I should receive an empty array', async () => {
+        // Given: An alliance with no contacts
+        const allianceId = 99005338;
+        const emptyContacts: any[] = [];
+
+        // Mock the API response
+        jest.spyOn(client.alliance, 'getContacts').mockResolvedValue(emptyContacts);
+
+        // When: I request the contact list
+        const result = await client.alliance.getContacts(allianceId);
+
+        // Then: I should receive an empty array
+        expect(result).toBeInstanceOf(Array);
+        expect(result).toHaveLength(0);
+      });
+    });
+  });
+
+  describe('Feature: API Resilience and Performance', () => {
+    describe('Scenario: Handle rate limiting gracefully', () => {
+      it('Given API rate limiting is active, When I make requests, Then I should receive appropriate rate limit errors', async () => {
+        // Given: API rate limiting is active
+        const allianceId = 99005338;
+        const rateLimitError = TestDataFactory.createError(ApiErrorType.RATE_LIMIT_ERROR, 429);
+
+        // Mock the API to throw a rate limit error
+        jest.spyOn(client.alliance, 'getAllianceById').mockRejectedValue(rateLimitError);
+
+        // When & Then: I make a request and expect a rate limit error
+        await expect(client.alliance.getAllianceById(allianceId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+
+    describe('Scenario: Measure response performance', () => {
+      it('Given normal API conditions, When I request alliance data, Then the response should be within acceptable time limits', async () => {
+        // Given: Normal API conditions
+        const allianceId = 99005338;
+        const mockAlliance = TestDataFactory.createAllianceInfo({ alliance_id: allianceId });
+
+        // Mock the API response with a slight delay to simulate network
+        jest.spyOn(client.alliance, 'getAllianceById').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 100)); // 100ms delay
+          return mockAlliance;
+        });
+
+        // When: I request alliance data and measure time
+        const startTime = Date.now();
+        const result = await client.alliance.getAllianceById(allianceId);
+        const endTime = Date.now();
+        const responseTime = endTime - startTime;
+
+        // Then: The response should be within acceptable time limits
+        expect(result).toBeDefined();
+        expect(responseTime).toBeLessThan(5000); // Should complete within 5 seconds
+        expect(responseTime).toBeGreaterThan(50);  // Should take at least 50ms (due to our mock delay)
+      });
+    });
+  });
+
+  describe('Feature: Integration Workflows', () => {
+    describe('Scenario: Complete alliance information gathering', () => {
+      it('Given a valid alliance ID, When I gather complete alliance information, Then I should successfully retrieve all related data', async () => {
+        // Given: A valid alliance ID
+        const allianceId = 99005338;
+        const mockAlliance = TestDataFactory.createAllianceInfo({ alliance_id: allianceId });
+        const mockContacts = [TestDataFactory.createAllianceContact()];
+        const mockCorporations = [1344654522, 1344654523];
+
+        // Mock all API responses
+        jest.spyOn(client.alliance, 'getAllianceById').mockResolvedValue(mockAlliance);
+        jest.spyOn(client.alliance, 'getContacts').mockResolvedValue(mockContacts);
+        jest.spyOn(client.alliance, 'getCorporations').mockResolvedValue(mockCorporations);
+
+        // When: I gather complete alliance information
+        const [alliance, contacts, corporations] = await Promise.all([
+          client.alliance.getAllianceById(allianceId),
+          client.alliance.getContacts(allianceId),
+          client.alliance.getCorporations(allianceId)
+        ]);
+
+        // Then: I should successfully retrieve all related data
+        expect(alliance).toBeDefined();
+        expect(alliance.alliance_id).toBe(allianceId);
+        
+        expect(contacts).toBeInstanceOf(Array);
+        expect(contacts.length).toBeGreaterThanOrEqual(0);
+        
+        expect(corporations).toBeInstanceOf(Array);
+        expect(corporations.length).toBeGreaterThan(0);
+        expect(typeof corporations[0]).toBe('number');
+      });
+    });
+  });
+});

package/tests/bdd-scenarios/core/bdd-alliance.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Simple BDD-Style Testing Demo
+ * 
+ * This demonstrates BDD principles using Jest with descriptive test names
+ * and Given/When/Then patterns in the test structure.
+ */
+
+import { EsiClient } from '../../../src/EsiClient';
+import { ApiError, ApiErrorType } from '../../../src/core/errors/ApiError';
+import { TestDataFactory } from '../../../src/testing/TestDataFactory';
+
+describe('BDD Demo: Alliance Management', () => {
+  let client: EsiClient;
+
+  beforeEach(() => {
+    client = new EsiClient({
+      clientId: 'test-client',
+      baseUrl: 'https://esi.evetech.net',
+      timeout: 5000
+    });
+  });
+
+  describe('Feature: Retrieve Alliance Information', () => {
+    describe('Scenario: Get alliance details for valid alliance ID', () => {
+      it('Given a valid alliance ID, When I request alliance details, Then I should receive complete alliance information', async () => {
+        // Given: A valid alliance ID
+        const validAllianceId = 99005338;
+        const expectedAlliance = TestDataFactory.createAllianceInfo({
+          alliance_id: validAllianceId,
+          name: 'Goonswarm Federation'
+        });
+
+        // Mock the API response
+        jest.spyOn(client.alliance, 'getAllianceById').mockResolvedValue(expectedAlliance);
+
+        // When: I request alliance details
+        const result = await client.alliance.getAllianceById(validAllianceId);
+
+        // Then: I should receive complete alliance information
+        expect(result).toBeDefined();
+        expect(result.alliance_id).toBe(validAllianceId);
+        expect(result.name).toBe('Goonswarm Federation');
+        expect(result).toHaveProperty('ticker');
+        expect(result).toHaveProperty('creator_id');
+      });
+    });
+
+    describe('Scenario: Handle non-existent alliance ID', () => {
+      it('Given an invalid alliance ID, When I request alliance details, Then I should receive a not found error', async () => {
+        // Given: An invalid alliance ID
+        const invalidAllianceId = 999999999;
+        const expectedError = TestDataFactory.createError(ApiErrorType.NOT_FOUND_ERROR, 404);
+
+        // Mock the API to throw an error
+        jest.spyOn(client.alliance, 'getAllianceById').mockRejectedValue(expectedError);
+
+        // When & Then: I request alliance details and expect an error
+        await expect(client.alliance.getAllianceById(invalidAllianceId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+
+    describe('Scenario: Handle network connectivity issues', () => {
+      it('Given network connectivity problems, When I request alliance details, Then I should receive a network error with retry capability', async () => {
+        // Given: Network connectivity problems
+        const allianceId = 99005338;
+        const networkError = TestDataFactory.createError(ApiErrorType.NETWORK_ERROR);
+
+        // Mock the API to throw a network error
+        jest.spyOn(client.alliance, 'getAllianceById').mockRejectedValue(networkError);
+
+        // When & Then: I request alliance details and expect a network error
+        await expect(client.alliance.getAllianceById(allianceId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+  });
+
+  describe('Feature: Alliance Contact Management', () => {
+    describe('Scenario: Retrieve alliance contacts', () => {
+      it('Given a valid alliance with contacts, When I request contact list, Then I should receive an array of contacts', async () => {
+        // Given: A valid alliance with contacts
+        const allianceId = 99005338;
+        const expectedContacts = [
+          TestDataFactory.createAllianceContact({
+            contact_id: 1689391488,
+            contact_type: 'character',
+            standing: 10.0
+          }),
+          TestDataFactory.createAllianceContact({
+            contact_id: 1344654522,
+            contact_type: 'corporation',
+            standing: 5.0
+          })
+        ];
+
+        // Mock the API response
+        jest.spyOn(client.alliance, 'getContacts').mockResolvedValue(expectedContacts);
+
+        // When: I request the contact list
+        const result = await client.alliance.getContacts(allianceId);
+
+        // Then: I should receive an array of contacts
+        expect(result).toBeInstanceOf(Array);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toHaveProperty('contact_id');
+        expect(result[0]).toHaveProperty('contact_type');
+        expect(result[0]).toHaveProperty('standing');
+      });
+    });
+
+    describe('Scenario: Handle empty contact list', () => {
+      it('Given an alliance with no contacts, When I request contact list, Then I should receive an empty array', async () => {
+        // Given: An alliance with no contacts
+        const allianceId = 99005338;
+        const emptyContacts: any[] = [];
+
+        // Mock the API response
+        jest.spyOn(client.alliance, 'getContacts').mockResolvedValue(emptyContacts);
+
+        // When: I request the contact list
+        const result = await client.alliance.getContacts(allianceId);
+
+        // Then: I should receive an empty array
+        expect(result).toBeInstanceOf(Array);
+        expect(result).toHaveLength(0);
+      });
+    });
+  });
+
+  describe('Feature: API Resilience and Performance', () => {
+    describe('Scenario: Handle rate limiting gracefully', () => {
+      it('Given API rate limiting is active, When I make requests, Then I should receive appropriate rate limit errors', async () => {
+        // Given: API rate limiting is active
+        const allianceId = 99005338;
+        const rateLimitError = TestDataFactory.createError(ApiErrorType.RATE_LIMIT_ERROR, 429);
+
+        // Mock the API to throw a rate limit error
+        jest.spyOn(client.alliance, 'getAllianceById').mockRejectedValue(rateLimitError);
+
+        // When & Then: I make a request and expect a rate limit error
+        await expect(client.alliance.getAllianceById(allianceId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+
+    describe('Scenario: Measure response performance', () => {
+      it('Given normal API conditions, When I request alliance data, Then the response should be within acceptable time limits', async () => {
+        // Given: Normal API conditions
+        const allianceId = 99005338;
+        const mockAlliance = TestDataFactory.createAllianceInfo({ alliance_id: allianceId });
+
+        // Mock the API response with a slight delay to simulate network
+        jest.spyOn(client.alliance, 'getAllianceById').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 100)); // 100ms delay
+          return mockAlliance;
+        });
+
+        // When: I request alliance data and measure time
+        const startTime = Date.now();
+        const result = await client.alliance.getAllianceById(allianceId);
+        const endTime = Date.now();
+        const responseTime = endTime - startTime;
+
+        // Then: The response should be within acceptable time limits
+        expect(result).toBeDefined();
+        expect(responseTime).toBeLessThan(5000); // Should complete within 5 seconds
+        expect(responseTime).toBeGreaterThan(50);  // Should take at least 50ms (due to our mock delay)
+      });
+    });
+  });
+
+  describe('Feature: Integration Workflows', () => {
+    describe('Scenario: Complete alliance information gathering', () => {
+      it('Given a valid alliance ID, When I gather complete alliance information, Then I should successfully retrieve all related data', async () => {
+        // Given: A valid alliance ID
+        const allianceId = 99005338;
+        const mockAlliance = TestDataFactory.createAllianceInfo({ alliance_id: allianceId });
+        const mockContacts = [TestDataFactory.createAllianceContact()];
+        const mockCorporations = [1344654522, 1344654523];
+
+        // Mock all API responses
+        jest.spyOn(client.alliance, 'getAllianceById').mockResolvedValue(mockAlliance);
+        jest.spyOn(client.alliance, 'getContacts').mockResolvedValue(mockContacts);
+        jest.spyOn(client.alliance, 'getCorporations').mockResolvedValue(mockCorporations);
+
+        // When: I gather complete alliance information
+        const [alliance, contacts, corporations] = await Promise.all([
+          client.alliance.getAllianceById(allianceId),
+          client.alliance.getContacts(allianceId),
+          client.alliance.getCorporations(allianceId)
+        ]);
+
+        // Then: I should successfully retrieve all related data
+        expect(alliance).toBeDefined();
+        expect(alliance.alliance_id).toBe(allianceId);
+        
+        expect(contacts).toBeInstanceOf(Array);
+        expect(contacts.length).toBeGreaterThanOrEqual(0);
+        
+        expect(corporations).toBeInstanceOf(Array);
+        expect(corporations.length).toBeGreaterThan(0);
+        expect(typeof corporations[0]).toBe('number');
+      });
+    });
+  });
+});