@lgriffin/esi.ts 1.0.0 → 2.0.0

package/tests/tdd/alliances/AllianceClient.improved.test.ts

@@ -0,0 +1,266 @@
+import { AllianceClient } from '../../../src/clients/AllianceClient';
+import { ApiClient } from '../../../src/core/ApiClient';
+import { ApiError, ApiErrorType } from '../../../src/core/errors/ApiError';
+import { 
+    TestDataFactory, 
+    MockApiClient, 
+    TestScenarios, 
+    TestAssertions,
+    createMockApiClient
+} from '../../../src/testing/TestHelpers';
+import { AllianceInfo } from '../../../src/types/api-responses';
+
+// Mock the actual API modules
+jest.mock('../../../src/api/alliances/getAllianceById');
+jest.mock('../../../src/api/alliances/getAllianceContacts');
+jest.mock('../../../src/api/alliances/getAllianceContactLabels');
+
+describe('AllianceClient - Resilient Tests', () => {
+    let allianceClient: AllianceClient;
+    let mockApiClient: ApiClient;
+    let mockAlliance: AllianceInfo;
+
+    beforeEach(() => {
+        mockApiClient = createMockApiClient();
+        allianceClient = new AllianceClient(mockApiClient);
+        mockAlliance = TestDataFactory.createAllianceInfo();
+
+        // Reset all mocks
+        jest.clearAllMocks();
+    });
+
+    describe('getAllianceById', () => {
+        it('should return valid alliance info with proper types', async () => {
+            const startTime = Date.now();
+            
+            // Mock the API response
+            const mockGetAllianceById = jest.fn().mockResolvedValue(mockAlliance);
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+
+            const result = await allianceClient.getAllianceById(mockAlliance.alliance_id);
+
+            // Assertions
+            TestAssertions.assertValidAllianceInfo(result);
+            TestAssertions.assertResponseTime(startTime, 1000); // Max 1 second
+            
+            expect(result.alliance_id).toBe(mockAlliance.alliance_id);
+            expect(result.name).toBe(mockAlliance.name);
+            expect(mockGetAllianceById).toHaveBeenCalledWith(mockAlliance.alliance_id);
+        });
+
+        it('should handle network errors gracefully', async () => {
+            const networkError = TestDataFactory.createError(ApiErrorType.NETWORK_ERROR);
+            const mockGetAllianceById = jest.fn().mockRejectedValue(networkError);
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+
+            await expect(allianceClient.getAllianceById(99005338))
+                .rejects
+                .toThrow(ApiError);
+
+            try {
+                await allianceClient.getAllianceById(99005338);
+            } catch (error) {
+                TestAssertions.assertValidError(error);
+                expect(error.type).toBe(ApiErrorType.NETWORK_ERROR);
+            }
+        });
+
+        it('should validate input parameters', async () => {
+            // Mock the API to simulate validation
+            const mockGetAllianceById = jest.fn().mockImplementation((id) => {
+                if (!id || id <= 0) {
+                    throw TestDataFactory.createError(ApiErrorType.VALIDATION_ERROR, 400);
+                }
+                return Promise.resolve(mockAlliance);
+            });
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+
+            const invalidInputs = [0, -1, NaN];
+
+            for (const invalidInput of invalidInputs) {
+                await expect(allianceClient.getAllianceById(invalidInput as any))
+                    .rejects
+                    .toThrow(ApiError);
+            }
+        });
+
+        it('should handle rate limiting with proper error type', async () => {
+            const rateLimitError = TestDataFactory.createError(ApiErrorType.RATE_LIMIT_ERROR, 429);
+            const mockGetAllianceById = jest.fn().mockRejectedValue(rateLimitError);
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+
+            try {
+                await allianceClient.getAllianceById(99005338);
+            } catch (error) {
+                expect(error).toBeInstanceOf(ApiError);
+                if (error instanceof ApiError) {
+                    expect(error.type).toBe(ApiErrorType.RATE_LIMIT_ERROR);
+                    expect(error.statusCode).toBe(429);
+                }
+            }
+        });
+
+        it('should handle concurrent requests', async () => {
+            const mockGetAllianceById = jest.fn().mockResolvedValue(mockAlliance);
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+
+            const results = await TestScenarios.testConcurrency(
+                () => allianceClient.getAllianceById(99005338),
+                5
+            );
+
+            expect(results).toHaveLength(5);
+            results.forEach(result => {
+                TestAssertions.assertValidAllianceInfo(result);
+            });
+            expect(mockGetAllianceById).toHaveBeenCalledTimes(5);
+        });
+
+        it('should handle server errors and provide meaningful error info', async () => {
+            const serverError = TestDataFactory.createError(ApiErrorType.SERVER_ERROR, 500);
+            const mockGetAllianceById = jest.fn().mockRejectedValue(serverError);
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+
+            try {
+                await allianceClient.getAllianceById(99005338);
+            } catch (error) {
+                TestAssertions.assertValidError(error);
+                expect(error.type).toBe(ApiErrorType.SERVER_ERROR);
+                expect(error.statusCode).toBe(500);
+                expect(error.timestamp).toBeInstanceOf(Date);
+            }
+        });
+    });
+
+    describe('getContacts', () => {
+        it('should return array of contacts with proper validation', async () => {
+            const mockContacts = [
+                TestDataFactory.createAllianceContact(),
+                TestDataFactory.createAllianceContact({ contact_id: 2, contact_type: 'corporation' })
+            ];
+
+            const mockGetContacts = jest.fn().mockResolvedValue(mockContacts);
+            (allianceClient as any).allianceContactsApi = { getAllianceContacts: mockGetContacts };
+
+            const result = await allianceClient.getContacts(99005338);
+
+            TestAssertions.assertArrayNotEmpty(result, 'Contacts array should not be empty');
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(2);
+            
+            result.forEach(contact => {
+                expect(contact).toHaveProperty('contact_id');
+                expect(contact).toHaveProperty('contact_type');
+                expect(contact).toHaveProperty('standing');
+                expect(typeof contact.contact_id).toBe('number');
+                expect(['character', 'corporation', 'alliance']).toContain(contact.contact_type);
+                expect(typeof contact.standing).toBe('number');
+            });
+        });
+
+        it('should handle empty results gracefully', async () => {
+            const mockGetContacts = jest.fn().mockResolvedValue([]);
+            (allianceClient as any).allianceContactsApi = { getAllianceContacts: mockGetContacts };
+
+            const result = await allianceClient.getContacts(99005338);
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(0);
+        });
+    });
+
+    describe('Error Recovery Scenarios', () => {
+        it('should implement fallback mechanism', async () => {
+            const primaryError = TestDataFactory.createError(ApiErrorType.SERVER_ERROR, 500);
+            const fallbackData = TestDataFactory.createAllianceInfo({ name: 'Fallback Alliance' });
+
+            const primaryOperation = jest.fn().mockRejectedValue(primaryError);
+            const fallbackOperation = jest.fn().mockResolvedValue(fallbackData);
+
+            const result = await TestScenarios.testErrorRecovery(
+                primaryOperation,
+                fallbackOperation
+            );
+
+            expect((result as any).name).toBe('Fallback Alliance');
+            expect(primaryOperation).toHaveBeenCalledTimes(1);
+            expect(fallbackOperation).toHaveBeenCalledTimes(1);
+        });
+
+        it('should test retry logic with exponential backoff', async () => {
+            let attemptCount = 0;
+            const mockOperation = jest.fn().mockImplementation(() => {
+                attemptCount++;
+                if (attemptCount <= 2) {
+                    throw TestDataFactory.createError(ApiErrorType.NETWORK_ERROR);
+                }
+                return Promise.resolve(mockAlliance);
+            });
+
+            const result = await TestScenarios.testRetryLogic(mockOperation, 3, 2);
+
+            expect(result).toEqual(mockAlliance);
+            expect(mockOperation).toHaveBeenCalledTimes(3);
+        });
+    });
+
+    describe('Performance Tests', () => {
+        it('should complete requests within acceptable time limits', async () => {
+            const mockGetAllianceById = jest.fn().mockImplementation(async () => {
+                // Simulate some processing time
+                await new Promise(resolve => setTimeout(resolve, 100));
+                return mockAlliance;
+            });
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+
+            const startTime = Date.now();
+            const result = await allianceClient.getAllianceById(99005338);
+            
+            TestAssertions.assertResponseTime(startTime, 500); // Max 500ms
+            expect(result).toEqual(mockAlliance);
+        });
+
+        it('should handle high-frequency requests', async () => {
+            const mockGetAllianceById = jest.fn().mockResolvedValue(mockAlliance);
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+
+            const startTime = Date.now();
+            const promises = Array(50).fill(null).map(() => 
+                allianceClient.getAllianceById(99005338)
+            );
+
+            const results = await Promise.all(promises);
+            
+            TestAssertions.assertResponseTime(startTime, 2000); // Max 2 seconds for 50 requests
+            expect(results).toHaveLength(50);
+            expect(mockGetAllianceById).toHaveBeenCalledTimes(50);
+        });
+    });
+
+    describe('Integration-like Tests', () => {
+        it('should maintain consistent behavior across multiple operations', async () => {
+            const mockGetAllianceById = jest.fn().mockResolvedValue(mockAlliance);
+            const mockGetContacts = jest.fn().mockResolvedValue([TestDataFactory.createAllianceContact()]);
+            const mockGetContactLabels = jest.fn().mockResolvedValue([TestDataFactory.createAllianceContactLabel()]);
+
+            (allianceClient as any).allianceApi = { getAllianceById: mockGetAllianceById };
+            (allianceClient as any).allianceContactsApi = { getAllianceContacts: mockGetContacts };
+            (allianceClient as any).allianceContactLabelsApi = { getAllianceContactLabels: mockGetContactLabels };
+
+            // Test multiple operations in sequence
+            const allianceInfo = await allianceClient.getAllianceById(99005338);
+            const contacts = await allianceClient.getContacts(99005338);
+            const labels = await allianceClient.getContactLabels(99005338);
+
+            // Verify all operations completed successfully
+            TestAssertions.assertValidAllianceInfo(allianceInfo);
+            TestAssertions.assertArrayNotEmpty(contacts);
+            TestAssertions.assertArrayNotEmpty(labels);
+
+            // Verify all mocks were called
+            expect(mockGetAllianceById).toHaveBeenCalledTimes(1);
+            expect(mockGetContacts).toHaveBeenCalledTimes(1);
+            expect(mockGetContactLabels).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/tests/tdd/alliances/AllianceClient.test.ts

@@ -1,27 +1,198 @@
 import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
 import { AllianceClient } from '../../../src/clients/AllianceClient';
 import { getConfig } from '../../../src/config/configManager';
+import { getBody } from '../../../src/core/util/testHelpers';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
 
 describe('AllianceClient', () => {
-    const config = getConfig();
-    const client = new ApiClientBuilder()
-        .setClientId(config.projectName)
-        .setLink(config.link)
-        .setAccessToken(config.authToken || undefined)
-        .build();
+    let allianceClient: AllianceClient;
+
+    beforeEach(() => {
+        fetchMock.resetMocks();
+        
+        const config = getConfig();
+        const client = new ApiClientBuilder()
+            .setClientId(config.projectName)
+            .setLink(config.link)
+            .setAccessToken(config.authToken || undefined)
+            .build();
+
+        allianceClient = new AllianceClient(client);
+    });
+
+    describe('getAllianceById', () => {
+        it('should return valid alliance information', async () => {
+            const allianceId = 99005338;
+            const mockResponse = { 
+                alliance_id: allianceId, 
+                name: 'Goonswarm Federation',
+                ticker: 'CONDI',
+                creator_id: 12345,
+                creator_corporation_id: 67890,
+                date_founded: '2010-05-23T05:20:00Z'
+            };
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => allianceClient.getAllianceById(allianceId));
+            
+            expect(result.alliance_id).toBe(allianceId);
+            expect(result.name).toBe('Goonswarm Federation');
+            expect(result.ticker).toBe('CONDI');
+            expect(result.creator_id).toBe(12345);
+            expect(result.creator_corporation_id).toBe(67890);
+            expect(result.date_founded).toBe('2010-05-23T05:20:00Z');
+        });
 
-    const allianceClient = new AllianceClient(client);
+        it('should handle API errors gracefully', async () => {
+            const allianceId = 99999999;
+            fetchMock.mockResponseOnce('Not Found', { status: 404 });
 
-    it('should call getAllianceById and return a valid response', async () => {
-        const allianceId = 12345;
-        const mockResponse = { alliance_id: allianceId, name: 'Test Alliance' };
+            const result = await getBody(() => allianceClient.getAllianceById(allianceId));
+            expect(result).toHaveProperty('error');
+            expect(result.error).toBe('resource not found');
+        });
+    });
+
+    describe('getContacts', () => {
+        it('should return valid alliance contacts', async () => {
+            const allianceId = 99005338;
+            const mockResponse = [
+                {
+                    contact_id: 123456,
+                    contact_type: 'character',
+                    standing: 10.0,
+                    label_ids: [1, 2]
+                },
+                {
+                    contact_id: 789012,
+                    contact_type: 'corporation',
+                    standing: -5.0,
+                    label_ids: [3]
+                }
+            ];
 
-        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
 
-        const result = await getBody(() => allianceClient.getAllianceById(allianceId));
-        expect(result.alliance_id).toBe(allianceId);
-        expect(result.name).toBe('Test Alliance');
+            const result = await getBody(() => allianceClient.getContacts(allianceId));
+            
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(2);
+            
+            expect(result[0].contact_id).toBe(123456);
+            expect(result[0].contact_type).toBe('character');
+            expect(result[0].standing).toBe(10.0);
+            expect(result[0].label_ids).toEqual([1, 2]);
+            
+            expect(result[1].contact_id).toBe(789012);
+            expect(result[1].contact_type).toBe('corporation');
+            expect(result[1].standing).toBe(-5.0);
+            expect(result[1].label_ids).toEqual([3]);
+        });
     });
 
-    // TODO: Add similar tests for other methods like getContacts, getContactLabels, etc.
+    describe('getContactLabels', () => {
+        it('should return valid alliance contact labels', async () => {
+            const allianceId = 99005338;
+            const mockResponse = [
+                {
+                    label_id: 1,
+                    name: 'Allies'
+                },
+                {
+                    label_id: 2,
+                    name: 'Neutrals'
+                },
+                {
+                    label_id: 3,
+                    name: 'Enemies'
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => allianceClient.getContactLabels(allianceId));
+            
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(3);
+            
+            expect(result[0].label_id).toBe(1);
+            expect(result[0].name).toBe('Allies');
+            expect(result[1].label_id).toBe(2);
+            expect(result[1].name).toBe('Neutrals');
+            expect(result[2].label_id).toBe(3);
+            expect(result[2].name).toBe('Enemies');
+        });
+    });
+
+    describe('getCorporations', () => {
+        it('should return valid alliance corporation IDs', async () => {
+            const allianceId = 99005338;
+            const mockResponse = [1344654522, 98306624, 1727758877, 98409330];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => allianceClient.getCorporations(allianceId));
+            
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(4);
+            expect(result).toEqual([1344654522, 98306624, 1727758877, 98409330]);
+            
+            // Verify all entries are numbers
+            result.forEach((corpId: number) => {
+                expect(typeof corpId).toBe('number');
+            });
+        });
+    });
+
+    describe('getIcons', () => {
+        it('should return valid alliance icon URLs', async () => {
+            const allianceId = 99005338;
+            const mockResponse = {
+                px64x64: 'https://images.evetech.net/alliances/99005338/logo?size=64',
+                px128x128: 'https://images.evetech.net/alliances/99005338/logo?size=128'
+            };
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => allianceClient.getIcons(allianceId));
+            
+            expect(result.px64x64).toBe('https://images.evetech.net/alliances/99005338/logo?size=64');
+            expect(result.px128x128).toBe('https://images.evetech.net/alliances/99005338/logo?size=128');
+        });
+    });
+
+    describe('getAlliances', () => {
+        it('should return valid list of all alliance IDs', async () => {
+            const mockResponse = [99005338, 99005551, 99010079, 99011978];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            // getAlliances uses handleRequestBody, so it returns the body directly
+            const result = await allianceClient.getAlliances();
+            
+            expect(Array.isArray(result)).toBe(true);
+            expect(result.length).toBeGreaterThan(0);
+            
+            // Verify all entries are numbers (alliance IDs)
+            result.forEach((allianceId: number) => {
+                expect(typeof allianceId).toBe('number');
+                expect(allianceId).toBeGreaterThan(0);
+            });
+        });
+
+        it('should handle empty alliance list', async () => {
+            const mockResponse: number[] = [];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            // getAlliances uses handleRequestBody, so it returns the body directly
+            const result = await allianceClient.getAlliances();
+            
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(0);
+        });
+    });
 });

package/tests/tdd/alliances/getAlliances.test.ts

@@ -8,15 +8,12 @@ interface Alliance {
     alliance_id: number;
 }
 
-let alliancesApi: AllAlliancesApi;
-
-beforeAll(() => {
-    alliancesApi = new AllAlliancesApi(getClient());
-});
-
 describe('AlliancesApi', () => {
+    let alliancesApi: AllAlliancesApi;
+
     beforeEach(() => {
         fetchMock.resetMocks();
+        alliancesApi = new AllAlliancesApi(getClient());
     });
 
     it('should return valid structure for all alliances', async () => {
@@ -27,7 +24,7 @@ describe('AlliancesApi', () => {
 
         fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
 
-        const result = await getBody(() => alliancesApi.getAllAlliances()) as Alliance[];
+        const result = await alliancesApi.getAllAlliances() as Alliance[];
 
         expect(Array.isArray(result)).toBe(true);
         result.forEach((alliance: Alliance) => {

package/tests/tdd/clones/postJumpCloneActivation.test.ts

@@ -0,0 +1,70 @@
+import { PostJumpCloneActivationApi } from '../../../src/api/clones/postJumpCloneActivation';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+let postJumpCloneActivationApi: PostJumpCloneActivationApi;
+
+beforeAll(() => {
+    postJumpCloneActivationApi = new PostJumpCloneActivationApi(getClient());
+});
+
+describe('PostJumpCloneActivationApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should call activateJumpClone and return success response', async () => {
+        const characterId = 90000001;
+        const jumpCloneId = 12345;
+        const mockResponse = { success: true };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => postJumpCloneActivationApi.activateJumpClone(characterId, jumpCloneId));
+
+        expect(result).toEqual(mockResponse);
+        expect(result).toHaveProperty('success', true);
+    });
+
+    it('should handle different character and clone IDs correctly', async () => {
+        const characterId = 90000002;
+        const jumpCloneId = 67890;
+        const mockResponse = { success: true };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => postJumpCloneActivationApi.activateJumpClone(characterId, jumpCloneId));
+
+        expect(result).toEqual(mockResponse);
+        expect(result).toHaveProperty('success', true);
+    });
+
+    it('should handle API errors gracefully', async () => {
+        const characterId = 90000001;
+        const jumpCloneId = 12345;
+        
+        fetchMock.mockRejectOnce(new Error('Jump clone not found'));
+
+        await expect(getBody(() => postJumpCloneActivationApi.activateJumpClone(characterId, jumpCloneId))).rejects.toThrow();
+    });
+
+    it('should send POST request to correct endpoint', async () => {
+        const characterId = 90000001;
+        const jumpCloneId = 12345;
+        const mockResponse = { success: true };
+        
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+        
+        await getBody(() => postJumpCloneActivationApi.activateJumpClone(characterId, jumpCloneId));
+        
+        // Verify the request was made to the correct endpoint
+        expect(fetchMock).toHaveBeenCalledWith(
+            expect.stringContaining(`characters/${characterId}/clones`),
+            expect.objectContaining({
+                method: 'POST'
+            })
+        );
+    });
+});