@lgriffin/esi.ts 1.0.0

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

@@ -0,0 +1,66 @@
+import { GetCorporationTitlesApi } from '../../../src/api/corporations/getCorporationTitles';
+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 GetCorporationTitlesApi(client);
+
+describe('GetCorporationTitlesApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for corporation titles', async () => {
+        const mockResponse = [
+            {
+                title_id: 1,
+                name: 'Director',
+                roles: ['role1', 'role2'],
+                grantable_roles: ['role3'],
+                roles_at_hq: ['role4'],
+                grantable_roles_at_hq: ['role5'],
+                roles_at_base: ['role6'],
+                grantable_roles_at_base: ['role7'],
+                roles_at_other: ['role8'],
+                grantable_roles_at_other: ['role9']
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => api.getCorporationTitles(123456));
+
+        expect(Array.isArray(result)).toBe(true);
+        (result as any[]).forEach(title => {
+            expect(title).toHaveProperty('title_id');
+            expect(typeof title.title_id).toBe('number');
+            expect(title).toHaveProperty('name');
+            expect(typeof title.name).toBe('string');
+            expect(title).toHaveProperty('roles');
+            expect(Array.isArray(title.roles)).toBe(true);
+            expect(title).toHaveProperty('grantable_roles');
+            expect(Array.isArray(title.grantable_roles)).toBe(true);
+            expect(title).toHaveProperty('roles_at_hq');
+            expect(Array.isArray(title.roles_at_hq)).toBe(true);
+            expect(title).toHaveProperty('grantable_roles_at_hq');
+            expect(Array.isArray(title.grantable_roles_at_hq)).toBe(true);
+            expect(title).toHaveProperty('roles_at_base');
+            expect(Array.isArray(title.roles_at_base)).toBe(true);
+            expect(title).toHaveProperty('grantable_roles_at_base');
+            expect(Array.isArray(title.grantable_roles_at_base)).toBe(true);
+            expect(title).toHaveProperty('roles_at_other');
+            expect(Array.isArray(title.roles_at_other)).toBe(true);
+            expect(title).toHaveProperty('grantable_roles_at_other');
+            expect(Array.isArray(title.grantable_roles_at_other)).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,34 @@
+import { GetNpcCorporationsApi } from '../../../src/api/corporations/getNpcCorporations';
+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 GetNpcCorporationsApi(client);
+
+describe('GetNpcCorporationsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for NPC corporations', async () => {
+        const mockResponse = [1000169, 1000170, 1000171];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => api.getNpcCorporations());
+
+        expect(Array.isArray(result)).toBe(true);
+        (result as number[]).forEach(corpId => {
+            expect(typeof corpId).toBe('number');
+        });
+    });
+});

package/tests/tdd/dogma/DogmaAPIBuilder.test.ts

@@ -0,0 +1,13 @@
+import { ApiClient } from '../../../src/core/ApiClient';
+import { DogmaAPIBuilder } from '../../../src/builders/DogmaApiBuilder';
+import { DogmaClient } from '../../../src/clients/DogmaClient';
+
+describe('DogmaAPIBuilder', () => {
+    it('should build DogmaClient', () => {
+        const apiClient = new ApiClient('test', 'https://esi.evetech.net/latest');
+        const builder = new DogmaAPIBuilder(apiClient);
+        const client = builder.build();
+
+        expect(client).toBeInstanceOf(DogmaClient);
+    });
+});

package/tests/tdd/dogma/DogmanClient.test.ts

@@ -0,0 +1,54 @@
+import { DogmaAPIBuilder } from '../../../src/builders/DogmaApiBuilder';
+import { ApiClient } from '../../../src/core/ApiClient';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+const apiClient = new ApiClient('test', 'https://esi.evetech.net/latest');
+const dogmaClient = new DogmaAPIBuilder(apiClient).build();
+
+describe('DogmaClient', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should get attributes', async () => {
+        const mockResponse = [{ attribute_id: 1, name: 'test_attribute' }];
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaClient.getAttributes());
+        expect(result).toEqual(mockResponse);
+    });
+
+    it('should get attribute by id', async () => {
+        const mockResponse = { attribute_id: 1, name: 'test_attribute' };
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaClient.getAttributeById(1));
+        expect(result).toEqual(mockResponse);
+    });
+
+    it('should get dynamic item info', async () => {
+        const mockResponse = { item_id: 1, type_id: 1, dogma: [] };
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaClient.getDynamicItemInfo(1, 1));
+        expect(result).toEqual(mockResponse);
+    });
+
+    it('should get effects', async () => {
+        const mockResponse = [{ effect_id: 1, name: 'test_effect' }];
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaClient.getEffects());
+        expect(result).toEqual(mockResponse);
+    });
+
+    it('should get effect by id', async () => {
+        const mockResponse = { effect_id: 1, name: 'test_effect' };
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaClient.getEffectById(1));
+        expect(result).toEqual(mockResponse);
+    });
+});

package/tests/tdd/dogma/getDogmaAttributeById.test.ts

@@ -0,0 +1,22 @@
+import { DogmaAttributeByIdApi } from '../../../src/api/dogma/getDogmaAttributeById';
+import { ApiClient } from '../../../src/core/ApiClient';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+describe('DogmaAttributeByIdApi', () => {
+    const apiClient = new ApiClient('test', 'https://esi.evetech.net/latest');
+    const dogmaAttributeByIdApi = new DogmaAttributeByIdApi(apiClient);
+
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should get attribute by id', async () => {
+        const mockResponse = { attribute_id: 1, name: 'test_attribute' };
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaAttributeByIdApi.getAttributeById(1));
+        expect(result).toEqual(mockResponse);
+    });
+});

package/tests/tdd/dogma/getDogmaAttributes.test.ts

@@ -0,0 +1,22 @@
+import { DogmaAttributesApi } from '../../../src/api/dogma/getDogmaAttributes';
+import { ApiClient } from '../../../src/core/ApiClient';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+describe('DogmaAttributesApi', () => {
+    const apiClient = new ApiClient('test', 'https://esi.evetech.net/latest');
+    const dogmaAttributesApi = new DogmaAttributesApi(apiClient);
+
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should get attributes', async () => {
+        const mockResponse = [{ attribute_id: 1, name: 'test_attribute' }];
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaAttributesApi.getAttributes());
+        expect(result).toEqual(mockResponse);
+    });
+});

package/tests/tdd/dogma/getDogmaDynamicItemAttributes.test.ts

@@ -0,0 +1,22 @@
+import { DogmaDynamicItemApi } from '../../../src/api/dogma/getDogmaDynamicItemAttributes';
+import { ApiClient } from '../../../src/core/ApiClient';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+describe('DogmaDynamicItemApi', () => {
+    const apiClient = new ApiClient('test', 'https://esi.evetech.net/latest');
+    const dogmaDynamicItemApi = new DogmaDynamicItemApi(apiClient);
+
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should get dynamic item info', async () => {
+        const mockResponse = { item_id: 1, type_id: 1, dogma: [] };
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaDynamicItemApi.getDynamicItemInfo(1, 1));
+        expect(result).toEqual(mockResponse);
+    });
+});

package/tests/tdd/dogma/getDogmaEffectById.test.ts

@@ -0,0 +1,22 @@
+import { DogmaEffectByIdApi } from '../../../src/api/dogma/getDogmaEffectById';
+import { ApiClient } from '../../../src/core/ApiClient';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+describe('DogmaEffectByIdApi', () => {
+    const apiClient = new ApiClient('test', 'https://esi.evetech.net/latest');
+    const dogmaEffectByIdApi = new DogmaEffectByIdApi(apiClient);
+
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should get effect by id', async () => {
+        const mockResponse = { effect_id: 1, name: 'test_effect' };
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaEffectByIdApi.getEffectById(1));
+        expect(result).toEqual(mockResponse);
+    });
+});

package/tests/tdd/dogma/getDogmaEffects.test.ts

@@ -0,0 +1,22 @@
+import { DogmaEffectsApi } from '../../../src/api/dogma/getDogmaEffects';
+import { ApiClient } from '../../../src/core/ApiClient';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+describe('DogmaEffectsApi', () => {
+    const apiClient = new ApiClient('test', 'https://esi.evetech.net/latest');
+    const dogmaEffectsApi = new DogmaEffectsApi(apiClient);
+
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should get effects', async () => {
+        const mockResponse = [{ effect_id: 1, name: 'test_effect' }];
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => dogmaEffectsApi.getEffects());
+        expect(result).toEqual(mockResponse);
+    });
+});

package/tests/tdd/factions/FactionApiBuilder.test.ts

@@ -0,0 +1,17 @@
+import { ApiClient } from '../../../src/core/ApiClient';
+import { FactionAPIBuilder } from '../../../src/builders/FactionApiBuilder';
+import { FactionClient } from '../../../src/clients/FactionClient';
+
+describe('FactionAPIBuilder', () => {
+    let client: ApiClient;
+
+    beforeEach(() => {
+        client = new ApiClient('clientId', 'link', 'authToken');
+    });
+
+    it('should build a FactionClient instance', () => {
+        const builder = new FactionAPIBuilder(client);
+        const factionClient = builder.build();
+        expect(factionClient).toBeInstanceOf(FactionClient);
+    });
+});

package/tests/tdd/factions/FactionClient.test.ts

@@ -0,0 +1,281 @@
+import { FactionClient } from '../../../src/clients/FactionClient';
+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 factionClient = new FactionClient(client);
+
+describe('FactionClient', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for getLeaderboardsCharacters', async () => {
+        const mockResponse = {
+            kills: {
+                yesterday: [{ character_id: 1, amount: 100 }],
+                last_week: [{ character_id: 1, amount: 500 }],
+                total: [{ character_id: 1, amount: 1000 }]
+            },
+            victory_points: {
+                yesterday: [{ character_id: 1, amount: 10 }],
+                last_week: [{ character_id: 1, amount: 50 }],
+                total: [{ character_id: 1, amount: 100 }]
+            }
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => factionClient.getLeaderboardsCharacters());
+
+        expect(result).toHaveProperty('kills');
+        expect(result.kills).toHaveProperty('yesterday');
+        expect(result.kills).toHaveProperty('last_week');
+        expect(result.kills).toHaveProperty('total');
+        expect(result).toHaveProperty('victory_points');
+        expect(result.victory_points).toHaveProperty('yesterday');
+        expect(result.victory_points).toHaveProperty('last_week');
+        expect(result.victory_points).toHaveProperty('total');
+    });
+
+    it('should return valid structure for getLeaderboardsCorporations', async () => {
+        const mockResponse = {
+            kills: {
+                yesterday: [{ corporation_id: 1, amount: 100 }],
+                last_week: [{ corporation_id: 1, amount: 500 }],
+                total: [{ corporation_id: 1, amount: 1000 }]
+            },
+            victory_points: {
+                yesterday: [{ corporation_id: 1, amount: 10 }],
+                last_week: [{ corporation_id: 1, amount: 50 }],
+                total: [{ corporation_id: 1, amount: 100 }]
+            }
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => factionClient.getLeaderboardsCorporations());
+
+        expect(result).toHaveProperty('kills');
+        expect(result.kills).toHaveProperty('yesterday');
+        expect(result.kills).toHaveProperty('last_week');
+        expect(result.kills).toHaveProperty('total');
+        expect(result).toHaveProperty('victory_points');
+        expect(result.victory_points).toHaveProperty('yesterday');
+        expect(result.victory_points).toHaveProperty('last_week');
+        expect(result.victory_points).toHaveProperty('total');
+    });
+
+    it('should return valid structure for getLeaderboardsOverall', async () => {
+        const mockResponse = {
+            kills: {
+                yesterday: [{ faction_id: 1, amount: 100 }],
+                last_week: [{ faction_id: 1, amount: 500 }],
+                total: [{ faction_id: 1, amount: 1000 }]
+            },
+            victory_points: {
+                yesterday: [{ faction_id: 1, amount: 10 }],
+                last_week: [{ faction_id: 1, amount: 50 }],
+                total: [{ faction_id: 1, amount: 100 }]
+            }
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => factionClient.getLeaderboardsOverall());
+
+        expect(result).toHaveProperty('kills');
+        expect(result.kills).toHaveProperty('yesterday');
+        expect(result.kills).toHaveProperty('last_week');
+        expect(result.kills).toHaveProperty('total');
+        expect(result).toHaveProperty('victory_points');
+        expect(result.victory_points).toHaveProperty('yesterday');
+        expect(result.victory_points).toHaveProperty('last_week');
+        expect(result.victory_points).toHaveProperty('total');
+    });
+
+    it('should return valid structure for getStats', async () => {
+        const mockResponse = [
+            {
+                faction_id: 500001,
+                kills: {
+                    last_week: 200,
+                    total: 5000,
+                    yesterday: 50
+                },
+                pilots: 300,
+                victory_points: {
+                    last_week: 1500,
+                    total: 30000,
+                    yesterday: 75
+                }
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => factionClient.getStats());
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((stat: { faction_id: number, kills: { last_week: number, total: number, yesterday: number }, pilots: number, victory_points: { last_week: number, total: number, yesterday: number } }) => {
+            expect(stat).toHaveProperty('faction_id');
+            expect(typeof stat.faction_id).toBe('number');
+            expect(stat).toHaveProperty('kills');
+            expect(stat.kills).toHaveProperty('last_week');
+            expect(typeof stat.kills.last_week).toBe('number');
+            expect(stat.kills).toHaveProperty('total');
+            expect(typeof stat.kills.total).toBe('number');
+            expect(stat.kills).toHaveProperty('yesterday');
+            expect(typeof stat.kills.yesterday).toBe('number');
+            expect(stat).toHaveProperty('pilots');
+            expect(typeof stat.pilots).toBe('number');
+            expect(stat).toHaveProperty('victory_points');
+            expect(stat.victory_points).toHaveProperty('last_week');
+            expect(typeof stat.victory_points.last_week).toBe('number');
+            expect(stat.victory_points).toHaveProperty('total');
+            expect(typeof stat.victory_points.total).toBe('number');
+            expect(stat.victory_points).toHaveProperty('yesterday');
+            expect(typeof stat.victory_points.yesterday).toBe('number');
+        });
+        
+    });
+
+    it('should return valid structure for getCharacterStats', async () => {
+        const mockResponse = {
+            faction_id: 500001,
+            kills: {
+                last_week: 200,
+                total: 5000,
+                yesterday: 50
+            },
+            victory_points: {
+                last_week: 1500,
+                total: 30000,
+                yesterday: 75
+            }
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => factionClient.getCharacterStats(123456789));
+
+        expect(result).toHaveProperty('faction_id');
+        expect(typeof result.faction_id).toBe('number');
+        expect(result).toHaveProperty('kills');
+        expect(result.kills).toHaveProperty('last_week');
+        expect(typeof result.kills.last_week).toBe('number');
+        expect(result.kills).toHaveProperty('total');
+        expect(typeof result.kills.total).toBe('number');
+        expect(result.kills).toHaveProperty('yesterday');
+        expect(typeof result.kills.yesterday).toBe('number');
+        expect(result).toHaveProperty('victory_points');
+        expect(result.victory_points).toHaveProperty('last_week');
+        expect(typeof result.victory_points.last_week).toBe('number');
+        expect(result.victory_points).toHaveProperty('total');
+        expect(typeof result.victory_points.total).toBe('number');
+        expect(result.victory_points).toHaveProperty('yesterday');
+        expect(typeof result.victory_points.yesterday).toBe('number');
+    });
+
+    it('should return valid structure for getCorporationStats', async () => {
+        const mockResponse = {
+            faction_id: 500001,
+            kills: {
+                last_week: 200,
+                total: 5000,
+                yesterday: 50
+            },
+            victory_points: {
+                last_week: 1500,
+                total: 30000,
+                yesterday: 75
+            }
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => factionClient.getCorporationStats(987654321));
+
+        expect(result).toHaveProperty('faction_id');
+        expect(typeof result.faction_id).toBe('number');
+        expect(result).toHaveProperty('kills');
+        expect(result.kills).toHaveProperty('last_week');
+        expect(typeof result.kills.last_week).toBe('number');
+        expect(result.kills).toHaveProperty('total');
+        expect(typeof result.kills.total).toBe('number');
+        expect(result.kills).toHaveProperty('yesterday');
+        expect(typeof result.kills.yesterday).toBe('number');
+        expect(result).toHaveProperty('victory_points');
+        expect(result.victory_points).toHaveProperty('last_week');
+        expect(typeof result.victory_points.last_week).toBe('number');
+        expect(result.victory_points).toHaveProperty('total');
+        expect(typeof result.victory_points.total).toBe('number');
+        expect(result.victory_points).toHaveProperty('yesterday');
+        expect(typeof result.victory_points.yesterday).toBe('number');
+    });
+
+    it('should return valid structure for getSystems', async () => {
+        const mockResponse = [
+            {
+                contested: "uncontested",
+                occupier_faction_id: 500001,
+                owner_faction_id: 500002,
+                solar_system_id: 30002078,
+                victory_points: 20,
+                victory_points_threshold: 3000
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => factionClient.getSystems());
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((system: { contested: string, occupier_faction_id: number, owner_faction_id: number, solar_system_id: number, victory_points: number, victory_points_threshold: number }) => {
+            expect(system).toHaveProperty('contested');
+            expect(typeof system.contested).toBe('string');
+            expect(system).toHaveProperty('occupier_faction_id');
+            expect(typeof system.occupier_faction_id).toBe('number');
+            expect(system).toHaveProperty('owner_faction_id');
+            expect(typeof system.owner_faction_id).toBe('number');
+            expect(system).toHaveProperty('solar_system_id');
+            expect(typeof system.solar_system_id).toBe('number');
+            expect(system).toHaveProperty('victory_points');
+            expect(typeof system.victory_points).toBe('number');
+            expect(system).toHaveProperty('victory_points_threshold');
+            expect(typeof system.victory_points_threshold).toBe('number');
+        });
+        
+    });
+
+    it('should return valid structure for getWars', async () => {
+        const mockResponse = [
+            {
+                against_id: 500002,
+                faction_id: 500001
+            }
+        ];
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        const result = await getBody(() => factionClient.getWars());
+
+        expect(Array.isArray(result)).toBe(true);
+        result.forEach((war: { against_id: number, faction_id: number }) => {
+            expect(war).toHaveProperty('against_id');
+            expect(typeof war.against_id).toBe('number');
+            expect(war).toHaveProperty('faction_id');
+            expect(typeof war.faction_id).toBe('number');
+        });
+        
+    });
+});

package/tests/tdd/factions/getCharacterFactionWarfareStats.test.ts

@@ -0,0 +1,72 @@
+import { GetCharacterFactionWarfareStatsApi } from '../../../src/api/factions/getCharacterFactionWarfareStats';
+import { getClient } from '../../../src/config/jest/jest.setup';
+import fetchMock from 'jest-fetch-mock';
+
+fetchMock.enableMocks();
+
+let getCharacterFactionWarfareStatsApi: GetCharacterFactionWarfareStatsApi;
+
+beforeAll(() => {
+    getCharacterFactionWarfareStatsApi = new GetCharacterFactionWarfareStatsApi(getClient());
+});
+
+describe('GetCharacterFactionWarfareStatsApi', () => {
+    beforeEach(() => {
+        fetchMock.resetMocks();
+    });
+
+    it('should return valid structure for character faction warfare stats', async () => {
+        const mockResponse = {
+            faction_id: 500001,
+            kills: {
+                last_week: 200,
+                total: 5000,
+                yesterday: 50
+            },
+            pilots: 300,
+            victory_points: {
+                last_week: 1500,
+                total: 30000,
+                yesterday: 75
+            }
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify(mockResponse));
+
+        type FactionWarfareStat = {
+            faction_id: number;
+            kills: {
+                last_week: number;
+                total: number;
+                yesterday: number;
+            };
+            pilots: number;
+            victory_points: {
+                last_week: number;
+                total: number;
+                yesterday: number;
+            };
+        };
+
+        const result = await getBody(() => getCharacterFactionWarfareStatsApi.getCharacterStats(123456)) as FactionWarfareStat;
+
+        expect(result).toHaveProperty('faction_id');
+        expect(typeof result.faction_id).toBe('number');
+        expect(result).toHaveProperty('kills');
+        expect(result.kills).toHaveProperty('last_week');
+        expect(typeof result.kills.last_week).toBe('number');
+        expect(result.kills).toHaveProperty('total');
+        expect(typeof result.kills.total).toBe('number');
+        expect(result.kills).toHaveProperty('yesterday');
+        expect(typeof result.kills.yesterday).toBe('number');
+        expect(result).toHaveProperty('pilots');
+        expect(typeof result.pilots).toBe('number');
+        expect(result).toHaveProperty('victory_points');
+        expect(result.victory_points).toHaveProperty('last_week');
+        expect(typeof result.victory_points.last_week).toBe('number');
+        expect(result.victory_points).toHaveProperty('total');
+        expect(typeof result.victory_points.total).toBe('number');
+        expect(result.victory_points).toHaveProperty('yesterday');
+        expect(typeof result.victory_points.yesterday).toBe('number');
+    });
+});