@lgriffin/esi.ts 1.0.0

package/tests/tdd/characters/CharacterBuilder.test.ts

@@ -0,0 +1,20 @@
+import { CharacterApiBuilder } from '../../../src/builders/CharacterApiBuilder';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+
+const config = getConfig();
+
+describe('CharacterApiBuilder', () => {
+    it('should build a CharacterClient instance', () => {
+        const client = new ApiClientBuilder()
+            .setClientId(config.projectName)
+            .setLink(config.link)
+            .setAccessToken(config.authToken || undefined)
+            .build();
+
+        const characterApiBuilder = new CharacterApiBuilder(client);
+        const characterClient = characterApiBuilder.build();
+
+        expect(characterClient).toBeDefined();
+    });
+});

package/tests/tdd/characters/CharacterClient.test.ts

@@ -0,0 +1,153 @@
+import { CharacterClient } from '../../../src/clients/CharacterClient';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 characterClient = new CharacterClient(client);
+
+describe('CharacterClient', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for getCharacterPublicInfo', async () => {
+        const mockResponse = {
+            character_id: 123,
+            name: 'Test Character',
+            corporation_id: 456,
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterClient.getCharacterPublicInfo(123456789));
+
+        expect(result).toHaveProperty('character_id');
+        expect(typeof result.character_id).toBe('number');
+        expect(result).toHaveProperty('name');
+        expect(typeof result.name).toBe('string');
+        expect(result).toHaveProperty('corporation_id');
+        expect(typeof result.corporation_id).toBe('number');
+    });
+
+    it('should return valid structure for getCharacterAgentsResearch', async () => {
+        const mockResponse = [
+            {
+                agent_id: 1,
+                points_per_day: 1.5,
+                remainder_points: 100.0,
+                skill_type_id: 123,
+                started_at: '2024-07-01T12:00:00Z',
+            },
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result: Array<{ agent_id: number; points_per_day: number; remainder_points: number; skill_type_id: number; started_at: string }> = await getBody(() => characterClient.getCharacterAgentsResearch(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((agent) => {
+            expect(agent).toHaveProperty('agent_id');
+            expect(typeof agent.agent_id).toBe('number');
+            expect(agent).toHaveProperty('points_per_day');
+            expect(typeof agent.points_per_day).toBe('number');
+            expect(agent).toHaveProperty('remainder_points');
+            expect(typeof agent.remainder_points).toBe('number');
+            expect(agent).toHaveProperty('skill_type_id');
+            expect(typeof agent.skill_type_id).toBe('number');
+            expect(agent).toHaveProperty('started_at');
+            expect(typeof agent.started_at).toBe('string');
+        });
+    });
+
+    it('should return valid structure for getCharacterBlueprints', async () => {
+        const mockResponse = [
+            {
+                item_id: 1,
+                type_id: 2,
+                location_id: 3,
+                location_flag: 'Hangar',
+                quantity: 1,
+                time_efficiency: 10,
+                material_efficiency: 10,
+                runs: 5,
+            },
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result: Array<{ item_id: number; type_id: number; location_id: number; location_flag: string; quantity: number; time_efficiency: number; material_efficiency: number; runs: number }> = await getBody(() => characterClient.getCharacterBlueprints(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((blueprint) => {
+            expect(blueprint).toHaveProperty('item_id');
+            expect(typeof blueprint.item_id).toBe('number');
+            expect(blueprint).toHaveProperty('type_id');
+            expect(typeof blueprint.type_id).toBe('number');
+            expect(blueprint).toHaveProperty('location_id');
+            expect(typeof blueprint.location_id).toBe('number');
+            expect(blueprint).toHaveProperty('location_flag');
+            expect(typeof blueprint.location_flag).toBe('string');
+            expect(blueprint).toHaveProperty('quantity');
+            expect(typeof blueprint.quantity).toBe('number');
+            expect(blueprint).toHaveProperty('time_efficiency');
+            expect(typeof blueprint.time_efficiency).toBe('number');
+            expect(blueprint).toHaveProperty('material_efficiency');
+            expect(typeof blueprint.material_efficiency).toBe('number');
+            expect(blueprint).toHaveProperty('runs');
+            expect(typeof blueprint.runs).toBe('number');
+        });
+    });
+
+    it('should return valid structure for getCharacterCorporationHistory', async () => {
+        const mockResponse = [
+            {
+                corporation_id: 123,
+                is_deleted: false,
+                record_id: 456,
+                start_date: '2024-07-01T12:00:00Z',
+            },
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result: Array<{ corporation_id: number; is_deleted: boolean; record_id: number; start_date: string }> = await  getBody(() => characterClient.getCharacterCorporationHistory(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((history) => {
+            expect(history).toHaveProperty('corporation_id');
+            expect(typeof history.corporation_id).toBe('number');
+            expect(history).toHaveProperty('is_deleted');
+            expect(typeof history.is_deleted).toBe('boolean');
+            expect(history).toHaveProperty('record_id');
+            expect(typeof history.record_id).toBe('number');
+            expect(history).toHaveProperty('start_date');
+            expect(typeof history.start_date).toBe('string');
+        });
+    });
+
+    it('should return valid structure for postCspaChargeCost', async () => {
+        const mockResponse = {
+            cost: 123456.78,
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const body = {
+            characters: [1234567890, 1234567891],
+        };
+
+        const result: { cost: number } = await getBody(() => characterClient.postCspaChargeCost(123456, body.characters));
+
+        expect(result).toHaveProperty('cost');
+        expect(typeof result.cost).toBe('number');
+    });
+});

package/tests/tdd/characters/getAgentsResearch.test.ts

@@ -0,0 +1,42 @@
+import { GetAgentsResearchApi } from '../../../src/api/characters/getAgentsResearch';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 agentsResearchApi = new GetAgentsResearchApi(client);
+
+describe('GetAgentsResearchApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for agents research', async () => {
+        const mockResponse = [
+            {
+                agent_id: 3009358,
+                skill_type_id: 11450,
+                research_start_date: '2024-01-01T00:00:00Z',
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => agentsResearchApi.getAgentsResearch(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((research: { agent_id: number, skill_type_id: number, researchh_start_date: Date}) => {
+            expect(research).toHaveProperty('agent_id');
+            expect(research).toHaveProperty('skill_type_id');
+            expect(research).toHaveProperty('research_start_date');
+        });
+    });
+});

package/tests/tdd/characters/getBlueprints.test.ts

@@ -0,0 +1,42 @@
+import { GetBlueprintsApi } from '../../../src/api/characters/getBlueprints';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 blueprintsApi = new GetBlueprintsApi(client);
+
+describe('GetBlueprintsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for blueprints', async () => {
+        const mockResponse = [
+            {
+                item_id: 123456,
+                type_id: 654321,
+                location_id: 123456,
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => blueprintsApi.getBlueprints(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((blueprint: {item_id: number, type_id: number, location_id: number}) => {
+            expect(blueprint).toHaveProperty('item_id');
+            expect(blueprint).toHaveProperty('type_id');
+            expect(blueprint).toHaveProperty('location_id');
+        });
+    });
+});

package/tests/tdd/characters/getCharacterPublicInfo.test.ts

@@ -0,0 +1,37 @@
+import { GetCharacterPublicInfoApi } from '../../../src/api/characters/getCharacterPublicInfo';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 characterPublicInfoApi = new GetCharacterPublicInfoApi(client);
+
+describe('GetCharacterPublicInfoApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for character public info', async () => {
+        const mockResponse = {
+            character_id: 123456,
+            name: 'Character Name',
+            corporation_id: 654321,
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterPublicInfoApi.getCharacterPublicInfo(123456));
+
+        expect(result).toHaveProperty('character_id');
+        expect(result).toHaveProperty('name');
+        expect(result).toHaveProperty('corporation_id');
+    });
+});

package/tests/tdd/characters/getCharacterRoles.test.ts

@@ -0,0 +1,34 @@
+import { GetCharacterRolesApi } from '../../../src/api/characters/getCharacterRoles';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 characterRolesApi = new GetCharacterRolesApi(client);
+
+describe('GetCharacterRolesApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for character roles', async () => {
+        const mockResponse = {
+            roles: ['role1', 'role2']
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterRolesApi.getCharacterRoles(123456));
+
+        expect(result).toHaveProperty('roles');
+        expect(Array.isArray(result.roles)).toBe(true);
+    });
+});

package/tests/tdd/characters/getCharacterStandings.test.ts

@@ -0,0 +1,45 @@
+import { GetCharacterStandingsApi } from '../../../src/api/characters/getCharacterStandings';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 characterStandingsApi = new GetCharacterStandingsApi(client);
+
+describe('GetCharacterStandingsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for character standings', async () => {
+        const mockResponse = {
+            standings: [
+                {
+                    from_id: 123,
+                    from_type: 'agent',
+                    standing: 5.0
+                }
+            ]
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterStandingsApi.getCharacterStandings(123456));
+
+        expect(result).toHaveProperty('standings');
+        expect(Array.isArray(result.standings)).toBe(true);
+        result.standings.forEach((standing: { from_id: number, from_type: string, standing: number }) => {
+            expect(standing).toHaveProperty('from_id');
+            expect(standing).toHaveProperty('from_type');
+            expect(standing).toHaveProperty('standing');
+        });
+    });
+});

package/tests/tdd/characters/getCharacterTitles.test.ts

@@ -0,0 +1,40 @@
+import { GetCharacterTitlesApi } from '../../../src/api/characters/getCharacterTitles'
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 characterTitlesApi = new GetCharacterTitlesApi(client);
+
+describe('GetCharacterTitlesApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for character titles', async () => {
+        const mockResponse = [
+            {
+                title_id: 1,
+                name: 'CEO'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterTitlesApi.getCharacterTitles(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((title: { title_id: number, name: string }) => {
+            expect(title).toHaveProperty('title_id');
+            expect(title).toHaveProperty('name');
+        });
+    });
+});

package/tests/tdd/characters/getContactNotifications.test.ts

@@ -0,0 +1,42 @@
+import { GetContactNotificationsApi } from '../../../src/api/characters/getContactNotifications';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 contactNotificationsApi = new GetContactNotificationsApi(client);
+
+describe('GetContactNotificationsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for contact notifications', async () => {
+        const mockResponse = [
+            {
+                notification_id: 1,
+                sender_character_id: 123456,
+                standing_level: 10.0
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => contactNotificationsApi.getContactNotifications(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((notification: {notification_id: number, sender_character_id: number, standing_level: number}) => {
+            expect(notification).toHaveProperty('notification_id');
+            expect(notification).toHaveProperty('sender_character_id');
+            expect(notification).toHaveProperty('standing_level');
+        });
+    });
+});

package/tests/tdd/characters/getCorporationHistory.test.ts

@@ -0,0 +1,42 @@
+import { GetCorporationHistoryApi } from '../../../src/api/characters/getCorporationHistory';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 corporationHistoryApi = new GetCorporationHistoryApi(client);
+
+describe('GetCorporationHistoryApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation history', async () => {
+        const mockResponse = [
+            {
+                corporation_id: 123456,
+                start_date: '2024-01-01T00:00:00Z',
+                record_id: 654321,
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationHistoryApi.getCorporationHistory(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((history: { corporation_id: number, start_date: Date, record_id: number}) => {
+            expect(history).toHaveProperty('corporation_id');
+            expect(history).toHaveProperty('start_date');
+            expect(history).toHaveProperty('record_id');
+        });
+    });
+});

package/tests/tdd/characters/getJumpFatigue.test.ts

@@ -0,0 +1,37 @@
+import { GetJumpFatigueApi } from '../../../src/api/characters/getJumpFatigue';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 jumpFatigueApi = new GetJumpFatigueApi(client);
+
+describe('GetJumpFatigueApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for jump fatigue', async () => {
+        const mockResponse = {
+            jump_fatigue_expire_date: '2024-01-01T00:00:00Z',
+            last_jump_date: '2024-01-01T00:00:00Z',
+            last_update_date: '2024-01-01T00:00:00Z'
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => jumpFatigueApi.getJumpFatigue(123456));
+
+        expect(result).toHaveProperty('jump_fatigue_expire_date');
+        expect(result).toHaveProperty('last_jump_date');
+        expect(result).toHaveProperty('last_update_date');
+    });
+});

package/tests/tdd/characters/getMedals.test.ts

@@ -0,0 +1,42 @@
+import { GetMedalsApi } from '../../../src/api/characters/getMedals';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 medalsApi = new GetMedalsApi(client);
+
+describe('GetMedalsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for medals', async () => {
+        const mockResponse = [
+            {
+                medal_id: 1,
+                reason: 'Bravery',
+                status: 'public'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => medalsApi.getMedals(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((medal: {medal_id: number, reason: String, status: String}) => {
+            expect(medal).toHaveProperty('medal_id');
+            expect(medal).toHaveProperty('reason');
+            expect(medal).toHaveProperty('status');
+        });
+    });
+});

package/tests/tdd/characters/getNotifications.test.ts

@@ -0,0 +1,42 @@
+import { GetNotificationsApi } from '../../../src/api/characters/getNotifications';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 notificationsApi = new GetNotificationsApi(client);
+
+describe('GetNotificationsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for notifications', async () => {
+        const mockResponse = [
+            {
+                notification_id: 1,
+                type: 'WarDeclared',
+                is_read: true
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => notificationsApi.getNotifications(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((notification: {notification_id: number, type: String, is_read: Boolean}) => {
+            expect(notification).toHaveProperty('notification_id');
+            expect(notification).toHaveProperty('type');
+            expect(notification).toHaveProperty('is_read');
+        });
+    });
+});

package/tests/tdd/characters/getPortrait.test.ts

@@ -0,0 +1,35 @@
+import { GetPortraitApi } from '../../../src/api/characters/getPortrait';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+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 portraitApi = new GetPortraitApi(client);
+
+describe('GetPortraitApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for portrait', async () => {
+        const mockResponse = {
+            px64x64: 'https://imageserver.eveonline.com/Character/123456_64.jpg',
+            px128x128: 'https://imageserver.eveonline.com/Character/123456_128.jpg'
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => portraitApi.getPortrait(123456));
+
+        expect(result).toHaveProperty('px64x64');
+        expect(result).toHaveProperty('px128x128');
+    });
+});