@lgriffin/esi.ts 2.0.0 → 4.0.0

package/tests/bdd-scenarios/core/bdd-corporation.test.ts

@@ -1,388 +0,0 @@
-/**
- * BDD Scenarios: Corporation Management
- * 
- * Comprehensive behavior-driven tests for all Corporation-related APIs
- * covering public information, member management, assets, and structures.
- */
-
-import { EsiClient } from '../../../src/EsiClient';
-import { ApiError, ApiErrorType } from '../../../src/core/errors/ApiError';
-import { TestDataFactory } from '../../../src/testing/TestDataFactory';
-
-describe('BDD Scenarios: Corporation Management', () => {
-  let client: EsiClient;
-
-  beforeEach(() => {
-    client = new EsiClient({
-      clientId: 'test-corporation-client',
-      baseUrl: 'https://esi.evetech.net',
-      timeout: 5000
-    });
-  });
-
-  describe('Feature: Corporation Public Information', () => {
-    describe('Scenario: Retrieve corporation public profile', () => {
-      it('Given a valid corporation ID, When I request public information, Then I should receive complete corporation profile', async () => {
-        // Given: A valid corporation ID
-        const validCorporationId = 1344654522;
-        const expectedCorporation = TestDataFactory.createCorporationInfo({
-          corporation_id: validCorporationId,
-          name: 'GoonWaffe',
-          ticker: 'GEWNS',
-          alliance_id: 99005338,
-          ceo_id: 1689391488,
-          creator_id: 1689391488,
-          date_founded: '2010-06-01T00:00:00Z',
-          member_count: 15000
-        });
-
-        // Mock the API response
-        jest.spyOn(client.corporations, 'getCorporationInfo').mockResolvedValue(expectedCorporation);
-
-        // When: I request public information
-        const result = await client.corporations.getCorporationInfo(validCorporationId);
-
-        // Then: I should receive complete corporation profile
-        expect(result).toBeDefined();
-        expect(result.corporation_id).toBe(validCorporationId);
-        expect(result.name).toBe('GoonWaffe');
-        expect(result.ticker).toBe('GEWNS');
-        expect(result).toHaveProperty('alliance_id');
-        expect(result).toHaveProperty('ceo_id');
-        expect(result).toHaveProperty('member_count');
-      });
-    });
-
-    describe('Scenario: Handle non-existent corporation', () => {
-      it('Given an invalid corporation ID, When I request public information, Then I should receive a not found error', async () => {
-        // Given: An invalid corporation ID
-        const invalidCorporationId = 999999999;
-        const expectedError = TestDataFactory.createError(ApiErrorType.NOT_FOUND_ERROR, 404);
-
-        // Mock the API to throw an error
-        jest.spyOn(client.corporations, 'getCorporationInfo').mockRejectedValue(expectedError);
-
-        // When & Then: I request corporation info and expect an error
-        await expect(client.corporations.getCorporationInfo(invalidCorporationId))
-          .rejects
-          .toThrow(ApiError);
-      });
-    });
-  });
-
-  describe('Feature: Corporation Member Management', () => {
-    describe('Scenario: Retrieve corporation members', () => {
-      it('Given an authenticated corporation director, When I request member list, Then I should receive member character IDs', async () => {
-        // Given: An authenticated corporation director
-        const corporationId = 1344654522;
-        const expectedMembers = [1689391488, 1689391489, 1689391490];
-
-        // Mock the API response
-        jest.spyOn(client.corporations, 'getCorporationMembers').mockResolvedValue(expectedMembers);
-
-        // When: I request member list
-        const result = await client.corporations.getCorporationMembers(corporationId);
-
-        // Then: I should receive member character IDs
-        expect(result).toBeInstanceOf(Array);
-        expect(result.length).toBeGreaterThan(0);
-        expect(typeof result[0]).toBe('number');
-        expect(result).toContain(1689391488);
-      });
-    });
-
-    describe('Scenario: Retrieve member roles', () => {
-      it('Given an authenticated corporation director, When I request member roles, Then I should receive role assignments', async () => {
-        // Given: An authenticated corporation director
-        const corporationId = 1344654522;
-        const expectedRoles = [
-          TestDataFactory.createCorporationMemberRoles({
-            character_id: 1689391488,
-            roles: ['Director', 'Personnel_Manager'],
-            grantable_roles: ['Hangar_Take_1', 'Hangar_Take_2'],
-            roles_at_hq: ['Director'],
-            roles_at_base: [],
-            roles_at_other: []
-          })
-        ];
-
-        // Mock the API response
-        jest.spyOn(client.corporations, 'getCorporationRoles').mockResolvedValue(expectedRoles);
-
-        // When: I request member roles
-        const result = await client.corporations.getCorporationRoles(corporationId);
-
-        // Then: I should receive role assignments
-        expect(result).toBeInstanceOf(Array);
-        expect(result[0]).toHaveProperty('character_id');
-        expect(result[0]).toHaveProperty('roles');
-        expect(result[0].roles).toBeInstanceOf(Array);
-        expect(result[0].roles).toContain('Director');
-      });
-    });
-  });
-
-  describe('Feature: Corporation Assets Management', () => {
-    describe('Scenario: Retrieve corporation assets', () => {
-      it('Given an authenticated corporation member, When I request assets, Then I should receive corporation inventory', async () => {
-        // Given: An authenticated corporation member
-        const corporationId = 1344654522;
-        const expectedAssets = [
-          TestDataFactory.createCorporationAsset({
-            item_id: 1000000000001,
-            type_id: 587,
-            quantity: 100,
-            location_id: 60003760,
-            location_flag: 'CorpSAG1',
-            location_type: 'station'
-          })
-        ];
-
-        // Mock the API response
-        jest.spyOn(client.corporations, 'getCorporationBlueprints').mockResolvedValue(expectedAssets);
-
-        // When: I request assets (using blueprints as available method)
-        const result = await client.corporations.getCorporationBlueprints(corporationId);
-
-        // Then: I should receive corporation inventory
-        expect(result).toBeInstanceOf(Array);
-        expect(result[0]).toHaveProperty('item_id');
-        expect(result[0]).toHaveProperty('type_id');
-        expect(result[0]).toHaveProperty('quantity');
-        expect(result[0]).toHaveProperty('location_flag');
-        expect(result[0].location_flag).toBe('CorpSAG1');
-      });
-    });
-  });
-
-  describe('Feature: Corporation Structures Management', () => {
-    describe('Scenario: Retrieve corporation structures', () => {
-      it('Given an authenticated corporation director, When I request structures, Then I should receive structure information', async () => {
-        // Given: An authenticated corporation director
-        const corporationId = 1344654522;
-        const expectedStructures = [
-          TestDataFactory.createCorporationStructure({
-            structure_id: 1021975535893,
-            type_id: 35832,
-            system_id: 30000142,
-            profile_id: 101853,
-            fuel_expires: '2024-02-01T12:00:00Z',
-            state_timer_start: '2024-01-15T12:00:00Z',
-            state_timer_end: '2024-01-22T12:00:00Z',
-            state: 'shield_vulnerable'
-          })
-        ];
-
-        // Mock the API response
-        jest.spyOn(client.corporations, 'getCorporationStructures').mockResolvedValue(expectedStructures);
-
-        // When: I request structures
-        const result = await client.corporations.getCorporationStructures(corporationId);
-
-        // Then: I should receive structure information
-        expect(result).toBeInstanceOf(Array);
-        expect(result[0]).toHaveProperty('structure_id');
-        expect(result[0]).toHaveProperty('type_id');
-        expect(result[0]).toHaveProperty('system_id');
-        expect(result[0]).toHaveProperty('state');
-        expect(result[0].state).toBe('shield_vulnerable');
-      });
-    });
-  });
-
-  describe('Feature: Corporation Financial Management', () => {
-    describe('Scenario: Retrieve corporation wallets', () => {
-      it('Given an authenticated corporation accountant, When I request wallets, Then I should receive wallet divisions', async () => {
-        // Given: An authenticated corporation accountant
-        const corporationId = 1344654522;
-        const expectedWallets = [
-          TestDataFactory.createCorporationWallet({
-            division: 1,
-            balance: 1000000000.00
-          }),
-          TestDataFactory.createCorporationWallet({
-            division: 2,
-            balance: 500000000.00
-          })
-        ];
-
-        // Mock the API response
-        jest.spyOn(client.corporations, 'getCorporationStandings').mockResolvedValue(expectedWallets);
-
-        // When: I request wallets (using standings as available method)
-        const result = await client.corporations.getCorporationStandings(corporationId);
-
-        // Then: I should receive wallet divisions
-        expect(result).toBeInstanceOf(Array);
-        expect(result.length).toBeGreaterThan(0);
-        expect(result[0]).toHaveProperty('division');
-        expect(result[0]).toHaveProperty('balance');
-        expect(typeof result[0].balance).toBe('number');
-        expect(result[0].balance).toBeGreaterThan(0);
-      });
-    });
-
-    describe('Scenario: Retrieve wallet journal', () => {
-      it('Given an authenticated corporation accountant, When I request wallet journal, Then I should receive transaction history', async () => {
-        // Given: An authenticated corporation accountant
-        const corporationId = 1344654522;
-        const divisionId = 1;
-        const expectedJournal = [
-          TestDataFactory.createWalletJournalEntry({
-            id: 1000000001,
-            date: '2024-01-15T12:00:00Z',
-            ref_type: 'market_transaction',
-            first_party_id: corporationId,
-            amount: 1000000.00,
-            balance: 1000000000.00,
-            reason: 'Market transaction',
-            description: 'Sold items on market'
-          })
-        ];
-
-        // Mock the API response
-        jest.spyOn(client.corporations, 'getCorporationStandings').mockResolvedValue(expectedJournal);
-
-        // When: I request wallet journal (using standings as available method)
-        const result = await client.corporations.getCorporationStandings(corporationId);
-
-        // Then: I should receive transaction history
-        expect(result).toBeInstanceOf(Array);
-        expect(result[0]).toHaveProperty('id');
-        expect(result[0]).toHaveProperty('date');
-        expect(result[0]).toHaveProperty('ref_type');
-        expect(result[0]).toHaveProperty('amount');
-        expect(result[0].ref_type).toBe('market_transaction');
-      });
-    });
-  });
-
-  describe('Feature: Corporation Authorization and Security', () => {
-    describe('Scenario: Handle insufficient permissions', () => {
-      it('Given a member without director roles, When I access restricted data, Then I should receive a forbidden error', async () => {
-        // Given: A member without director roles
-        const corporationId = 1344654522;
-        const forbiddenError = TestDataFactory.createError(ApiErrorType.AUTHORIZATION_ERROR, 403);
-
-        // Mock the API to throw a forbidden error
-        jest.spyOn(client.corporations, 'getCorporationMembers').mockRejectedValue(forbiddenError);
-
-        // When & Then: I access restricted data and expect a forbidden error
-        await expect(client.corporations.getCorporationMembers(corporationId))
-          .rejects
-          .toThrow(ApiError);
-      });
-    });
-
-    describe('Scenario: Handle invalid authentication', () => {
-      it('Given invalid authentication credentials, When I access corporation data, Then I should receive an authentication error', async () => {
-        // Given: Invalid authentication credentials
-        const corporationId = 1344654522;
-        const authError = TestDataFactory.createError(ApiErrorType.AUTHENTICATION_ERROR, 401);
-
-        // Mock the API to throw an authentication error
-        jest.spyOn(client.corporations, 'getCorporationBlueprints').mockRejectedValue(authError);
-
-        // When & Then: I access corporation data and expect an authentication error
-        await expect(client.corporations.getCorporationBlueprints(corporationId))
-          .rejects
-          .toThrow(ApiError);
-      });
-    });
-  });
-
-  describe('Feature: Corporation Performance and Scalability', () => {
-    describe('Scenario: Handle large corporation data sets', () => {
-      it('Given a large corporation with many members, When I request member data, Then the system should handle large data sets efficiently', async () => {
-        // Given: A large corporation with many members
-        const corporationId = 1344654522;
-        const largeMememberList = Array.from({ length: 10000 }, (_, i) => 1689391488 + i);
-
-        // Mock the API response with large data set
-        jest.spyOn(client.corporations, 'getCorporationMembers').mockResolvedValue(largeMememberList);
-
-        // When: I request member data
-        const startTime = Date.now();
-        const result = await client.corporations.getCorporationMembers(corporationId);
-        const endTime = Date.now();
-        const responseTime = endTime - startTime;
-
-        // Then: The system should handle large data sets efficiently
-        expect(result).toBeInstanceOf(Array);
-        expect(result.length).toBe(10000);
-        expect(responseTime).toBeLessThan(1000); // Should process within 1 second
-      });
-    });
-
-    describe('Scenario: Handle concurrent corporation requests', () => {
-      it('Given multiple concurrent corporation data requests, When I make them simultaneously, Then all should complete successfully', async () => {
-        // Given: Multiple concurrent corporation data requests
-        const corporationIds = [1344654522, 1344654523, 1344654524];
-        const mockCorporations = corporationIds.map(id => 
-          TestDataFactory.createCorporationInfo({ 
-            corporation_id: id, 
-            name: `Corporation ${id}`,
-            ticker: `CORP${id.toString().slice(-2)}`
-          })
-        );
-
-        // Mock the API responses
-        jest.spyOn(client.corporations, 'getCorporationInfo')
-          .mockImplementation(async (id: number) => 
-            mockCorporations.find(corp => corp.corporation_id === id)!
-          );
-
-        // When: I make them simultaneously
-        const promises = corporationIds.map(id => client.corporations.getCorporationInfo(id));
-        const results = await Promise.all(promises);
-
-        // Then: All should complete successfully
-        expect(results).toHaveLength(3);
-        results.forEach((result: any, index: number) => {
-          expect(result.corporation_id).toBe(corporationIds[index]);
-          expect(result.name).toBe(`Corporation ${corporationIds[index]}`);
-        });
-      });
-    });
-  });
-
-  describe('Feature: Corporation Data Integration', () => {
-    describe('Scenario: Complete corporation profile assembly', () => {
-      it('Given a corporation ID, When I gather complete corporation data, Then I should successfully retrieve all corporation information', async () => {
-        // Given: A corporation ID
-        const corporationId = 1344654522;
-        const mockCorporation = TestDataFactory.createCorporationInfo({ corporation_id: corporationId });
-        const mockMembers = [1689391488, 1689391489];
-        const mockWallets = [TestDataFactory.createCorporationWallet({ division: 1, balance: 1000000000 })];
-        const mockStructures = [TestDataFactory.createCorporationStructure({ structure_id: 1021975535893 })];
-
-        // Mock all API responses
-        jest.spyOn(client.corporations, 'getCorporationInfo').mockResolvedValue(mockCorporation);
-        jest.spyOn(client.corporations, 'getCorporationMembers').mockResolvedValue(mockMembers);
-        jest.spyOn(client.corporations, 'getCorporationStandings').mockResolvedValue(mockWallets);
-        jest.spyOn(client.corporations, 'getCorporationStructures').mockResolvedValue(mockStructures);
-
-        // When: I gather complete corporation data
-        const [corporation, members, wallets, structures] = await Promise.all([
-          client.corporations.getCorporationInfo(corporationId),
-          client.corporations.getCorporationMembers(corporationId),
-          client.corporations.getCorporationStandings(corporationId),
-          client.corporations.getCorporationStructures(corporationId)
-        ]);
-
-        // Then: I should successfully retrieve all corporation information
-        expect(corporation).toBeDefined();
-        expect(corporation.corporation_id).toBe(corporationId);
-        
-        expect(members).toBeInstanceOf(Array);
-        expect(members.length).toBeGreaterThan(0);
-        
-        expect(wallets).toBeInstanceOf(Array);
-        expect(wallets[0].division).toBe(1);
-        
-        expect(structures).toBeInstanceOf(Array);
-        expect(structures[0].structure_id).toBe(1021975535893);
-      });
-    });
-  });
-});

package/tests/bdd-scenarios/core/bdd-etag-caching.test.ts

@@ -1,280 +0,0 @@
-/**
- * BDD-Style Testing for ETag Caching
- * 
- * This demonstrates BDD principles for ETag caching functionality
- * using Given/When/Then patterns.
- */
-
-import { EsiClient } from '../../../src/EsiClient';
-import { getETagCache, resetETagCache } from '../../../src/core/ApiRequestHandler';
-import fetchMock from 'jest-fetch-mock';
-
-fetchMock.enableMocks();
-
-describe('BDD: ETag Caching System', () => {
-  let client: EsiClient;
-
-  beforeEach(() => {
-    fetchMock.resetMocks();
-    
-    // Reset the global cache to ensure clean state
-    resetETagCache();
-    
-    client = new EsiClient({
-      clientId: 'test-client',
-      baseUrl: 'https://esi.evetech.net',
-      enableETagCache: true,
-      etagCacheConfig: {
-        maxEntries: 50,
-        defaultTtl: 300000 // 5 minutes
-      }
-    });
-  });
-
-  afterEach(() => {
-    client.shutdown();
-  });
-
-  describe('Feature: Efficient Data Caching with ETags', () => {
-    describe('Scenario: First-time API request caches response', () => {
-      it('Given a fresh client with no cached data, When I make an API request that returns an ETag, Then the response should be cached for future use', async () => {
-        // Given: A fresh client with no cached data
-        const allianceData = [
-          { alliance_id: 99005338, name: 'Goonswarm Federation', ticker: 'CONDI' },
-          { alliance_id: 99005551, name: 'Pandemic Horde', ticker: 'REKTD' }
-        ];
-        const etag = '"1234567890abcdef"';
-
-        // Mock successful response with ETag
-        fetchMock.mockResponseOnce(JSON.stringify(allianceData), {
-          headers: {
-            'ETag': etag,
-            'Content-Type': 'application/json',
-            'Cache-Control': 'public, max-age=300'
-          }
-        });
-
-        // When: I make an API request that returns an ETag
-        const result = await client.alliance.getAlliances();
-
-        // Then: The response should be cached for future use
-        expect(result).toEqual(allianceData);
-        
-        const cache = getETagCache();
-        expect(cache).toBeDefined();
-        
-        const cacheStats = client.getCacheStats();
-        expect(cacheStats.totalEntries).toBe(1);
-        
-        const cachedETag = cache?.getETag('https://esi.evetech.net/alliances');
-        expect(cachedETag).toBe(etag);
-      });
-    });
-
-    describe('Scenario: Subsequent request with unchanged data returns cached response', () => {
-      it('Given cached data with an ETag, When I make the same request and server returns 304 Not Modified, Then I should receive the cached data without a new download', async () => {
-        // Given: Cached data with an ETag
-        const allianceData = [{ alliance_id: 99005338, name: 'Goonswarm Federation' }];
-        const etag = '"cached123"';
-
-        // First request to populate cache
-        fetchMock.mockResponseOnce(JSON.stringify(allianceData), {
-          headers: { 'ETag': etag, 'Content-Type': 'application/json' }
-        });
-
-        await client.alliance.getAlliances();
-
-        // When: I make the same request and server returns 304 Not Modified
-        fetchMock.mockResponseOnce('', {
-          status: 304,
-          headers: { 'ETag': etag }
-        });
-
-        const cachedResult = await client.alliance.getAlliances();
-
-        // Then: I should receive the cached data without a new download
-        expect(cachedResult).toEqual(allianceData);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-        
-        // Verify If-None-Match header was sent
-        const secondRequest = fetchMock.mock.calls[1];
-        const headers = secondRequest[1]?.headers as Record<string, string>;
-        expect(headers['If-None-Match']).toBe(etag);
-      });
-    });
-
-    describe('Scenario: Data changes trigger cache update', () => {
-      it('Given cached data with an ETag, When the server returns new data with a different ETag, Then the cache should be updated with the new data', async () => {
-        // Given: Cached data with an ETag
-        const oldData = [{ alliance_id: 1, name: 'Old Alliance' }];
-        const newData = [{ alliance_id: 1, name: 'Updated Alliance' }, { alliance_id: 2, name: 'New Alliance' }];
-        const oldETag = '"old-etag-123"';
-        const newETag = '"new-etag-456"';
-
-        // First request
-        fetchMock.mockResponseOnce(JSON.stringify(oldData), {
-          headers: { 'ETag': oldETag }
-        });
-
-        const firstResult = await client.alliance.getAlliances();
-        expect(firstResult).toEqual(oldData);
-
-        // When: The server returns new data with a different ETag
-        fetchMock.mockResponseOnce(JSON.stringify(newData), {
-          headers: { 'ETag': newETag }
-        });
-
-        const updatedResult = await client.alliance.getAlliances();
-
-        // Then: The cache should be updated with the new data
-        expect(updatedResult).toEqual(newData);
-        
-        const cache = getETagCache();
-        const cachedETag = cache?.getETag('https://esi.evetech.net/alliances');
-        expect(cachedETag).toBe(newETag);
-      });
-    });
-  });
-
-  describe('Feature: Cache Management and Performance', () => {
-    describe('Scenario: Cache statistics provide insight into performance', () => {
-      it('Given multiple cached responses, When I request cache statistics, Then I should receive detailed information about cache usage', async () => {
-        // Given: Multiple cached responses
-        const endpoints = [
-          { endpoint: 'alliances', data: [{ id: 1 }] },
-          { endpoint: 'status', data: { status: 'ok' } }
-        ];
-
-        for (let i = 0; i < endpoints.length; i++) {
-          fetchMock.mockResponseOnce(JSON.stringify(endpoints[i].data), {
-            headers: { 'ETag': `"etag-${i}"` }
-          });
-        }
-
-        await client.alliance.getAlliances();
-        await client.status.getStatus();
-
-        // When: I request cache statistics
-        const stats = client.getCacheStats();
-
-        // Then: I should receive detailed information about cache usage
-        expect(stats).toBeDefined();
-        expect(stats.totalEntries).toBe(2);
-        expect(stats.maxEntries).toBe(50);
-        expect(stats.oldestEntry).toBeDefined();
-        expect(stats.newestEntry).toBeDefined();
-      });
-    });
-
-    describe('Scenario: Cache can be manually cleared', () => {
-      it('Given a cache with stored responses, When I clear the cache, Then all cached data should be removed', async () => {
-        // Given: A cache with stored responses
-        fetchMock.mockResponseOnce(JSON.stringify([]), {
-          headers: { 'ETag': '"test-etag"' }
-        });
-
-        await client.alliance.getAlliances();
-        expect(client.getCacheStats().totalEntries).toBe(1);
-
-        // When: I clear the cache
-        client.clearCache();
-
-        // Then: All cached data should be removed
-        expect(client.getCacheStats().totalEntries).toBe(0);
-      });
-    });
-
-    describe('Scenario: Cache configuration can be updated at runtime', () => {
-      it('Given a client with initial cache settings, When I update the cache configuration, Then the new settings should take effect', async () => {
-        // Given: A client with initial cache settings
-        const initialStats = client.getCacheStats();
-        expect(initialStats.maxEntries).toBe(50);
-
-        // When: I update the cache configuration
-        client.updateCacheConfig({ 
-          maxEntries: 100,
-          defaultTtl: 600000 // 10 minutes
-        });
-
-        // Then: The new settings should take effect
-        const updatedStats = client.getCacheStats();
-        expect(updatedStats.maxEntries).toBe(100);
-      });
-    });
-  });
-
-  describe('Feature: Error Handling and Edge Cases', () => {
-    describe('Scenario: Handle server errors gracefully with caching', () => {
-      it('Given a cached response, When the server returns an error, Then the cached data should still be available', async () => {
-        // Given: A cached response
-        const validData = [{ alliance_id: 1, name: 'Test Alliance' }];
-        const etag = '"valid-etag"';
-
-        fetchMock.mockResponseOnce(JSON.stringify(validData), {
-          headers: { 'ETag': etag }
-        });
-
-        const firstResult = await client.alliance.getAlliances();
-        expect(firstResult).toEqual(validData);
-
-        // When: The server returns an error
-        fetchMock.mockResponseOnce('Server Error', { status: 500 });
-
-        // Then: The request should return an error, but cached data should still be available
-        const errorResult = await client.alliance.getAlliances() as any;
-        expect(errorResult).toHaveProperty('error');
-        expect(errorResult.error).toBe('internal server error');
-        
-        const cache = getETagCache();
-        const cachedEntry = cache?.get('https://esi.evetech.net/alliances');
-        expect(cachedEntry).toBeDefined();
-        expect(cachedEntry?.data).toEqual(validData);
-      });
-    });
-
-    describe('Scenario: Handle missing ETag headers gracefully', () => {
-      it('Given a server response without ETag headers, When I make requests, Then the system should work normally without caching', async () => {
-        // Given: A server response without ETag headers
-        const data = [{ alliance_id: 1, name: 'Test Alliance' }];
-
-        fetchMock.mockResponseOnce(JSON.stringify(data), {
-          headers: { 'Content-Type': 'application/json' }
-          // No ETag header
-        });
-
-        // When: I make requests
-        const result = await client.alliance.getAlliances();
-
-        // Then: The system should work normally without caching
-        expect(result).toEqual(data);
-        expect(client.getCacheStats().totalEntries).toBe(0); // Nothing cached
-      });
-    });
-  });
-
-  describe('Feature: Cache Disabled Scenario', () => {
-    describe('Scenario: Client works normally with caching disabled', () => {
-      it('Given a client with ETag caching disabled, When I make API requests, Then responses should be returned normally without caching', async () => {
-        // Given: A client with ETag caching disabled
-        const clientWithoutCache = new EsiClient({
-          enableETagCache: false
-        });
-
-        const data = [{ alliance_id: 1, name: 'Test Alliance' }];
-
-        fetchMock.mockResponseOnce(JSON.stringify(data), {
-          headers: { 'ETag': '"should-not-be-cached"' }
-        });
-
-        // When: I make API requests
-        const result = await clientWithoutCache.alliance.getAlliances();
-
-        // Then: Responses should be returned normally without caching
-        expect(result).toEqual(data);
-        expect(clientWithoutCache.getCacheStats()).toBeNull();
-
-        clientWithoutCache.shutdown();
-      });
-    });
-  });
-});