@lgriffin/esi.ts 1.0.0 → 2.0.0

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

@@ -0,0 +1,346 @@
+/**
+ * BDD Scenarios: Character Management
+ * 
+ * Comprehensive behavior-driven tests for Character-related APIs
+ * covering public information, portraits, roles, and other available endpoints.
+ */
+
+import { EsiClient } from '../../../src/EsiClient';
+import { ApiError, ApiErrorType } from '../../../src/core/errors/ApiError';
+import { TestDataFactory } from '../../../src/testing/TestDataFactory';
+
+describe('BDD Scenarios: Character Management', () => {
+  let client: EsiClient;
+
+  beforeEach(() => {
+    client = new EsiClient({
+      clientId: 'test-character-client',
+      baseUrl: 'https://esi.evetech.net',
+      timeout: 5000
+    });
+  });
+
+  describe('Feature: Character Public Information', () => {
+    describe('Scenario: Retrieve character public profile', () => {
+      it('Given a valid character ID, When I request public information, Then I should receive complete character profile', async () => {
+        // Given: A valid character ID
+        const validCharacterId = 1689391488;
+        const expectedCharacter = TestDataFactory.createCharacterInfo({
+          character_id: validCharacterId,
+          name: 'Test Character',
+          corporation_id: 1344654522,
+          alliance_id: 99005338
+        });
+
+        // Mock the API response
+        jest.spyOn(client.characters, 'getCharacterPublicInfo').mockResolvedValue(expectedCharacter);
+
+        // When: I request public information
+        const result = await client.characters.getCharacterPublicInfo(validCharacterId);
+
+        // Then: I should receive complete character profile
+        expect(result).toBeDefined();
+        expect(result.character_id).toBe(validCharacterId);
+        expect(result.name).toBe('Test Character');
+        expect(result).toHaveProperty('corporation_id');
+        expect(result).toHaveProperty('alliance_id');
+        expect(result).toHaveProperty('birthday');
+      });
+    });
+
+    describe('Scenario: Handle non-existent character', () => {
+      it('Given an invalid character ID, When I request public information, Then I should receive a not found error', async () => {
+        // Given: An invalid character ID
+        const invalidCharacterId = 999999999;
+        const expectedError = TestDataFactory.createError(ApiErrorType.NOT_FOUND_ERROR, 404);
+
+        // Mock the API to throw an error
+        jest.spyOn(client.characters, 'getCharacterPublicInfo').mockRejectedValue(expectedError);
+
+        // When & Then: I request character info and expect an error
+        await expect(client.characters.getCharacterPublicInfo(invalidCharacterId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+  });
+
+  describe('Feature: Character Portrait Management', () => {
+    describe('Scenario: Retrieve character portraits', () => {
+      it('Given a valid character ID, When I request portraits, Then I should receive image URLs in different sizes', async () => {
+        // Given: A valid character ID
+        const characterId = 1689391488;
+        const expectedPortrait = TestDataFactory.createCharacterPortrait();
+
+        // Mock the API response
+        jest.spyOn(client.characters, 'getCharacterPortrait').mockResolvedValue(expectedPortrait);
+
+        // When: I request portraits
+        const result = await client.characters.getCharacterPortrait(characterId);
+
+        // Then: I should receive image URLs in different sizes
+        expect(result).toBeDefined();
+        expect(result).toHaveProperty('px64x64');
+        expect(result).toHaveProperty('px128x128');
+        expect(result).toHaveProperty('px256x256');
+        expect(result).toHaveProperty('px512x512');
+      });
+    });
+  });
+
+  describe('Feature: Character Roles and Permissions', () => {
+    describe('Scenario: Retrieve character roles', () => {
+      it('Given an authenticated character, When I request roles, Then I should receive role information', async () => {
+        // Given: An authenticated character
+        const characterId = 1689391488;
+        const expectedRoles = TestDataFactory.createCharacterRoles({
+          roles: ['Director', 'Personnel_Manager'],
+          roles_at_base: ['Station_Manager'],
+          roles_at_hq: ['Director'],
+          roles_at_other: []
+        });
+
+        // Mock the API response
+        jest.spyOn(client.characters, 'getCharacterRoles').mockResolvedValue(expectedRoles);
+
+        // When: I request roles
+        const result = await client.characters.getCharacterRoles(characterId);
+
+        // Then: I should receive role information
+        expect(result).toBeDefined();
+        expect(result).toHaveProperty('roles');
+        expect(result.roles).toBeInstanceOf(Array);
+        expect(result.roles).toContain('Director');
+        expect(result.roles).toContain('Personnel_Manager');
+      });
+    });
+  });
+
+  describe('Feature: Character History and Records', () => {
+    describe('Scenario: Retrieve corporation history', () => {
+      it('Given a character ID, When I request corporation history, Then I should receive employment history', async () => {
+        // Given: A character ID
+        const characterId = 1689391488;
+        const expectedHistory = [
+          TestDataFactory.createCorporationHistoryEntry({
+            corporation_id: 1344654522,
+            is_deleted: false,
+            record_id: 1,
+            start_date: '2020-01-01T00:00:00Z'
+          }),
+          TestDataFactory.createCorporationHistoryEntry({
+            corporation_id: 1000001,
+            is_deleted: false,
+            record_id: 2,
+            start_date: '2015-01-01T00:00:00Z'
+          })
+        ];
+
+        // Mock the API response
+        jest.spyOn(client.characters, 'getCharacterCorporationHistory').mockResolvedValue(expectedHistory);
+
+        // When: I request corporation history
+        const result = await client.characters.getCharacterCorporationHistory(characterId);
+
+        // Then: I should receive employment history
+        expect(result).toBeInstanceOf(Array);
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0]).toHaveProperty('corporation_id');
+        expect(result[0]).toHaveProperty('start_date');
+        expect(result[0]).toHaveProperty('record_id');
+      });
+    });
+
+    describe('Scenario: Retrieve character medals', () => {
+      it('Given a character ID, When I request medals, Then I should receive medal information', async () => {
+        // Given: A character ID
+        const characterId = 1689391488;
+        const expectedMedals = [
+          TestDataFactory.createCharacterMedal({
+            medal_id: 1,
+            title: 'Test Medal',
+            description: 'A test medal for demonstration',
+            corporation_id: 1344654522,
+            date: '2023-01-01T00:00:00Z',
+            issuer_id: 1689391489,
+            reason: 'Outstanding service'
+          })
+        ];
+
+        // Mock the API response
+        jest.spyOn(client.characters, 'getCharacterMedals').mockResolvedValue(expectedMedals);
+
+        // When: I request medals
+        const result = await client.characters.getCharacterMedals(characterId);
+
+        // Then: I should receive medal information
+        expect(result).toBeInstanceOf(Array);
+        expect(result[0]).toHaveProperty('medal_id');
+        expect(result[0]).toHaveProperty('title');
+        expect(result[0]).toHaveProperty('description');
+        expect(result[0]).toHaveProperty('date');
+      });
+    });
+  });
+
+  describe('Feature: Character Notifications', () => {
+    describe('Scenario: Retrieve character notifications', () => {
+      it('Given an authenticated character, When I request notifications, Then I should receive notification list', async () => {
+        // Given: An authenticated character
+        const characterId = 1689391488;
+        const expectedNotifications = [
+          TestDataFactory.createCharacterNotification({
+            notification_id: 1000001,
+            sender_id: 1689391489,
+            sender_type: 'character',
+            text: 'Test notification',
+            timestamp: '2024-01-15T12:00:00Z',
+            type: 'AllWarDeclaredMsg',
+            is_read: false
+          })
+        ];
+
+        // Mock the API response
+        jest.spyOn(client.characters, 'getCharacterNotifications').mockResolvedValue(expectedNotifications);
+
+        // When: I request notifications
+        const result = await client.characters.getCharacterNotifications(characterId);
+
+        // Then: I should receive notification list
+        expect(result).toBeInstanceOf(Array);
+        expect(result[0]).toHaveProperty('notification_id');
+        expect(result[0]).toHaveProperty('sender_id');
+        expect(result[0]).toHaveProperty('type');
+        expect(result[0]).toHaveProperty('timestamp');
+      });
+    });
+  });
+
+  describe('Feature: Character Authentication and Authorization', () => {
+    describe('Scenario: Handle unauthorized access', () => {
+      it('Given an unauthenticated request, When I access private data, Then I should receive an authorization error', async () => {
+        // Given: An unauthenticated request
+        const characterId = 1689391488;
+        const authError = TestDataFactory.createError(ApiErrorType.AUTHORIZATION_ERROR, 403);
+
+        // Mock the API to throw an authorization error
+        jest.spyOn(client.characters, 'getCharacterRoles').mockRejectedValue(authError);
+
+        // When & Then: I access private data and expect an authorization error
+        await expect(client.characters.getCharacterRoles(characterId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+
+    describe('Scenario: Handle expired authentication', () => {
+      it('Given an expired token, When I access private data, Then I should receive an authentication error', async () => {
+        // Given: An expired token
+        const characterId = 1689391488;
+        const authError = TestDataFactory.createError(ApiErrorType.AUTHENTICATION_ERROR, 401);
+
+        // Mock the API to throw an authentication error
+        jest.spyOn(client.characters, 'getCharacterNotifications').mockRejectedValue(authError);
+
+        // When & Then: I access private data and expect an authentication error
+        await expect(client.characters.getCharacterNotifications(characterId))
+          .rejects
+          .toThrow(ApiError);
+      });
+    });
+  });
+
+  describe('Feature: Character Performance and Reliability', () => {
+    describe('Scenario: Handle high-frequency character requests', () => {
+      it('Given multiple concurrent character requests, When I make them simultaneously, Then all should complete successfully', async () => {
+        // Given: Multiple concurrent character requests
+        const characterIds = [1689391488, 1689391489, 1689391490];
+        const mockCharacters = characterIds.map(id => 
+          TestDataFactory.createCharacterInfo({ character_id: id, name: `Character ${id}` })
+        );
+
+        // Mock the API responses
+        jest.spyOn(client.characters, 'getCharacterPublicInfo')
+          .mockImplementation(async (id: number) => 
+            mockCharacters.find(char => char.character_id === id)!
+          );
+
+        // When: I make them simultaneously
+        const promises = characterIds.map(id => client.characters.getCharacterPublicInfo(id));
+        const results = await Promise.all(promises);
+
+        // Then: All should complete successfully
+        expect(results).toHaveLength(3);
+        results.forEach((result: any, index: number) => {
+          expect(result.character_id).toBe(characterIds[index]);
+          expect(result.name).toBe(`Character ${characterIds[index]}`);
+        });
+      });
+    });
+
+    describe('Scenario: Measure character API response times', () => {
+      it('Given normal API conditions, When I request character data, Then response should be within acceptable limits', async () => {
+        // Given: Normal API conditions
+        const characterId = 1689391488;
+        const mockCharacter = TestDataFactory.createCharacterInfo({ character_id: characterId });
+
+        // Mock with simulated network delay
+        jest.spyOn(client.characters, 'getCharacterPublicInfo').mockImplementation(async () => {
+          await new Promise(resolve => setTimeout(resolve, 150)); // 150ms delay
+          return mockCharacter;
+        });
+
+        // When: I request character data and measure time
+        const startTime = Date.now();
+        const result = await client.characters.getCharacterPublicInfo(characterId);
+        const endTime = Date.now();
+        const responseTime = endTime - startTime;
+
+        // Then: Response should be within acceptable limits
+        expect(result).toBeDefined();
+        expect(responseTime).toBeLessThan(5000); // Should complete within 5 seconds
+        expect(responseTime).toBeGreaterThan(100); // Should take at least 100ms (due to mock delay)
+      });
+    });
+  });
+
+  describe('Feature: Character Data Integration', () => {
+    describe('Scenario: Complete character profile assembly', () => {
+      it('Given a character ID, When I gather complete profile data, Then I should successfully retrieve all available character information', async () => {
+        // Given: A character ID
+        const characterId = 1689391488;
+        const mockCharacter = TestDataFactory.createCharacterInfo({ character_id: characterId });
+        const mockPortrait = TestDataFactory.createCharacterPortrait();
+        const mockRoles = TestDataFactory.createCharacterRoles({ roles: ['Director'] });
+        const mockNotifications = [TestDataFactory.createCharacterNotification({ notification_id: 1000001 })];
+
+        // Mock all API responses
+        jest.spyOn(client.characters, 'getCharacterPublicInfo').mockResolvedValue(mockCharacter);
+        jest.spyOn(client.characters, 'getCharacterPortrait').mockResolvedValue(mockPortrait);
+        jest.spyOn(client.characters, 'getCharacterRoles').mockResolvedValue(mockRoles);
+        jest.spyOn(client.characters, 'getCharacterNotifications').mockResolvedValue(mockNotifications);
+
+        // When: I gather complete profile data
+        const [character, portrait, roles, notifications] = await Promise.all([
+          client.characters.getCharacterPublicInfo(characterId),
+          client.characters.getCharacterPortrait(characterId),
+          client.characters.getCharacterRoles(characterId),
+          client.characters.getCharacterNotifications(characterId)
+        ]);
+
+        // Then: I should successfully retrieve all available character information
+        expect(character).toBeDefined();
+        expect(character.character_id).toBe(characterId);
+        
+        expect(portrait).toBeDefined();
+        expect(portrait.px64x64).toBeDefined();
+        
+        expect(roles).toBeDefined();
+        expect(roles.roles).toContain('Director');
+        
+        expect(notifications).toBeInstanceOf(Array);
+        expect(notifications[0].notification_id).toBe(1000001);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,159 @@
+/**
+ * BDD-Style Testing for Clones API (Jump Clone Activation)
+ * 
+ * This demonstrates BDD principles for the Clones API jump activation
+ * using Given/When/Then patterns.
+ */
+
+import { EsiClient } from '../../../src/EsiClient';
+import { ApiError, ApiErrorType } from '../../../src/core/errors/ApiError';
+
+describe('BDD: Clone Management', () => {
+  let client: EsiClient;
+
+  beforeEach(() => {
+    client = new EsiClient({
+      clientId: 'test-client',
+      baseUrl: 'https://esi.evetech.net',
+      accessToken: 'mock-access-token',
+      timeout: 5000
+    });
+  });
+
+  describe('Feature: Jump Clone Activation', () => {
+    describe('Scenario: Activate a valid jump clone', () => {
+      it('Given a valid character with available jump clones, When I activate a specific jump clone, Then the jump should be successful', async () => {
+        // Given: A valid character with available jump clones
+        const characterId = 90000001;
+        const jumpCloneId = 12345;
+        const expectedResponse = {
+          success: true,
+          jump_clone_id: jumpCloneId,
+          location_id: 60003760,
+          location_name: 'Jita IV - Moon 4 - Caldari Navy Assembly Plant'
+        };
+
+        // Mock the API response
+        jest.spyOn(client.clones, 'activateJumpClone').mockResolvedValue(expectedResponse);
+
+        // When: I activate a specific jump clone
+        const result = await client.clones.activateJumpClone(characterId, jumpCloneId);
+
+        // Then: The jump should be successful
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.jump_clone_id).toBe(jumpCloneId);
+        expect(result).toHaveProperty('location_id');
+        expect(result).toHaveProperty('location_name');
+      });
+    });
+
+    describe('Scenario: Handle jump clone cooldown', () => {
+      it('Given a character with jump clone cooldown active, When I attempt to activate a jump clone, Then I should receive a cooldown error', async () => {
+        // Given: A character with jump clone cooldown active
+        const characterId = 90000001;
+        const jumpCloneId = 12345;
+        const cooldownError = new ApiError('Jump clone cooldown active', ApiErrorType.RATE_LIMIT_ERROR, 429);
+
+        // Mock the API error
+        jest.spyOn(client.clones, 'activateJumpClone').mockRejectedValue(cooldownError);
+
+        // When & Then: I attempt to activate and should receive an error
+        await expect(client.clones.activateJumpClone(characterId, jumpCloneId)).rejects.toThrow('Jump clone cooldown active');
+      });
+    });
+
+    describe('Scenario: Handle non-existent jump clone', () => {
+      it('Given a non-existent jump clone ID, When I attempt to activate it, Then I should receive a not found error', async () => {
+        // Given: A non-existent jump clone ID
+        const characterId = 90000001;
+        const invalidJumpCloneId = 99999999;
+        const notFoundError = new ApiError('Jump clone not found', ApiErrorType.NOT_FOUND_ERROR, 404);
+
+        // Mock the API error
+        jest.spyOn(client.clones, 'activateJumpClone').mockRejectedValue(notFoundError);
+
+        // When & Then: I attempt to activate and should receive an error
+        await expect(client.clones.activateJumpClone(characterId, invalidJumpCloneId)).rejects.toThrow('Jump clone not found');
+      });
+    });
+
+    describe('Scenario: Handle character in space', () => {
+      it('Given a character currently in space, When I attempt to activate a jump clone, Then I should receive an invalid location error', async () => {
+        // Given: A character currently in space
+        const characterId = 90000001;
+        const jumpCloneId = 12345;
+        const locationError = new ApiError('Cannot jump clone while in space', ApiErrorType.CLIENT_ERROR, 400);
+
+        // Mock the API error
+        jest.spyOn(client.clones, 'activateJumpClone').mockRejectedValue(locationError);
+
+        // When & Then: I attempt to activate and should receive an error
+        await expect(client.clones.activateJumpClone(characterId, jumpCloneId)).rejects.toThrow('Cannot jump clone while in space');
+      });
+    });
+  });
+
+  describe('Feature: Authentication and Authorization', () => {
+    describe('Scenario: Verify proper character ownership', () => {
+      it('Given a character ID that I do not own, When I attempt to activate their jump clone, Then I should receive an unauthorized error', async () => {
+        // Given: A character ID that I do not own
+        const unauthorizedCharacterId = 90000002;
+        const jumpCloneId = 12345;
+        const unauthorizedError = new ApiError('Character not owned by token', ApiErrorType.AUTHORIZATION_ERROR, 403);
+
+        // Mock the API error
+        jest.spyOn(client.clones, 'activateJumpClone').mockRejectedValue(unauthorizedError);
+
+        // When & Then: I attempt to activate and should receive an error
+        await expect(client.clones.activateJumpClone(unauthorizedCharacterId, jumpCloneId)).rejects.toThrow('Character not owned by token');
+      });
+    });
+
+    describe('Scenario: Verify required scopes', () => {
+      it('Given an access token without required scopes, When I attempt to activate a jump clone, Then I should receive a scope error', async () => {
+        // Given: An access token without required scopes
+        const characterId = 90000001;
+        const jumpCloneId = 12345;
+        const scopeError = new ApiError('Required scope missing: esi-clones.jump_clones.v1', ApiErrorType.AUTHORIZATION_ERROR, 403);
+
+        // Mock the API error
+        jest.spyOn(client.clones, 'activateJumpClone').mockRejectedValue(scopeError);
+
+        // When & Then: I attempt to activate and should receive an error
+        await expect(client.clones.activateJumpClone(characterId, jumpCloneId)).rejects.toThrow('Required scope missing: esi-clones.jump_clones.v1');
+      });
+    });
+  });
+
+  describe('Feature: Jump Clone Workflow', () => {
+    describe('Scenario: Complete jump clone workflow', () => {
+      it('Given a character with multiple jump clones, When I list clones and then activate one, Then the workflow should complete successfully', async () => {
+        // Given: A character with multiple jump clones
+        const characterId = 90000001;
+        const availableClones = [
+          { jump_clone_id: 12345, location_id: 60003760, name: 'Jita Clone' },
+          { jump_clone_id: 12346, location_id: 60008494, name: 'Amarr Clone' }
+        ];
+        const selectedCloneId = 12345;
+        const activationResponse = { success: true, jump_clone_id: selectedCloneId };
+
+        // Mock both API responses
+        jest.spyOn(client.clones, 'getClones').mockResolvedValue({ jump_clones: availableClones });
+        jest.spyOn(client.clones, 'activateJumpClone').mockResolvedValue(activationResponse);
+
+        // When: I list clones and then activate one
+        const clones = await client.clones.getClones(characterId);
+        const selectedClone = clones.jump_clones.find((clone: any) => clone.jump_clone_id === selectedCloneId);
+        const result = await client.clones.activateJumpClone(characterId, selectedCloneId);
+
+        // Then: The workflow should complete successfully
+        expect(clones.jump_clones).toHaveLength(2);
+        expect(selectedClone).toBeDefined();
+        expect(selectedClone.name).toBe('Jita Clone');
+        expect(result.success).toBe(true);
+        expect(result.jump_clone_id).toBe(selectedCloneId);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,136 @@
+/**
+ * BDD-Style Testing for Corporation Projects API
+ * 
+ * This demonstrates BDD principles for the Corporation Projects API
+ * using Given/When/Then patterns.
+ */
+
+import { EsiClient } from '../../../src/EsiClient';
+import { ApiError, ApiErrorType } from '../../../src/core/errors/ApiError';
+
+describe('BDD: Corporation Projects Management', () => {
+  let client: EsiClient;
+
+  beforeEach(() => {
+    client = new EsiClient({
+      clientId: 'test-client',
+      baseUrl: 'https://esi.evetech.net',
+      accessToken: 'mock-access-token',
+      timeout: 5000
+    });
+  });
+
+  describe('Feature: Retrieve Corporation Projects', () => {
+    describe('Scenario: Get projects for a valid corporation', () => {
+      it('Given a valid corporation ID and proper authentication, When I request corporation projects, Then I should receive a list of active projects', async () => {
+        // Given: A valid corporation ID and proper authentication
+        const corporationId = 98000001;
+        const expectedProjects = [
+          {
+            project_id: 1,
+            name: 'Mining Operation Alpha',
+            description: 'Large-scale mining operation in nullsec',
+            status: 'active',
+            created_date: '2024-01-15T10:00:00Z',
+            completion_date: null,
+            participants: 15
+          },
+          {
+            project_id: 2,
+            name: 'Defense Infrastructure',
+            description: 'Establishing defensive structures',
+            status: 'in_progress',
+            created_date: '2024-01-10T14:30:00Z',
+            completion_date: null,
+            participants: 8
+          }
+        ];
+
+        // Mock the API response
+        jest.spyOn(client.corporations, 'getCorporationProjects').mockResolvedValue(expectedProjects);
+
+        // When: I request corporation projects
+        const result = await client.corporations.getCorporationProjects(corporationId);
+
+        // Then: I should receive a list of active projects
+        expect(result).toBeDefined();
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toHaveProperty('project_id');
+        expect(result[0]).toHaveProperty('name');
+        expect(result[0]).toHaveProperty('status');
+        expect(result[0].name).toBe('Mining Operation Alpha');
+        expect(result[1].name).toBe('Defense Infrastructure');
+      });
+    });
+
+    describe('Scenario: Handle corporation with no projects', () => {
+      it('Given a corporation with no active projects, When I request corporation projects, Then I should receive an empty list', async () => {
+        // Given: A corporation with no active projects
+        const corporationId = 98000002;
+        const expectedProjects: any[] = [];
+
+        // Mock the API response
+        jest.spyOn(client.corporations, 'getCorporationProjects').mockResolvedValue(expectedProjects);
+
+        // When: I request corporation projects
+        const result = await client.corporations.getCorporationProjects(corporationId);
+
+        // Then: I should receive an empty list
+        expect(result).toBeDefined();
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toHaveLength(0);
+      });
+    });
+
+    describe('Scenario: Handle unauthorized access', () => {
+      it('Given insufficient permissions for the corporation, When I request corporation projects, Then I should receive an unauthorized error', async () => {
+        // Given: Insufficient permissions for the corporation
+        const corporationId = 98000001;
+        const unauthorizedError = new ApiError('Insufficient permissions', ApiErrorType.AUTHORIZATION_ERROR, 403);
+
+        // Mock the API error
+        jest.spyOn(client.corporations, 'getCorporationProjects').mockRejectedValue(unauthorizedError);
+
+        // When & Then: I request projects and should receive an error
+        await expect(client.corporations.getCorporationProjects(corporationId)).rejects.toThrow('Insufficient permissions');
+      });
+    });
+
+    describe('Scenario: Handle non-existent corporation', () => {
+      it('Given a non-existent corporation ID, When I request corporation projects, Then I should receive a not found error', async () => {
+        // Given: A non-existent corporation ID
+        const invalidCorporationId = 99999999;
+        const notFoundError = new ApiError('Corporation not found', ApiErrorType.NOT_FOUND_ERROR, 404);
+
+        // Mock the API error
+        jest.spyOn(client.corporations, 'getCorporationProjects').mockRejectedValue(notFoundError);
+
+        // When & Then: I request projects and should receive an error
+        await expect(client.corporations.getCorporationProjects(invalidCorporationId)).rejects.toThrow('Corporation not found');
+      });
+    });
+  });
+
+  describe('Feature: Authentication Requirements', () => {
+    describe('Scenario: Verify authentication is required', () => {
+      it('Given no authentication token, When I request corporation projects, Then I should receive an authentication required error', async () => {
+        // Given: No authentication token
+        const unauthenticatedClient = new EsiClient({
+          clientId: 'test-client',
+          baseUrl: 'https://esi.evetech.net'
+          // No accessToken provided
+        });
+        
+        const corporationId = 98000001;
+        const authError = new ApiError('Authentication required', ApiErrorType.AUTHENTICATION_ERROR, 401);
+
+        // Mock the API error
+        jest.spyOn(unauthenticatedClient.corporations, 'getCorporationProjects').mockRejectedValue(authError);
+
+        // When & Then: I request projects and should receive an error
+        await expect(unauthenticatedClient.corporations.getCorporationProjects(corporationId)).rejects.toThrow('Authentication required');
+      });
+    });
+  });
+});