@lgriffin/esi.ts 1.0.0

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

@@ -0,0 +1,54 @@
+import { GetCorporationIssuedMedalsApi } from '../../../src/api/corporations/getCorporationIssuedMedals';
+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 corporationIssuedMedalsApi = new GetCorporationIssuedMedalsApi(client);
+
+describe('GetCorporationIssuedMedalsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation issued medals', async () => {
+        const mockResponse = [
+            {
+                medal_id: 1,
+                recipient_id: 54321,
+                issuer_id: 12345,
+                issued_at: '2024-07-01T12:00:00Z',
+                reason: 'Great performance',
+                status: 'public'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationIssuedMedalsApi.getCorporationIssuedMedals(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((medal: { medal_id: number; recipient_id: number; issuer_id: number; issued_at: string; reason: string; status: string }) => {
+            expect(medal).toHaveProperty('medal_id');
+            expect(typeof medal.medal_id).toBe('number');
+            expect(medal).toHaveProperty('recipient_id');
+            expect(typeof medal.recipient_id).toBe('number');
+            expect(medal).toHaveProperty('issuer_id');
+            expect(typeof medal.issuer_id).toBe('number');
+            expect(medal).toHaveProperty('issued_at');
+            expect(typeof medal.issued_at).toBe('string');
+            expect(medal).toHaveProperty('reason');
+            expect(typeof medal.reason).toBe('string');
+            expect(medal).toHaveProperty('status');
+            expect(typeof medal.status).toBe('string');
+        });
+    });
+});

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

@@ -0,0 +1,51 @@
+import { GetCorporationMedalsApi } from '../../../src/api/corporations/getCorporationMedals';
+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 corporationMedalsApi = new GetCorporationMedalsApi(client);
+
+describe('GetCorporationMedalsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation medals', async () => {
+        const mockResponse = [
+            {
+                medal_id: 1,
+                title: 'Medal Title',
+                description: 'Medal Description',
+                creator_id: 12345,
+                created_at: '2024-07-01T12:00:00Z',
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMedalsApi.getCorporationMedals(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((medal: { medal_id: number; title: string; description: string; creator_id: number; created_at: string }) => {
+            expect(medal).toHaveProperty('medal_id');
+            expect(typeof medal.medal_id).toBe('number');
+            expect(medal).toHaveProperty('title');
+            expect(typeof medal.title).toBe('string');
+            expect(medal).toHaveProperty('description');
+            expect(typeof medal.description).toBe('string');
+            expect(medal).toHaveProperty('creator_id');
+            expect(typeof medal.creator_id).toBe('number');
+            expect(medal).toHaveProperty('created_at');
+            expect(typeof medal.created_at).toBe('string');
+        });
+    });
+});

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

@@ -0,0 +1,32 @@
+import { GetCorporationMemberLimitApi } from '../../../src/api/corporations/getCorporationMemberLimit';
+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 corporationMemberLimitApi = new GetCorporationMemberLimitApi(client);
+
+describe('GetCorporationMemberLimitApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation member limit', async () => {
+        const mockResponse = { member_limit: 100 };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMemberLimitApi.getCorporationMemberLimit(12345));
+
+        expect(result).toHaveProperty('member_limit');
+        expect(typeof result.member_limit).toBe('number');
+    });
+});

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

@@ -0,0 +1,45 @@
+import { GetCorporationMemberRolesApi } from '../../../src/api/corporations/getCorporationMemberRoles';
+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 corporationMemberRolesApi = new GetCorporationMemberRolesApi(client);
+
+describe('GetCorporationMemberRolesApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation member roles', async () => {
+        const mockResponse = [
+            {
+                character_id: 12345,
+                roles: ['Director', 'Accountant']
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMemberRolesApi.getCorporationMemberRoles(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((memberRole: { character_id: number, roles: string[] }) => {
+            expect(memberRole).toHaveProperty('character_id');
+            expect(typeof memberRole.character_id).toBe('number');
+            expect(memberRole).toHaveProperty('roles');
+            expect(Array.isArray(memberRole.roles)).toBe(true);
+            memberRole.roles.forEach(role => {
+                expect(typeof role).toBe('string');
+            });
+        });
+    });
+});

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

@@ -0,0 +1,60 @@
+import { GetCorporationMemberRolesHistoryApi } from '../../../src/api/corporations/getCorporationMemberRolesHistory';
+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 corporationMemberRolesHistoryApi = new GetCorporationMemberRolesHistoryApi(client);
+
+describe('GetCorporationMemberRolesHistoryApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation member roles history', async () => {
+        const mockResponse = [
+            {
+                character_id: 12345,
+                changed_at: '2024-07-01T12:00:00Z',
+                issuer_id: 67890,
+                role_type: 'role_type',
+                old_roles: ['old_role1', 'old_role2'],
+                new_roles: ['new_role1', 'new_role2']
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMemberRolesHistoryApi.getCorporationMemberRolesHistory(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((history: { character_id: number, changed_at: string, issuer_id: number, role_type: string, old_roles: string[], new_roles: string[] }) => {
+            expect(history).toHaveProperty('character_id');
+            expect(typeof history.character_id).toBe('number');
+            expect(history).toHaveProperty('changed_at');
+            expect(typeof history.changed_at).toBe('string');
+            expect(history).toHaveProperty('issuer_id');
+            expect(typeof history.issuer_id).toBe('number');
+            expect(history).toHaveProperty('role_type');
+            expect(typeof history.role_type).toBe('string');
+            expect(history).toHaveProperty('old_roles');
+            expect(Array.isArray(history.old_roles)).toBe(true);
+            history.old_roles.forEach(role => {
+                expect(typeof role).toBe('string');
+            });
+            expect(history).toHaveProperty('new_roles');
+            expect(Array.isArray(history.new_roles)).toBe(true);
+            history.new_roles.forEach(role => {
+                expect(typeof role).toBe('string');
+            });
+        });
+    });
+});

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

@@ -0,0 +1,48 @@
+import { GetCorporationMemberTrackingApi } from '../../../src/api/corporations/getCorporationMemberTracking';
+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 corporationMemberTrackingApi = new GetCorporationMemberTrackingApi(client);
+
+describe('GetCorporationMemberTrackingApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation member tracking', async () => {
+        const mockResponse = [
+            {
+                character_id: 12345,
+                start_date: '2024-07-01T12:00:00Z',
+                location_id: 67890,
+                ship_type_id: 54321
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMemberTrackingApi.getCorporationMemberTracking(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((member: { character_id: number, start_date: string, location_id: number, ship_type_id: number }) => {
+            expect(member).toHaveProperty('character_id');
+            expect(typeof member.character_id).toBe('number');
+            expect(member).toHaveProperty('start_date');
+            expect(typeof member.start_date).toBe('string');
+            expect(member).toHaveProperty('location_id');
+            expect(typeof member.location_id).toBe('number');
+            expect(member).toHaveProperty('ship_type_id');
+            expect(typeof member.ship_type_id).toBe('number');
+        });
+    });
+});

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

@@ -0,0 +1,34 @@
+import { GetCorporationMembersApi } from '../../../src/api/corporations/getCorporationMembers';
+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 corporationMembersApi = new GetCorporationMembersApi(client);
+
+describe('GetCorporationMembersApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation members', async () => {
+        const mockResponse = [123456, 789012, 345678];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMembersApi.getCorporationMembers(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((memberId: number) => {
+            expect(typeof memberId).toBe('number');
+        });
+    });
+});

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

@@ -0,0 +1,45 @@
+import { GetCorporationMembersTitlesApi } from '../../../src/api/corporations/getCorporationMembersTitles';
+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 corporationMembersTitlesApi = new GetCorporationMembersTitlesApi(client);
+
+describe('GetCorporationMembersTitlesApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation members titles', async () => {
+        const mockResponse = [
+            {
+                character_id: 12345,
+                titles: [1, 2, 3]
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMembersTitlesApi.getCorporationMembersTitles(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((memberTitle: { character_id: number, titles: number[] }) => {
+            expect(memberTitle).toHaveProperty('character_id');
+            expect(typeof memberTitle.character_id).toBe('number');
+            expect(memberTitle).toHaveProperty('titles');
+            expect(Array.isArray(memberTitle.titles)).toBe(true);
+            memberTitle.titles.forEach(title => {
+                expect(typeof title).toBe('number');
+            });
+        });
+    });
+});

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

@@ -0,0 +1,45 @@
+import { GetCorporationShareholdersApi } from '../../../src/api/corporations/getCorporationShareholders';
+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 corporationShareholdersApi = new GetCorporationShareholdersApi(client);
+
+describe('GetCorporationShareholdersApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation shareholders', async () => {
+        const mockResponse = [
+            {
+                shareholder_id: 12345,
+                shareholder_type: 'character',
+                shares: 1000
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationShareholdersApi.getCorporationShareholders(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((shareholder: { shareholder_id: number, shareholder_type: string, shares: number }) => {
+            expect(shareholder).toHaveProperty('shareholder_id');
+            expect(typeof shareholder.shareholder_id).toBe('number');
+            expect(shareholder).toHaveProperty('shareholder_type');
+            expect(typeof shareholder.shareholder_type).toBe('string');
+            expect(shareholder).toHaveProperty('shares');
+            expect(typeof shareholder.shares).toBe('number');
+        });
+    });
+});

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

@@ -0,0 +1,45 @@
+import { GetCorporationStandingsApi } from '../../../src/api/corporations/getCorporationStandings';
+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 corporationStandingsApi = new GetCorporationStandingsApi(client);
+
+describe('GetCorporationStandingsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation standings', async () => {
+        const mockResponse = [
+            {
+                from_id: 12345,
+                from_type: 'agent',
+                standing: 0.5
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationStandingsApi.getCorporationStandings(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((standing: { from_id: number, from_type: string, standing: number }) => {
+            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');
+        });
+    });
+});

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

@@ -0,0 +1,49 @@
+import { GetCorporationStarbaseDetailApi } from '../../../src/api/corporations/getCorporationStarbaseDetail';
+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 api = new GetCorporationStarbaseDetailApi(client);
+
+describe('GetCorporationStarbaseDetailApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for starbase detail', async () => {
+        const mockResponse = {
+            starbase_id: 1234567890,
+            type_id: 12345,
+            system_id: 67890,
+            moon_id: 112233,
+            state: 'online',
+            unanchor_at: '2024-01-01T00:00:00Z'
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => api.getCorporationStarbaseDetail(123456, 1234567890));
+
+        expect(result).toHaveProperty('starbase_id');
+        expect(typeof result.starbase_id).toBe('number');
+        expect(result).toHaveProperty('type_id');
+        expect(typeof result.type_id).toBe('number');
+        expect(result).toHaveProperty('system_id');
+        expect(typeof result.system_id).toBe('number');
+        expect(result).toHaveProperty('moon_id');
+        expect(typeof result.moon_id).toBe('number');
+        expect(result).toHaveProperty('state');
+        expect(typeof result.state).toBe('string');
+        expect(result).toHaveProperty('unanchor_at');
+        expect(typeof result.unanchor_at).toBe('string');
+    });
+});

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

@@ -0,0 +1,54 @@
+import { GetCorporationStarbasesApi } from '../../../src/api/corporations/getCorporationStarbases';
+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 corporationStarbasesApi = new GetCorporationStarbasesApi(client);
+
+describe('GetCorporationStarbasesApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation starbases', async () => {
+        const mockResponse = [
+            {
+                starbase_id: 12345,
+                type_id: 67890,
+                system_id: 54321,
+                moon_id: 98765,
+                state: 'online',
+                unanchor_at: '2024-07-01T12:00:00Z'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationStarbasesApi.getCorporationStarbases(12345));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((starbase: { starbase_id: number, type_id: number, system_id: number, moon_id: number, state: string, unanchor_at: string }) => {
+            expect(starbase).toHaveProperty('starbase_id');
+            expect(typeof starbase.starbase_id).toBe('number');
+            expect(starbase).toHaveProperty('type_id');
+            expect(typeof starbase.type_id).toBe('number');
+            expect(starbase).toHaveProperty('system_id');
+            expect(typeof starbase.system_id).toBe('number');
+            expect(starbase).toHaveProperty('moon_id');
+            expect(typeof starbase.moon_id).toBe('number');
+            expect(starbase).toHaveProperty('state');
+            expect(typeof starbase.state).toBe('string');
+            expect(starbase).toHaveProperty('unanchor_at');
+            expect(typeof starbase.unanchor_at).toBe('string');
+        });
+    });
+});

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

@@ -0,0 +1,54 @@
+import { GetCorporationStructuresApi } from '../../../src/api/corporations/getCorporationStructures';
+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 api = new GetCorporationStructuresApi(client);
+
+describe('GetCorporationStructuresApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation structures', async () => {
+        const mockResponse = [
+            {
+                structure_id: 1234567890,
+                type_id: 12345,
+                system_id: 67890,
+                starbase_id: 112233,
+                state: 'online',
+                fuel_expires: '2024-01-01T00:00:00Z'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => api.getCorporationStructures(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        (result as any[]).forEach(structure => {
+            expect(structure).toHaveProperty('structure_id');
+            expect(typeof structure.structure_id).toBe('number');
+            expect(structure).toHaveProperty('type_id');
+            expect(typeof structure.type_id).toBe('number');
+            expect(structure).toHaveProperty('system_id');
+            expect(typeof structure.system_id).toBe('number');
+            expect(structure).toHaveProperty('starbase_id');
+            expect(typeof structure.starbase_id).toBe('number');
+            expect(structure).toHaveProperty('state');
+            expect(typeof structure.state).toBe('string');
+            expect(structure).toHaveProperty('fuel_expires');
+            expect(typeof structure.fuel_expires).toBe('string');
+        });
+    });
+});