@lgriffin/esi.ts 1.0.0 → 2.0.0

package/tests/tdd/core/ETagIntegration.test.ts

@@ -0,0 +1,208 @@
+import { EsiClient } from '../../../src/EsiClient';
+import { initializeETagCache, getETagCache, resetETagCache } from '../../../src/core/ApiRequestHandler';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+describe('ETag Integration Tests', () => {
+    let client: EsiClient;
+
+    beforeEach(() => {
+        fetchMock.resetMocks();
+        
+        // Reset the global cache to ensure clean state
+        resetETagCache();
+        
+        client = new EsiClient({
+            clientId: 'test-client',
+            baseUrl: 'https://esi.evetech.net',
+            enableETagCache: true,
+            etagCacheConfig: {
+                maxEntries: 100,
+                defaultTtl: 5000,
+                cleanupInterval: 1000
+            }
+        });
+    });
+
+    afterEach(() => {
+        client.shutdown();
+    });
+
+    describe('ETag Caching Flow', () => {
+        it('should cache response with ETag on first request', async () => {
+            const mockData = [{ alliance_id: 1, name: 'Test Alliance' }];
+            const etag = '"abc123def456"';
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockData), {
+                headers: {
+                    'ETag': etag,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            const result = await client.alliance.getAlliances();
+
+            expect(result).toEqual(mockData);
+            
+            const cache = getETagCache();
+            expect(cache).toBeDefined();
+            
+            const cacheStats = client.getCacheStats();
+            expect(cacheStats.totalEntries).toBe(1);
+        });
+
+        it('should return cached data on 304 Not Modified', async () => {
+            const mockData = [{ alliance_id: 1, name: 'Test Alliance' }];
+            const etag = '"abc123def456"';
+
+            // First request - populate cache
+            fetchMock.mockResponseOnce(JSON.stringify(mockData), {
+                headers: {
+                    'ETag': etag,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            await client.alliance.getAlliances();
+
+            // Second request - should return 304
+            fetchMock.mockResponseOnce('', {
+                status: 304,
+                headers: {
+                    'ETag': etag
+                }
+            });
+
+            const cachedResult = await client.alliance.getAlliances();
+
+            expect(cachedResult).toEqual(mockData);
+            expect(fetchMock).toHaveBeenCalledTimes(2);
+            
+            // Verify If-None-Match header was sent
+            const lastCall = fetchMock.mock.calls[1];
+            const requestHeaders = lastCall[1]?.headers as Record<string, string>;
+            expect(requestHeaders['If-None-Match']).toBe(etag);
+        });
+
+        it('should update cache when ETag changes', async () => {
+            const oldData = [{ alliance_id: 1, name: 'Old Alliance' }];
+            const newData = [{ alliance_id: 1, name: 'Updated Alliance' }];
+            const oldETag = '"old123"';
+            const newETag = '"new456"';
+
+            // First request
+            fetchMock.mockResponseOnce(JSON.stringify(oldData), {
+                headers: {
+                    'ETag': oldETag,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            const firstResult = await client.alliance.getAlliances();
+            expect(firstResult).toEqual(oldData);
+
+            // Second request with new ETag
+            fetchMock.mockResponseOnce(JSON.stringify(newData), {
+                headers: {
+                    'ETag': newETag,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            const secondResult = await client.alliance.getAlliances();
+            expect(secondResult).toEqual(newData);
+
+            const cache = getETagCache();
+            const url = 'https://esi.evetech.net/alliances';
+            expect(cache?.getETag(url)).toBe(newETag);
+        });
+    });
+
+    describe('Cache Management', () => {
+        it('should provide cache statistics', async () => {
+            const mockData = [{ alliance_id: 1, name: 'Test Alliance' }];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockData), {
+                headers: { 'ETag': '"test123"' }
+            });
+
+            await client.alliance.getAlliances();
+
+            const stats = client.getCacheStats();
+            expect(stats).toBeDefined();
+            expect(stats.totalEntries).toBe(1);
+            expect(stats.maxEntries).toBe(100);
+        });
+
+        it('should clear cache', async () => {
+            const mockData = [{ alliance_id: 1, name: 'Test Alliance' }];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockData), {
+                headers: { 'ETag': '"test123"' }
+            });
+
+            await client.alliance.getAlliances();
+
+            expect(client.getCacheStats().totalEntries).toBe(1);
+
+            client.clearCache();
+
+            expect(client.getCacheStats().totalEntries).toBe(0);
+        });
+
+        it('should update cache configuration', () => {
+            const initialStats = client.getCacheStats();
+            expect(initialStats.maxEntries).toBe(100);
+
+            client.updateCacheConfig({ maxEntries: 200 });
+
+            const updatedStats = client.getCacheStats();
+            expect(updatedStats.maxEntries).toBe(200);
+        });
+    });
+
+    describe('ETag Disabled', () => {
+        it('should work without ETag cache when disabled', async () => {
+            const clientWithoutETag = new EsiClient({
+                enableETagCache: false
+            });
+
+            const mockData = [{ alliance_id: 1, name: 'Test Alliance' }];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockData), {
+                headers: { 'ETag': '"test123"' }
+            });
+
+            const result = await clientWithoutETag.alliance.getAlliances();
+
+            expect(result).toEqual(mockData);
+            expect(clientWithoutETag.getCacheStats()).toBeNull();
+
+            clientWithoutETag.shutdown();
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should handle requests when cache returns null', async () => {
+            const mockData = [{ alliance_id: 1, name: 'Test Alliance' }];
+
+            // Mock 304 response but no cached data (edge case)
+            fetchMock.mockResponseOnce('', {
+                status: 304
+            });
+
+            // Should handle gracefully and not crash
+            const result = await client.alliance.getAlliances();
+            
+            // Should return error object for 304 with no cache
+            expect(result).toEqual({ error: 'not modified' });
+        });
+
+        it('should handle network errors gracefully', async () => {
+            fetchMock.mockRejectOnce(new Error('Network error'));
+
+            await expect(client.alliance.getAlliances()).rejects.toThrow('Network error');
+        });
+    });
+});

package/tests/tdd/corporations/CorporationsClient.test.ts

@@ -1,22 +1,25 @@
 import { CorporationsClient } from '../../../src/clients/CorporationsClient';
 import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
 import { getConfig } from '../../../src/config/configManager';
+import { getBody } from '../../../src/core/util/testHelpers';
 import fetchMock from 'jest-fetch-mock';
 
 fetchMock.enableMocks();
 
-const config = getConfig();
-const client = new ApiClientBuilder()
-    .setClientId(config.projectName)
-    .setLink(config.link)
-    .setAccessToken(config.authToken || undefined)
-    .build();
-
-const corporationsClient = new CorporationsClient(client);
-
 describe('CorporationsClient', () => {
+    let corporationsClient: CorporationsClient;
+
     beforeEach(() => {
         fetchMock.resetMocks();
+        
+        const config = getConfig();
+        const client = new ApiClientBuilder()
+            .setClientId(config.projectName)
+            .setLink(config.link)
+            .setAccessToken(config.authToken || undefined)
+            .build();
+
+        corporationsClient = new CorporationsClient(client);
     });
 
     it('should return valid structure for getCorporationInfo', async () => {
@@ -227,4 +230,172 @@ describe('CorporationsClient', () => {
         expect(result).toHaveProperty('px256x256');
         expect(typeof result.px256x256).toBe('string');
     });
+
+    // Adding tests for key missing methods
+    it('should return valid structure for getCorporationMembers', async () => {
+        const mockResponse = [
+            {
+                character_id: 123456789,
+                name: 'John Doe',
+                title: 'CEO'
+            },
+            {
+                character_id: 987654321,
+                name: 'Jane Smith',
+                title: 'Director'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationsClient.getCorporationMembers(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((member: { character_id: number; name: string; title: string }) => {
+            expect(member).toHaveProperty('character_id');
+            expect(typeof member.character_id).toBe('number');
+            expect(member).toHaveProperty('name');
+            expect(typeof member.name).toBe('string');
+            expect(member).toHaveProperty('title');
+            expect(typeof member.title).toBe('string');
+        });
+    });
+
+    it('should return valid structure for getCorporationMemberLimit', async () => {
+        const mockResponse = 50;
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationsClient.getCorporationMemberLimit(123456789));
+
+        expect(typeof result).toBe('number');
+        expect(result).toBe(50);
+    });
+
+    it('should return valid structure for getCorporationRoles', async () => {
+        const mockResponse = [
+            {
+                character_id: 123456789,
+                roles: ['Director', 'Personnel_Manager'],
+                grantable_roles: ['Accountant'],
+                roles_at_hq: ['Director'],
+                grantable_roles_at_hq: [],
+                roles_at_base: [],
+                grantable_roles_at_base: [],
+                roles_at_other: [],
+                grantable_roles_at_other: []
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationsClient.getCorporationRoles(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((roleData: any) => {
+            expect(roleData).toHaveProperty('character_id');
+            expect(typeof roleData.character_id).toBe('number');
+            expect(roleData).toHaveProperty('roles');
+            expect(Array.isArray(roleData.roles)).toBe(true);
+            expect(roleData).toHaveProperty('grantable_roles');
+            expect(Array.isArray(roleData.grantable_roles)).toBe(true);
+        });
+    });
+
+    it('should return valid structure for getCorporationStandings', async () => {
+        const mockResponse = [
+            {
+                from_id: 123456,
+                from_type: 'agent',
+                standing: 5.0
+            },
+            {
+                from_id: 789012,
+                from_type: 'faction',
+                standing: -2.5
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationsClient.getCorporationStandings(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((standing: any) => {
+            expect(standing).toHaveProperty('from_id');
+            expect(typeof standing.from_id).toBe('number');
+            expect(standing).toHaveProperty('from_type');
+            expect(typeof standing.from_type).toBe('string');
+            expect(standing).toHaveProperty('standing');
+            expect(typeof standing.standing).toBe('number');
+        });
+    });
+
+    it('should return valid structure for getCorporationTitles', async () => {
+        const mockResponse = [
+            {
+                title_id: 1,
+                name: 'CEO',
+                roles: ['Director', 'Personnel_Manager'],
+                grantable_roles: ['Accountant'],
+                roles_at_hq: ['Director'],
+                grantable_roles_at_hq: [],
+                roles_at_base: [],
+                grantable_roles_at_base: [],
+                roles_at_other: [],
+                grantable_roles_at_other: []
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationsClient.getCorporationTitles(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((title: any) => {
+            expect(title).toHaveProperty('title_id');
+            expect(typeof title.title_id).toBe('number');
+            expect(title).toHaveProperty('name');
+            expect(typeof title.name).toBe('string');
+            expect(title).toHaveProperty('roles');
+            expect(Array.isArray(title.roles)).toBe(true);
+        });
+    });
+
+    it('should return valid structure for getNpcCorporations', async () => {
+        const mockResponse = [1000001, 1000002, 1000003, 1000004];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationsClient.getNpcCorporations());
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((corpId: number) => {
+            expect(typeof corpId).toBe('number');
+            expect(corpId).toBeGreaterThan(0);
+        });
+    });
+
+    it('should return valid structure for getCorporationProjects', async () => {
+        const mockResponse = [
+            {
+                project_id: 1,
+                name: 'Research Project Alpha',
+                description: 'Advanced research project',
+                status: 'active'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationsClient.getCorporationProjects(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((project: any) => {
+            expect(project).toHaveProperty('project_id');
+            expect(typeof project.project_id).toBe('number');
+            expect(project).toHaveProperty('name');
+            expect(typeof project.name).toBe('string');
+        });
+    });
 });

package/tests/tdd/corporations/getCorporationProjects.test.ts

@@ -0,0 +1,62 @@
+import { GetCorporationProjectsApi } from '../../../src/api/corporations/getCorporationProjects';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+let getCorporationProjectsApi: GetCorporationProjectsApi;
+
+beforeAll(() => {
+    getCorporationProjectsApi = new GetCorporationProjectsApi(getClient());
+});
+
+describe('GetCorporationProjectsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should call getCorporationProjects and return corporation projects', async () => {
+        const corporationId = 98000001;
+        const mockProjects = [
+            {
+                project_id: 1,
+                name: 'Test Project',
+                description: 'A test project',
+                status: 'active'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockProjects));
+
+        const result = await getBody(() => getCorporationProjectsApi.getCorporationProjects(corporationId));
+
+        expect(result).toEqual(mockProjects);
+        expect(Array.isArray(result)).toBe(true);
+        if (result.length > 0) {
+            expect(result[0]).toHaveProperty('project_id');
+            expect(result[0]).toHaveProperty('name');
+            expect(result[0]).toHaveProperty('status');
+        }
+    });
+
+    it('should handle different corporation IDs correctly', async () => {
+        const corporationId = 98000002;
+        const mockProjects: any[] = [];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockProjects));
+
+        const result = await getBody(() => getCorporationProjectsApi.getCorporationProjects(corporationId));
+
+        expect(result).toEqual(mockProjects);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toHaveLength(0);
+    });
+
+    it('should handle API errors gracefully', async () => {
+        const corporationId = 98000001;
+        
+        fetchMock.mockRejectOnce(new Error('Corporation not found'));
+
+        await expect(getBody(() => getCorporationProjectsApi.getCorporationProjects(corporationId))).rejects.toThrow();
+    });
+});

package/tests/tdd/incursions/getIncursions.test.ts

@@ -1,31 +1,17 @@
+import { IncursionsClient } from '../../../src/clients/IncursionsClient';
 import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
-import { IncursionsApi } from '../../../src/api/incursions/getIncursions';
 import { getConfig } from '../../../src/config/configManager';
+import { getBody } from '../../../src/core/util/testHelpers';
 import fetchMock from 'jest-fetch-mock';
 
 fetchMock.enableMocks();
 
-describe('IncursionsApi', () => {
+describe('IncursionsClient', () => {
+    let incursionsClient: IncursionsClient;
+
     beforeEach(() => {
         fetchMock.resetMocks();
-    });
-
-    it('should fetch incursions correctly', async () => {
-        const mockResponse = [
-            {
-                constellation_id: 20000169,
-                faction_id: 500019,
-                has_boss: true,
-                infested_solar_systems: [30001161, 30001162],
-                influence: 0.9,
-                staging_solar_system_id: 30001161,
-                state: 'mobilizing',
-                type: 'Incursion'
-            }
-        ];
-
-        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
-
+        
         const config = getConfig();
         const client = new ApiClientBuilder()
             .setClientId(config.projectName)
@@ -33,9 +19,148 @@ describe('IncursionsApi', () => {
             .setAccessToken(config.authToken || undefined)
             .build();
 
-        const incursionsApi = new IncursionsApi(client);
+        incursionsClient = new IncursionsClient(client);
+    });
+
+    describe('getIncursions', () => {
+        it('should return valid incursion data structure', async () => {
+            const mockResponse = [
+                {
+                    constellation_id: 20000169,
+                    faction_id: 500019,
+                    has_boss: true,
+                    infested_solar_systems: [30001161, 30001162],
+                    influence: 0.9,
+                    staging_solar_system_id: 30001161,
+                    state: 'mobilizing',
+                    type: 'Incursion'
+                },
+                {
+                    constellation_id: 20000170,
+                    faction_id: 500019,
+                    has_boss: false,
+                    infested_solar_systems: [30001163, 30001164, 30001165],
+                    influence: 0.7,
+                    staging_solar_system_id: 30001163,
+                    state: 'established',
+                    type: 'Incursion'
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => incursionsClient.getIncursions());
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(2);
+
+            // Validate first incursion structure
+            const firstIncursion = result[0];
+            expect(firstIncursion).toHaveProperty('constellation_id');
+            expect(typeof firstIncursion.constellation_id).toBe('number');
+            expect(firstIncursion.constellation_id).toBe(20000169);
+
+            expect(firstIncursion).toHaveProperty('faction_id');
+            expect(typeof firstIncursion.faction_id).toBe('number');
+            expect(firstIncursion.faction_id).toBe(500019);
+
+            expect(firstIncursion).toHaveProperty('has_boss');
+            expect(typeof firstIncursion.has_boss).toBe('boolean');
+            expect(firstIncursion.has_boss).toBe(true);
+
+            expect(firstIncursion).toHaveProperty('infested_solar_systems');
+            expect(Array.isArray(firstIncursion.infested_solar_systems)).toBe(true);
+            expect(firstIncursion.infested_solar_systems).toEqual([30001161, 30001162]);
+
+            expect(firstIncursion).toHaveProperty('influence');
+            expect(typeof firstIncursion.influence).toBe('number');
+            expect(firstIncursion.influence).toBe(0.9);
+
+            expect(firstIncursion).toHaveProperty('staging_solar_system_id');
+            expect(typeof firstIncursion.staging_solar_system_id).toBe('number');
+            expect(firstIncursion.staging_solar_system_id).toBe(30001161);
+
+            expect(firstIncursion).toHaveProperty('state');
+            expect(typeof firstIncursion.state).toBe('string');
+            expect(firstIncursion.state).toBe('mobilizing');
+
+            expect(firstIncursion).toHaveProperty('type');
+            expect(typeof firstIncursion.type).toBe('string');
+            expect(firstIncursion.type).toBe('Incursion');
+
+            // Validate all incursions have required properties
+            result.forEach((incursion: any) => {
+                expect(incursion).toHaveProperty('constellation_id');
+                expect(incursion).toHaveProperty('faction_id');
+                expect(incursion).toHaveProperty('has_boss');
+                expect(incursion).toHaveProperty('infested_solar_systems');
+                expect(incursion).toHaveProperty('influence');
+                expect(incursion).toHaveProperty('staging_solar_system_id');
+                expect(incursion).toHaveProperty('state');
+                expect(incursion).toHaveProperty('type');
+
+                // Type validations
+                expect(typeof incursion.constellation_id).toBe('number');
+                expect(typeof incursion.faction_id).toBe('number');
+                expect(typeof incursion.has_boss).toBe('boolean');
+                expect(Array.isArray(incursion.infested_solar_systems)).toBe(true);
+                expect(typeof incursion.influence).toBe('number');
+                expect(typeof incursion.staging_solar_system_id).toBe('number');
+                expect(typeof incursion.state).toBe('string');
+                expect(typeof incursion.type).toBe('string');
+
+                // Value validations
+                expect(incursion.constellation_id).toBeGreaterThan(0);
+                expect(incursion.faction_id).toBeGreaterThan(0);
+                expect(incursion.influence).toBeGreaterThanOrEqual(0);
+                expect(incursion.influence).toBeLessThanOrEqual(1);
+                expect(incursion.staging_solar_system_id).toBeGreaterThan(0);
+                expect(incursion.infested_solar_systems.length).toBeGreaterThan(0);
+                expect(['mobilizing', 'established', 'withdrawing'].includes(incursion.state)).toBe(true);
+                expect(incursion.type).toBe('Incursion');
+            });
+        });
+
+        it('should handle empty incursion list', async () => {
+            const mockResponse: any[] = [];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => incursionsClient.getIncursions());
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(0);
+        });
+
+        it('should handle single incursion response', async () => {
+            const mockResponse = [
+                {
+                    constellation_id: 20000169,
+                    faction_id: 500019,
+                    has_boss: false,
+                    infested_solar_systems: [30001161],
+                    influence: 0.5,
+                    staging_solar_system_id: 30001161,
+                    state: 'established',
+                    type: 'Incursion'
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => incursionsClient.getIncursions());
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(1);
+            expect(result[0].constellation_id).toBe(20000169);
+        });
+
+        it('should handle API errors gracefully', async () => {
+            fetchMock.mockResponseOnce('Server Error', { status: 500 });
 
-        const result = await getBody(() => incursionsApi.getIncursions());
-        expect(result).toEqual(mockResponse);
+            const result = await getBody(() => incursionsClient.getIncursions());
+            expect(result).toHaveProperty('error');
+            expect(result.error).toBe('internal server error');
+        });
     });
 });