@lgriffin/esi.ts 1.0.0

package/tests/tdd/industry/getCharacterIndustryJobs.test.ts

@@ -0,0 +1,80 @@
+import { GetCharacterIndustryJobsApi } from '../../../src/api/industry/getCharacterIndustryJobs';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterIndustryJobsApi = new GetCharacterIndustryJobsApi(client);
+
+describe('GetCharacterIndustryJobsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for character industry jobs', async () => {
+        const mockResponse = [
+            {
+                job_id: 1,
+                activity_id: 3,
+                blueprint_id: 2,
+                blueprint_location_id: 3,
+                blueprint_type_id: 4,
+                cost: 500,
+                end_date: '2024-01-01T00:00:00Z',
+                facility_id: 5,
+                installer_id: 6,
+                licensed_runs: 1,
+                location_id: 7,
+                output_location_id: 8,
+                probability: 0.9,
+                product_type_id: 9,
+                runs: 1,
+                start_date: '2024-01-01T00:00:00Z',
+                status: 'active'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterIndustryJobsApi.getCharacterIndustryJobs(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((job: any) => {
+            expect(job).toHaveProperty('job_id');
+            expect(typeof job.job_id).toBe('number');
+            expect(job).toHaveProperty('activity_id');
+            expect(typeof job.activity_id).toBe('number');
+            expect(job).toHaveProperty('blueprint_id');
+            expect(typeof job.blueprint_id).toBe('number');
+            expect(job).toHaveProperty('blueprint_location_id');
+            expect(typeof job.blueprint_location_id).toBe('number');
+            expect(job).toHaveProperty('blueprint_type_id');
+            expect(typeof job.blueprint_type_id).toBe('number');
+            expect(job).toHaveProperty('cost');
+            expect(typeof job.cost).toBe('number');
+            expect(job).toHaveProperty('end_date');
+            expect(typeof job.end_date).toBe('string');
+            expect(job).toHaveProperty('facility_id');
+            expect(typeof job.facility_id).toBe('number');
+            expect(job).toHaveProperty('installer_id');
+            expect(typeof job.installer_id).toBe('number');
+            expect(job).toHaveProperty('licensed_runs');
+            expect(typeof job.licensed_runs).toBe('number');
+            expect(job).toHaveProperty('location_id');
+            expect(typeof job.location_id).toBe('number');
+            expect(job).toHaveProperty('output_location_id');
+            expect(typeof job.output_location_id).toBe('number');
+            expect(job).toHaveProperty('probability');
+            expect(typeof job.probability).toBe('number');
+            expect(job).toHaveProperty('product_type_id');
+            expect(typeof job.product_type_id).toBe('number');
+            expect(job).toHaveProperty('runs');
+            expect(typeof job.runs).toBe('number');
+            expect(job).toHaveProperty('start_date');
+            expect(typeof job.start_date).toBe('string');
+            expect(job).toHaveProperty('status');
+            expect(typeof job.status).toBe('string');
+        });
+    });
+});

package/tests/tdd/industry/getCharacterMiningLedger.test.ts

@@ -0,0 +1,41 @@
+import { GetCharacterMiningLedgerApi } from '../../../src/api/industry/getCharacterMiningLedger';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const characterMiningLedgerApi = new GetCharacterMiningLedgerApi(client);
+
+describe('GetCharacterMiningLedgerApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for character mining ledger', async () => {
+        const mockResponse = [
+            {
+                date: '2024-01-01',
+                solar_system_id: 30000142,
+                type_id: 1230,
+                quantity: 1000
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => characterMiningLedgerApi.getCharacterMiningLedger(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((entry: any) => {
+            expect(entry).toHaveProperty('date');
+            expect(typeof entry.date).toBe('string');
+            expect(entry).toHaveProperty('solar_system_id');
+            expect(typeof entry.solar_system_id).toBe('number');
+            expect(entry).toHaveProperty('type_id');
+            expect(typeof entry.type_id).toBe('number');
+            expect(entry).toHaveProperty('quantity');
+            expect(typeof entry.quantity).toBe('number');
+        });
+    });
+});

package/tests/tdd/industry/getCorporationIndustryJobs.test.ts

@@ -0,0 +1,92 @@
+import { GetCorporationIndustryJobsApi } from '../../../src/api/industry/getCorporationIndustryJobs';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const corporationIndustryJobsApi = new GetCorporationIndustryJobsApi(client);
+
+describe('GetCorporationIndustryJobsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation industry jobs', async () => {
+        const mockResponse = [
+            {
+                job_id: 1,
+                installer_id: 2,
+                facility_id: 3,
+                location_id: 4,
+                activity_id: 5,
+                blueprint_id: 6,
+                blueprint_type_id: 7,
+                blueprint_location_id: 8,
+                output_location_id: 9,
+                runs: 10,
+                cost: 11.1,
+                licensed_runs: 12,
+                probability: 0.5,
+                product_type_id: 13,
+                status: 'active',
+                duration: 14,
+                start_date: '2024-01-01T00:00:00Z',
+                end_date: '2024-01-02T00:00:00Z',
+                pause_date: '2024-01-01T12:00:00Z',
+                completed_date: '2024-01-02T12:00:00Z',
+                completed_character_id: 15
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationIndustryJobsApi.getCorporationIndustryJobs(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((job: any) => {
+            expect(job).toHaveProperty('job_id');
+            expect(typeof job.job_id).toBe('number');
+            expect(job).toHaveProperty('installer_id');
+            expect(typeof job.installer_id).toBe('number');
+            expect(job).toHaveProperty('facility_id');
+            expect(typeof job.facility_id).toBe('number');
+            expect(job).toHaveProperty('location_id');
+            expect(typeof job.location_id).toBe('number');
+            expect(job).toHaveProperty('activity_id');
+            expect(typeof job.activity_id).toBe('number');
+            expect(job).toHaveProperty('blueprint_id');
+            expect(typeof job.blueprint_id).toBe('number');
+            expect(job).toHaveProperty('blueprint_type_id');
+            expect(typeof job.blueprint_type_id).toBe('number');
+            expect(job).toHaveProperty('blueprint_location_id');
+            expect(typeof job.blueprint_location_id).toBe('number');
+            expect(job).toHaveProperty('output_location_id');
+            expect(typeof job.output_location_id).toBe('number');
+            expect(job).toHaveProperty('runs');
+            expect(typeof job.runs).toBe('number');
+            expect(job).toHaveProperty('cost');
+            expect(typeof job.cost).toBe('number');
+            expect(job).toHaveProperty('licensed_runs');
+            expect(typeof job.licensed_runs).toBe('number');
+            expect(job).toHaveProperty('probability');
+            expect(typeof job.probability).toBe('number');
+            expect(job).toHaveProperty('product_type_id');
+            expect(typeof job.product_type_id).toBe('number');
+            expect(job).toHaveProperty('status');
+            expect(typeof job.status).toBe('string');
+            expect(job).toHaveProperty('duration');
+            expect(typeof job.duration).toBe('number');
+            expect(job).toHaveProperty('start_date');
+            expect(typeof job.start_date).toBe('string');
+            expect(job).toHaveProperty('end_date');
+            expect(typeof job.end_date).toBe('string');
+            expect(job).toHaveProperty('pause_date');
+            expect(typeof job.pause_date).toBe('string');
+            expect(job).toHaveProperty('completed_date');
+            expect(typeof job.completed_date).toBe('string');
+            expect(job).toHaveProperty('completed_character_id');
+            expect(typeof job.completed_character_id).toBe('number');
+        });
+    });
+});

package/tests/tdd/industry/getCorporationMiningObserver.test.ts

@@ -0,0 +1,44 @@
+import { GetCorporationMiningObserverApi } from '../../../src/api/industry/getCorporationMiningObserver';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const corporationMiningObserverApi = new GetCorporationMiningObserverApi(client);
+
+describe('GetCorporationMiningObserverApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for observed corporation mining', async () => {
+        const mockResponse = [
+            {
+                character_id: 123456789,
+                last_updated: '2024-01-01T00:00:00Z',
+                quantity: 1000,
+                recorded_corporation_id: 987654321,
+                type_id: 1234
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMiningObserverApi.getCorporationMiningObserver(123456789, 987654321));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((mining: any) => {
+            expect(mining).toHaveProperty('character_id');
+            expect(typeof mining.character_id).toBe('number');
+            expect(mining).toHaveProperty('last_updated');
+            expect(typeof mining.last_updated).toBe('string');
+            expect(mining).toHaveProperty('quantity');
+            expect(typeof mining.quantity).toBe('number');
+            expect(mining).toHaveProperty('recorded_corporation_id');
+            expect(typeof mining.recorded_corporation_id).toBe('number');
+            expect(mining).toHaveProperty('type_id');
+            expect(typeof mining.type_id).toBe('number');
+        });
+    });
+});

package/tests/tdd/industry/getCorporationMiningObservers.test.ts

@@ -0,0 +1,38 @@
+import { GetCorporationMiningObserversApi } from '../../../src/api/industry/getCorporationMiningObservers';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const corporationMiningObserversApi = new GetCorporationMiningObserversApi(client);
+
+describe('GetCorporationMiningObserversApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation mining observers', async () => {
+        const mockResponse = [
+            {
+                last_updated: '2024-01-01T00:00:00Z',
+                observer_id: 123456789,
+                observer_type: 'structure'
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => corporationMiningObserversApi.getCorporationMiningObservers(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((observer: any) => {
+            expect(observer).toHaveProperty('last_updated');
+            expect(typeof observer.last_updated).toBe('string');
+            expect(observer).toHaveProperty('observer_id');
+            expect(typeof observer.observer_id).toBe('number');
+            expect(observer).toHaveProperty('observer_type');
+            expect(typeof observer.observer_type).toBe('string');
+        });
+    });
+});

package/tests/tdd/industry/getIndustryFacilities.test.ts

@@ -0,0 +1,47 @@
+import { GetIndustryFacilitiesApi } from '../../../src/api/industry/getIndustryFacilities';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const industryFacilitiesApi = new GetIndustryFacilitiesApi(client);
+
+describe('GetIndustryFacilitiesApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for industry facilities', async () => {
+        const mockResponse = [
+            {
+                facility_id: 1,
+                type_id: 2,
+                solar_system_id: 3,
+                region_id: 4,
+                starbase_modifier: 0.5,
+                tax: 0.1
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => industryFacilitiesApi.getIndustryFacilities());
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((facility: any) => {
+            expect(facility).toHaveProperty('facility_id');
+            expect(typeof facility.facility_id).toBe('number');
+            expect(facility).toHaveProperty('type_id');
+            expect(typeof facility.type_id).toBe('number');
+            expect(facility).toHaveProperty('solar_system_id');
+            expect(typeof facility.solar_system_id).toBe('number');
+            expect(facility).toHaveProperty('region_id');
+            expect(typeof facility.region_id).toBe('number');
+            expect(facility).toHaveProperty('starbase_modifier');
+            expect(typeof facility.starbase_modifier).toBe('number');
+            expect(facility).toHaveProperty('tax');
+            expect(typeof facility.tax).toBe('number');
+        });
+    });
+});

package/tests/tdd/industry/getIndustrySystems.test.ts

@@ -0,0 +1,46 @@
+import { GetIndustrySystemsApi } from '../../../src/api/industry/getIndustrySystems';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const industrySystemsApi = new GetIndustrySystemsApi(client);
+
+describe('GetIndustrySystemsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for industry systems', async () => {
+        const mockResponse = [
+            {
+                solar_system_id: 1,
+                cost_indices: [
+                    {
+                        activity: 'manufacturing',
+                        cost_index: 0.1
+                    }
+                ]
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => industrySystemsApi.getIndustrySystems());
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((system: any) => {
+            expect(system).toHaveProperty('solar_system_id');
+            expect(typeof system.solar_system_id).toBe('number');
+            expect(system).toHaveProperty('cost_indices');
+            expect(Array.isArray(system.cost_indices)).toBe(true);
+            system.cost_indices.forEach((costIndex: any) => {
+                expect(costIndex).toHaveProperty('activity');
+                expect(typeof costIndex.activity).toBe('string');
+                expect(costIndex).toHaveProperty('cost_index');
+                expect(typeof costIndex.cost_index).toBe('number');
+            });
+        });
+    });
+});

package/tests/tdd/industry/getMoonExtractionTimers.test.ts

@@ -0,0 +1,44 @@
+import { GetMoonExtractionTimersApi } from '../../../src/api/industry/getMoonExtractionTimers';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const client = getClient();
+const moonExtractionTimersApi = new GetMoonExtractionTimersApi(client);
+
+describe('GetMoonExtractionTimersApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for moon extraction timers', async () => {
+        const mockResponse = [
+            {
+                chunk_arrival_time: '2024-01-01T00:00:00Z',
+                extraction_start_time: '2024-01-01T00:00:00Z',
+                moon_id: 40161465,
+                natural_decay_time: '2024-01-01T00:00:00Z',
+                structure_id: 1021975535893
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => moonExtractionTimersApi.getMoonExtractionTimers(123456789));
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((timer: any) => {
+            expect(timer).toHaveProperty('chunk_arrival_time');
+            expect(typeof timer.chunk_arrival_time).toBe('string');
+            expect(timer).toHaveProperty('extraction_start_time');
+            expect(typeof timer.extraction_start_time).toBe('string');
+            expect(timer).toHaveProperty('moon_id');
+            expect(typeof timer.moon_id).toBe('number');
+            expect(timer).toHaveProperty('natural_decay_time');
+            expect(typeof timer.natural_decay_time).toBe('string');
+            expect(timer).toHaveProperty('structure_id');
+            expect(typeof timer.structure_id).toBe('number');
+        });
+    });
+});

package/tests/tdd/insurance/InsuranceApiBuilder.test.ts

@@ -0,0 +1,21 @@
+import { ApiClient } from '../../../src/core/ApiClient';
+import { ApiClientBuilder } from '../../../src/core/ApiClientBuilder';
+import { getConfig } from '../../../src/config/configManager';
+import { InsuranceAPIBuilder } from '../../../src/builders/InsuranceApiBuilder';
+import { InsuranceClient } from '../../../src/clients/InsuranceClient';
+
+describe('InsuranceAPIBuilder', () => {
+    const config = getConfig();
+    const client = new ApiClientBuilder()
+        .setClientId(config.projectName)
+        .setLink(config.link)
+        .setAccessToken(config.authToken || undefined)
+        .build();
+
+    it('should build an InsuranceClient', () => {
+        const builder = new InsuranceAPIBuilder(client);
+        const insuranceClient = builder.build();
+
+        expect(insuranceClient).toBeInstanceOf(InsuranceClient);
+    });
+});

package/tests/tdd/insurance/InsuranceClient.test.ts

@@ -0,0 +1,50 @@
+import { InsuranceClient } from '../../../src/clients/InsuranceClient';
+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 insuranceClient = new InsuranceClient(client);
+
+describe('InsuranceClient', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid insurance prices', async () => {
+        const mockResponse = [
+            {
+                name: 'Basic',
+                cost: 1000,
+                payout: 5000
+            },
+            {
+                name: 'Standard',
+                cost: 2000,
+                payout: 10000
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => insuranceClient.getInsurancePrices());
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((insurance: any) => {
+            expect(insurance).toHaveProperty('name');
+            expect(typeof insurance.name).toBe('string');
+            expect(insurance).toHaveProperty('cost');
+            expect(typeof insurance.cost).toBe('number');
+            expect(insurance).toHaveProperty('payout');
+            expect(typeof insurance.payout).toBe('number');
+        });
+    });
+});

package/tests/tdd/insurance/getInsurancePrices.test.ts

@@ -0,0 +1,51 @@
+import { InsuranceApi } from '../../../src/api/insurance/getInsurancePrices';
+import { ApiClient } from '../../../src/core/ApiClient';
+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 insuranceApi = new InsuranceApi(client);
+
+describe('InsuranceApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid insurance prices', async () => {
+        const mockResponse = [
+            {
+                name: 'Basic',
+                cost: 1000,
+                payout: 5000
+            },
+            {
+                name: 'Standard',
+                cost: 2000,
+                payout: 10000
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => insuranceApi.getInsurancePrices());
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((insurance: any) => {
+            expect(insurance).toHaveProperty('name');
+            expect(typeof insurance.name).toBe('string');
+            expect(insurance).toHaveProperty('cost');
+            expect(typeof insurance.cost).toBe('number');
+            expect(insurance).toHaveProperty('payout');
+            expect(typeof insurance.payout).toBe('number');
+        });
+    });
+});

package/tests/tdd/killmails/KillmailApiBuilder.test.ts

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