@lgriffin/esi.ts 1.0.0 → 2.0.0

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

@@ -0,0 +1,388 @@
+/**
+ * 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

@@ -0,0 +1,280 @@
+/**
+ * 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();
+      });
+    });
+  });
+});