@lgriffin/esi.ts 1.0.0

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

@@ -0,0 +1,39 @@
+import { PostCspaChargeCostApi } from '../../../src/api/characters/postCSPAChargeCost';
+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 cspaChargeCostApi = new PostCspaChargeCostApi(client);
+
+describe('PostCspaChargeCostApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for CSPA charge cost', async () => {
+        const mockResponse = {
+            cost: 123456.78
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const body = {
+            characters: [1234567890, 1234567891]
+        };
+
+        // Explicitly defining the type inline
+        const result = await getBody(() => cspaChargeCostApi.calculateCspaChargeCost(123456, body)) as { cost: number };
+
+        expect(result).toHaveProperty('cost');
+        expect(typeof result.cost).toBe('number');
+    });
+});

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

@@ -0,0 +1,48 @@
+import { PostCharacterAffiliationApi } from '../../../src/api/characters/postCharacterAffiliations';
+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 characterAffiliationApi = new PostCharacterAffiliationApi(client);
+
+describe('PostCharacterAffiliationApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for character affiliation', async () => {
+        const mockResponse = [
+            {
+                character_id: 123456,
+                corporation_id: 654321,
+                alliance_id: 987654,
+                faction_id: 123123
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const body = {
+            characters: [1234567890, 1234567891]
+        };
+
+        const result = await getBody(() => characterAffiliationApi.postCharacterAffiliation(body));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((affiliation: { character_id: number, corporation_id: number, alliance_id: number, faction_id: number }) => {
+            expect(affiliation).toHaveProperty('character_id');
+            expect(affiliation).toHaveProperty('corporation_id');
+            expect(affiliation).toHaveProperty('alliance_id');
+            expect(affiliation).toHaveProperty('faction_id');
+        });
+    });
+});

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

@@ -0,0 +1,19 @@
+import { ClonesApiBuilder } from '../../../src/builders/ClonesApiBuilder';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+import { ClonesClient } from '../../../src/clients/ClonesClient';
+
+const config = getConfig();
+const client = new ApiClientBuilder()
+    .setClientId(config.projectName)
+    .setLink(config.link)
+    .setAccessToken(config.authToken || undefined)
+    .build();
+
+describe('ClonesApiBuilder', () => {
+    it('should build a ClonesClient instance', () => {
+        const builder = new ClonesApiBuilder(client);
+        const clonesClient = builder.build();
+        expect(clonesClient).toBeInstanceOf(ClonesClient);
+    });
+});

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

@@ -0,0 +1,61 @@
+import { ClonesClient } from '../../../src/clients/ClonesClient';
+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 clonesClient = new ClonesClient(client);
+
+describe('ClonesClient', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for clones', async () => {
+        const mockResponse = {
+            home_location: {
+                location_id: 123456,
+                location_type: 'station'
+            },
+            jump_clones: [
+                {
+                    implants: [1, 2, 3],
+                    location_id: 654321,
+                    location_type: 'station'
+                }
+            ]
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => clonesClient.getClones(123456789));
+
+        expect(result).toHaveProperty('home_location');
+        expect(result.home_location).toHaveProperty('location_id');
+        expect(result.home_location).toHaveProperty('location_type');
+        expect(result).toHaveProperty('jump_clones');
+        expect(Array.isArray(result.jump_clones)).toBe(true);
+    });
+
+    it('should return valid structure for implants', async () => {
+        const mockResponse = [1, 2, 3];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => clonesClient.getImplants(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((implant: number) => {
+            expect(typeof implant).toBe('number');
+        });
+    });
+});

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

@@ -0,0 +1,48 @@
+import { GetClonesApi } from '../../../src/api/clones/getClones';
+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 getClonesApi = new GetClonesApi(client);
+
+describe('GetClonesApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for clones', async () => {
+        const mockResponse = {
+            home_location: {
+                location_id: 123456,
+                location_type: 'station'
+            },
+            jump_clones: [
+                {
+                    implants: [1, 2, 3],
+                    location_id: 654321,
+                    location_type: 'station'
+                }
+            ]
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => getClonesApi.getClones(123456789));
+
+        expect(result).toHaveProperty('home_location');
+        expect(result.home_location).toHaveProperty('location_id');
+        expect(result.home_location).toHaveProperty('location_type');
+        expect(result).toHaveProperty('jump_clones');
+        expect(Array.isArray(result.jump_clones)).toBe(true);
+    });
+});

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

@@ -0,0 +1,35 @@
+import { GetImplantsApi } from '../../../src/api/clones/getImplants';
+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 getImplantsApi = new GetImplantsApi(client);
+
+describe('GetImplantsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for implants', async () => {
+        const mockResponse = [1, 2, 3];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => getImplantsApi.getImplants(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((implant: number) => {
+            expect(typeof implant).toBe('number');
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+// tests/tdd/contacts/ContactsApiBuilder.test.ts
+import { ContactsApiBuilder } from '../../../src/builders/ContactsApiBuilder';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+import { ContactsClient } from '../../../src/clients/ContactsClient';
+
+const config = getConfig();
+const client = new ApiClientBuilder()
+    .setClientId(config.projectName)
+    .setLink(config.link)
+    .setAccessToken(config.authToken || undefined)
+    .build();
+
+describe('ContactsApiBuilder', () => {
+    it('should build and return a ContactsClient instance', () => {
+        const builder = new ContactsApiBuilder(client);
+        const contactsClient = builder.build();
+
+        expect(contactsClient).toBeInstanceOf(ContactsClient);
+    });
+});

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

@@ -0,0 +1,66 @@
+import { ContactsClient } from '../../../src/clients/ContactsClient';
+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 contactsClient = new ContactsClient(client);
+
+describe('ContactsClient', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    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');
+        });
+    });
+
+    // Add other tests for the remaining APIs following the same pattern
+});

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

@@ -0,0 +1,23 @@
+import { deleteCharacterContacts } from '../../../src/api/contacts/deleteCharacterContacts';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterContactsApi = new deleteCharacterContacts(client);
+
+describe('DeleteCharacterContactsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should delete character contacts', async () => {
+        fetchMock.mockResponseOnce('', { status: 204 });
+
+        const contactIds = [123, 456];
+        const result = await getBody(() => characterContactsApi.deleteCharacterContacts(123456, contactIds));
+
+        expect(result).toEqual({ error: 'no content' });
+    });
+});

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

@@ -0,0 +1,33 @@
+import { getAllianceContactLabels } from '../../../src/api/contacts/getAllianceContactLabels';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const allianceContactLabelsApi = new getAllianceContactLabels(client);
+
+describe('GetAllianceContactLabelsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return alliance contact labels', async () => {
+        const mockResponse = [
+            {
+                label_id: 1,
+                label_name: 'Friends'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => allianceContactLabelsApi.getAllianceContactLabels(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((label: any) => {
+            expect(label).toHaveProperty('label_id');
+            expect(label).toHaveProperty('label_name');
+        });
+    });
+});

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

@@ -0,0 +1,37 @@
+import { getAllianceContacts } from '../../../src/api/contacts/getAllianceContacts';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const allianceContactsApi = new getAllianceContacts(client);
+
+describe('GetAllianceContactsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return alliance contacts', async () => {
+        const mockResponse = [
+            {
+                contact_id: 123,
+                contact_type: 'character',
+                standing: 10,
+                label_ids: [1, 2]
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => allianceContactsApi.getAllianceContacts(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((contact: any) => {
+            expect(contact).toHaveProperty('contact_id');
+            expect(contact).toHaveProperty('contact_type');
+            expect(contact).toHaveProperty('standing');
+            expect(contact).toHaveProperty('label_ids');
+        });
+    });
+});

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

@@ -0,0 +1,33 @@
+import { getCharacterContactLabels } from '../../../src/api/contacts/getCharacterContactLabels';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterContactLabelsApi = new getCharacterContactLabels(client);
+
+describe('getCharacterContactLabels', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return character contact labels', async () => {
+        const mockResponse = [
+            {
+                label_id: 1,
+                name: 'Friends'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterContactLabelsApi.getLabels(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((label: any) => {
+            expect(label).toHaveProperty('label_id');
+            expect(label).toHaveProperty('name');
+        });
+    });
+});

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

@@ -0,0 +1,37 @@
+import { getCharacterContacts } from '../../../src/api/contacts/getCharacterContacts';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterContactsApi = new getCharacterContacts(client);
+
+describe('getCharacterContacts', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return character contacts', async () => {
+        const mockResponse = [
+            {
+                contact_id: 123,
+                contact_type: 'character',
+                standing: 10,
+                label_ids: [1, 2]
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterContactsApi.getContacts(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((contact: any) => {
+            expect(contact).toHaveProperty('contact_id');
+            expect(contact).toHaveProperty('contact_type');
+            expect(contact).toHaveProperty('standing');
+            expect(contact).toHaveProperty('label_ids');
+        });
+    });
+});

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

@@ -0,0 +1,33 @@
+import { getCorporationContactLabels } from '../../../src/api/contacts/getCorporationContactLabels';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const corporationContactLabelsApi = new getCorporationContactLabels(client);
+
+describe('getCorporationContactLabels', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return corporation contact labels', async () => {
+        const mockResponse = [
+            {
+                label_id: 1,
+                name: 'VIPs'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationContactLabelsApi.getLabels(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((label: any) => {
+            expect(label).toHaveProperty('label_id');
+            expect(label).toHaveProperty('name');
+        });
+    });
+});

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

@@ -0,0 +1,37 @@
+import { getCorporationContacts } from '../../../src/api/contacts/getCorporationContacts';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const corporationContactsApi = new getCorporationContacts(client);
+
+describe('getCorporationContacts', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return corporation contacts', async () => {
+        const mockResponse = [
+            {
+                contact_id: 123,
+                contact_type: 'character',
+                standing: 10,
+                label_ids: [1, 2]
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationContactsApi.getContacts(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((contact: any) => {
+            expect(contact).toHaveProperty('contact_id');
+            expect(contact).toHaveProperty('contact_type');
+            expect(contact).toHaveProperty('standing');
+            expect(contact).toHaveProperty('label_ids');
+        });
+    });
+});

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

@@ -0,0 +1,30 @@
+import { postCharacterContacts } from '../../../src/api/contacts/postCharacterContacts';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterContactsApi = new postCharacterContacts(client);
+
+describe('postCharacterContacts', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should add character contacts', async () => {
+        const mockResponse = '';
+
+        fetchMock.mockResponseOnce(mockResponse, { status: 201 });
+
+        const contacts = {
+            contact_ids: [123, 456],
+            standing: 5,
+            label_ids: [1, 2]
+        };
+
+        const result = await getBody(() => characterContactsApi.addContacts(123456, contacts));
+
+        expect(result).toEqual({ error: 'created' });
+    });
+});

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

@@ -0,0 +1,30 @@
+import { putCharacterContacts } from '../../../src/api/contacts/putCharacterContacts';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterContactsApi = new putCharacterContacts(client);
+
+describe('putCharacterContacts', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should edit character contacts', async () => {
+        const mockResponse = '';
+
+        fetchMock.mockResponseOnce(mockResponse, { status: 204 });
+
+        const contacts = {
+            contact_ids: [123, 456],
+            standing: 5,
+            label_ids: [1, 2]
+        };
+
+        const result = await getBody(() => characterContactsApi.editContacts(123456, contacts));
+
+        expect(result).toEqual({ error: 'no content' });
+    });
+});

package/tests/tdd/contracts/ContractsApiBuilder.ts

@@ -0,0 +1,20 @@
+import { ContractsApiBuilder } from '../../../src/builders/ContractsApiBuilder';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+import { ContractsClient } from '../../../src/clients/ContractsClient';
+
+const config = getConfig();
+const client = new ApiClientBuilder()
+    .setClientId(config.projectName)
+    .setLink(config.link)
+    .setAccessToken(config.authToken || undefined)
+    .build();
+
+describe('ContractApiBuilder', () => {
+    it('should build and return a ContractClient instance', () => {
+        const builder = new ContractsApiBuilder(client);
+        const contractClient = builder.build();
+
+        expect(contractClient).toBeInstanceOf(ContractsClient);
+    });
+});