@lgriffin/esi.ts 1.0.0 → 2.0.0

package/tests/tdd/contacts/ContactsClient.test.ts

@@ -1,66 +1,289 @@
 import { ContactsClient } from '../../../src/clients/ContactsClient';
 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 contactsClient = new ContactsClient(client);
-
 describe('ContactsClient', () => {
+    let contactsClient: ContactsClient;
+
     beforeEach(() => {
         fetchMock.resetMocks();
+        
+        const config = getConfig();
+        const client = new ApiClientBuilder()
+            .setClientId(config.projectName)
+            .setLink(config.link)
+            .setAccessToken(config.authToken || undefined)
+            .build();
+
+        contactsClient = new ContactsClient(client);
     });
 
-    it('should return valid structure for getAllianceContacts', async () => {
-        const mockResponse = [
-            {
-                contact_id: 123,
-                contact_type: 'character',
-                standing: 10,
-                label_ids: [1, 2]
-            }
-        ];
-
-        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
-
-        const result = await getBody(() => contactsClient.getAllianceContacts(123456));
-
-        expect(Array.isArray(result)).toBe(true);
-        (result as any[]).forEach(contact => {
-            expect(contact).toHaveProperty('contact_id');
-            expect(contact).toHaveProperty('contact_type');
-            expect(contact).toHaveProperty('standing');
-            expect(contact).toHaveProperty('label_ids');
+    describe('Alliance Contacts', () => {
+        it('should return valid structure for getAllianceContacts', async () => {
+            const mockResponse = [
+                {
+                    contact_id: 123,
+                    contact_type: 'character',
+                    standing: 10,
+                    label_ids: [1, 2]
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => contactsClient.getAllianceContacts(123456));
+
+            expect(Array.isArray(result)).toBe(true);
+            (result as any[]).forEach(contact => {
+                expect(contact).toHaveProperty('contact_id');
+                expect(contact).toHaveProperty('contact_type');
+                expect(contact).toHaveProperty('standing');
+                expect(contact).toHaveProperty('label_ids');
+            });
+        });
+
+        it('should return valid structure for getAllianceContactLabels', async () => {
+            const mockResponse = [
+                {
+                    label_id: 1,
+                    name: 'VIPs'
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => contactsClient.getAllianceContactLabels(123456));
+
+            expect(Array.isArray(result)).toBe(true);
+            (result as any[]).forEach(label => {
+                expect(label).toHaveProperty('label_id');
+                expect(label).toHaveProperty('name');
+            });
+        });
+    });
+
+    describe('Character Contacts', () => {
+        it('should return valid structure for getCharacterContacts', async () => {
+            const mockResponse = [
+                {
+                    contact_id: 123456789,
+                    contact_type: 'character',
+                    standing: 5.0,
+                    label_ids: [1],
+                    is_watched: false,
+                    is_blocked: false
+                },
+                {
+                    contact_id: 987654321,
+                    contact_type: 'corporation',
+                    standing: -10.0,
+                    label_ids: [2, 3],
+                    is_watched: true,
+                    is_blocked: true
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => contactsClient.getCharacterContacts(123456));
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(2);
+
+            expect(result[0].contact_id).toBe(123456789);
+            expect(result[0].contact_type).toBe('character');
+            expect(result[0].standing).toBe(5.0);
+            expect(result[0].label_ids).toEqual([1]);
+            expect(result[0].is_watched).toBe(false);
+            expect(result[0].is_blocked).toBe(false);
+
+            expect(result[1].contact_id).toBe(987654321);
+            expect(result[1].contact_type).toBe('corporation');
+            expect(result[1].standing).toBe(-10.0);
+            expect(result[1].label_ids).toEqual([2, 3]);
+            expect(result[1].is_watched).toBe(true);
+            expect(result[1].is_blocked).toBe(true);
+        });
+
+        it('should return valid structure for getCharacterContactLabels', async () => {
+            const mockResponse = [
+                {
+                    label_id: 1,
+                    name: 'Friends'
+                },
+                {
+                    label_id: 2,
+                    name: 'Enemies'
+                },
+                {
+                    label_id: 3,
+                    name: 'Neutrals'
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => contactsClient.getCharacterContactLabels(123456));
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(3);
+
+            result.forEach((label: any) => {
+                expect(label).toHaveProperty('label_id');
+                expect(label).toHaveProperty('name');
+                expect(typeof label.label_id).toBe('number');
+                expect(typeof label.name).toBe('string');
+            });
+        });
+
+        it('should handle postCharacterContacts (add contacts)', async () => {
+            const mockResponse = [123456789, 987654321]; // Contact IDs that were added
+            const contactsToAdd = [
+                {
+                    contact_id: 123456789,
+                    contact_type: 'character',
+                    standing: 5.0,
+                    label_ids: [1]
+                },
+                {
+                    contact_id: 987654321,
+                    contact_type: 'corporation',
+                    standing: -5.0,
+                    label_ids: [2]
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => contactsClient.postCharacterContacts(123456, contactsToAdd));
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toEqual([123456789, 987654321]);
+        });
+
+        it('should handle putCharacterContacts (edit contacts)', async () => {
+            const mockResponse = {}; // PUT typically returns empty response on success
+            const contactsToUpdate = [
+                {
+                    contact_id: 123456789,
+                    standing: 10.0,
+                    label_ids: [1, 2]
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => contactsClient.putCharacterContacts(123456, contactsToUpdate));
+
+            expect(result).toEqual({});
+        });
+
+        it('should handle deleteCharacterContacts', async () => {
+            const mockResponse = {}; // DELETE typically returns empty response on success
+            const contactIdsToDelete = [123456789, 987654321];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => contactsClient.deleteCharacterContacts(123456, contactIdsToDelete));
+
+            expect(result).toEqual({});
         });
     });
 
-    it('should return valid structure for getAllianceContactLabels', async () => {
-        const mockResponse = [
-            {
-                label_id: 1,
-                name: 'VIPs'
-            }
-        ];
+    describe('Corporation Contacts', () => {
+        it('should return valid structure for getCorporationContacts', async () => {
+            const mockResponse = [
+                {
+                    contact_id: 123456789,
+                    contact_type: 'alliance',
+                    standing: 10.0,
+                    label_ids: [1],
+                    is_watched: false
+                },
+                {
+                    contact_id: 987654321,
+                    contact_type: 'corporation',
+                    standing: 0.0,
+                    label_ids: [],
+                    is_watched: true
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
 
-        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+            const result = await getBody(() => contactsClient.getCorporationContacts(123456789));
 
-        const result = await getBody(() => contactsClient.getAllianceContactLabels(123456));
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(2);
 
-        expect(Array.isArray(result)).toBe(true);
-        (result as any[]).forEach(label => {
-            expect(label).toHaveProperty('label_id');
-            expect(label).toHaveProperty('name');
+            result.forEach((contact: any) => {
+                expect(contact).toHaveProperty('contact_id');
+                expect(contact).toHaveProperty('contact_type');
+                expect(contact).toHaveProperty('standing');
+                expect(contact).toHaveProperty('label_ids');
+                expect(contact).toHaveProperty('is_watched');
+                expect(typeof contact.contact_id).toBe('number');
+                expect(typeof contact.standing).toBe('number');
+                expect(Array.isArray(contact.label_ids)).toBe(true);
+                expect(typeof contact.is_watched).toBe('boolean');
+            });
+        });
+
+        it('should return valid structure for getCorporationContactLabels', async () => {
+            const mockResponse = [
+                {
+                    label_id: 1,
+                    name: 'Corporate Allies'
+                },
+                {
+                    label_id: 2,
+                    name: 'Trade Partners'
+                }
+            ];
+
+            fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+            const result = await getBody(() => contactsClient.getCorporationContactLabels(123456789));
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(2);
+
+            result.forEach((label: any) => {
+                expect(label).toHaveProperty('label_id');
+                expect(label).toHaveProperty('name');
+                expect(typeof label.label_id).toBe('number');
+                expect(typeof label.name).toBe('string');
+            });
         });
     });
 
-    // Add other tests for the remaining APIs following the same pattern
+    describe('Error Handling', () => {
+        it('should handle authentication errors', async () => {
+            fetchMock.mockResponseOnce('Unauthorized', { status: 401 });
+
+            const result = await getBody(() => contactsClient.getCharacterContacts(123456));
+            expect(result).toHaveProperty('error');
+            expect(result.error).toBe('unauthorized');
+        });
+
+        it('should handle forbidden access errors', async () => {
+            fetchMock.mockResponseOnce('Forbidden', { status: 403 });
+
+            const result = await getBody(() => contactsClient.getCorporationContacts(123456789));
+            expect(result).toHaveProperty('error');
+            expect(result.error).toBe('forbidden');
+        });
+
+        it('should handle not found errors', async () => {
+            fetchMock.mockResponseOnce('Not Found', { status: 404 });
+
+            const result = await getBody(() => contactsClient.getAllianceContacts(999999999));
+            expect(result).toHaveProperty('error');
+            expect(result.error).toBe('resource not found');
+        });
+    });
 });

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

@@ -0,0 +1,173 @@
+import { ETagCacheManager, CacheEntry } from '../../../src/core/cache/ETagCacheManager';
+
+describe('ETagCacheManager', () => {
+    let cacheManager: ETagCacheManager;
+
+    beforeEach(() => {
+        cacheManager = new ETagCacheManager({
+            maxEntries: 5,
+            defaultTtl: 1000, // 1 second for testing
+            cleanupInterval: 500, // 0.5 seconds
+            persistToStorage: false
+        });
+    });
+
+    afterEach(() => {
+        cacheManager.shutdown();
+    });
+
+    describe('Basic Cache Operations', () => {
+        it('should set and get cache entries', () => {
+            const url = 'https://esi.evetech.net/latest/alliances/';
+            const etag = '"abc123"';
+            const data = [{ alliance_id: 1, name: 'Test Alliance' }];
+            const headers = { 'content-type': 'application/json' };
+
+            cacheManager.set(url, etag, data, headers);
+            const entry = cacheManager.get(url);
+
+            expect(entry).toBeDefined();
+            expect(entry?.etag).toBe(etag);
+            expect(entry?.data).toEqual(data);
+            expect(entry?.headers).toEqual(headers);
+        });
+
+        it('should return null for non-existent entries', () => {
+            const entry = cacheManager.get('https://non-existent.url');
+            expect(entry).toBeNull();
+        });
+
+        it('should check if entries exist', () => {
+            const url = 'https://esi.evetech.net/latest/alliances/';
+            expect(cacheManager.has(url)).toBe(false);
+
+            cacheManager.set(url, '"etag"', [], {});
+            expect(cacheManager.has(url)).toBe(true);
+        });
+
+        it('should get ETag for URL', () => {
+            const url = 'https://esi.evetech.net/latest/alliances/';
+            const etag = '"abc123"';
+
+            expect(cacheManager.getETag(url)).toBeNull();
+
+            cacheManager.set(url, etag, [], {});
+            expect(cacheManager.getETag(url)).toBe(etag);
+        });
+
+        it('should delete specific entries', () => {
+            const url = 'https://esi.evetech.net/latest/alliances/';
+            cacheManager.set(url, '"etag"', [], {});
+
+            expect(cacheManager.has(url)).toBe(true);
+            expect(cacheManager.delete(url)).toBe(true);
+            expect(cacheManager.has(url)).toBe(false);
+            expect(cacheManager.delete(url)).toBe(false); // Already deleted
+        });
+
+        it('should clear all entries', () => {
+            cacheManager.set('url1', '"etag1"', [], {});
+            cacheManager.set('url2', '"etag2"', [], {});
+
+            expect(cacheManager.getStats().totalEntries).toBe(2);
+            cacheManager.clear();
+            expect(cacheManager.getStats().totalEntries).toBe(0);
+        });
+    });
+
+    describe('TTL and Expiration', () => {
+        it('should expire entries after TTL', async () => {
+            const url = 'https://esi.evetech.net/latest/alliances/';
+            cacheManager.set(url, '"etag"', [], {}, 100); // 100ms TTL
+
+            expect(cacheManager.has(url)).toBe(true);
+
+            // Wait for expiration
+            await new Promise(resolve => setTimeout(resolve, 150));
+
+            expect(cacheManager.has(url)).toBe(false);
+            expect(cacheManager.get(url)).toBeNull();
+        });
+
+        it('should use default TTL when not specified', async () => {
+            const url = 'https://esi.evetech.net/latest/alliances/';
+            cacheManager.set(url, '"etag"', [], {}); // Use default TTL (1000ms)
+
+            expect(cacheManager.has(url)).toBe(true);
+
+            // Should still be valid after 500ms
+            await new Promise(resolve => setTimeout(resolve, 500));
+            expect(cacheManager.has(url)).toBe(true);
+
+            // Should expire after 1100ms
+            await new Promise(resolve => setTimeout(resolve, 600));
+            expect(cacheManager.has(url)).toBe(false);
+        });
+    });
+
+    describe('Cache Size Management', () => {
+        it('should evict oldest entries when max size reached', () => {
+            // Fill cache to max capacity
+            for (let i = 0; i < 5; i++) {
+                cacheManager.set(`url${i}`, `"etag${i}"`, [], {});
+            }
+
+            expect(cacheManager.getStats().totalEntries).toBe(5);
+
+            // Add one more - should evict oldest
+            cacheManager.set('url5', '"etag5"', [], {});
+
+            expect(cacheManager.getStats().totalEntries).toBe(5);
+            expect(cacheManager.has('url0')).toBe(false); // Oldest should be evicted
+            expect(cacheManager.has('url5')).toBe(true); // Newest should be present
+        });
+    });
+
+    describe('Cleanup Operations', () => {
+        it('should manually cleanup expired entries', async () => {
+            // Add entries with short TTL
+            cacheManager.set('url1', '"etag1"', [], {}, 50);
+            cacheManager.set('url2', '"etag2"', [], {}, 50);
+            cacheManager.set('url3', '"etag3"', [], {}, 2000); // Long TTL
+
+            expect(cacheManager.getStats().totalEntries).toBe(3);
+
+            // Wait for some to expire
+            await new Promise(resolve => setTimeout(resolve, 100));
+
+            const cleanedCount = cacheManager.cleanup();
+            expect(cleanedCount).toBe(2); // Should clean up 2 expired entries
+            expect(cacheManager.getStats().totalEntries).toBe(1);
+            expect(cacheManager.has('url3')).toBe(true); // Long TTL entry should remain
+        });
+    });
+
+    describe('Cache Statistics', () => {
+        it('should provide accurate statistics', () => {
+            const stats = cacheManager.getStats();
+            expect(stats.totalEntries).toBe(0);
+            expect(stats.maxEntries).toBe(5);
+
+            cacheManager.set('url1', '"etag1"', [], {});
+            cacheManager.set('url2', '"etag2"', [], {});
+
+            const newStats = cacheManager.getStats();
+            expect(newStats.totalEntries).toBe(2);
+            expect(newStats.oldestEntry).toBeDefined();
+            expect(newStats.newestEntry).toBeDefined();
+            expect(newStats.newestEntry).toBeGreaterThanOrEqual(newStats.oldestEntry!);
+        });
+    });
+
+    describe('Configuration Updates', () => {
+        it('should update configuration', () => {
+            const initialStats = cacheManager.getStats();
+            expect(initialStats.maxEntries).toBe(5);
+
+            cacheManager.updateConfig({ maxEntries: 10 });
+
+            const updatedStats = cacheManager.getStats();
+            expect(updatedStats.maxEntries).toBe(10);
+        });
+    });
+});