website refactor

2026-01-21 22:36:01 +01:00
parent ea58909070
commit 5ed958281d
49 changed files with 8763 additions and 131 deletions
--- a/tests/integration/website/LeagueDetailPageQuery.integration.test.ts
+++ b/tests/integration/website/LeagueDetailPageQuery.integration.test.ts
@@ -0,0 +1,662 @@
+/**
+ * Integration Tests for LeagueDetailPageQuery
+ *
+ * Tests the LeagueDetailPageQuery with mocked API clients to verify:
+ * - Happy path: API returns valid league detail data
+ * - Error handling: 404 when league not found
+ * - Error handling: 500 when API server error
+ * - Missing data: API returns partial data
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { LeagueDetailPageQuery } from '@/lib/page-queries/LeagueDetailPageQuery';
+import { MockLeaguesApiClient } from './mocks/MockLeaguesApiClient';
+import { ApiError } from '../../../apps/website/lib/api/base/ApiError';
+
+// Mock data factories
+const createMockLeagueDetailData = () => ({
+  leagues: [
+    {
+      id: 'league-1',
+      name: 'Test League',
+      description: 'A test league',
+      capacity: 10,
+      currentMembers: 5,
+      ownerId: 'driver-1',
+      status: 'active' as const,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    },
+  ],
+});
+
+const createMockMembershipsData = () => ({
+  members: [
+    {
+      driverId: 'driver-1',
+      driver: {
+        id: 'driver-1',
+        iracingId: '12345',
+        name: 'Test Driver',
+        country: 'US',
+        joinedAt: new Date().toISOString(),
+      },
+      role: 'owner' as const,
+      status: 'active' as const,
+      joinedAt: new Date().toISOString(),
+    },
+  ],
+});
+
+const createMockRacesPageData = () => ({
+  races: [
+    {
+      id: 'race-1',
+      track: 'Test Track',
+      car: 'Test Car',
+      scheduledAt: new Date().toISOString(),
+      leagueName: 'Test League',
+      status: 'scheduled' as const,
+      strengthOfField: 50,
+    },
+  ],
+});
+
+const createMockDriverData = () => ({
+  id: 'driver-1',
+  iracingId: '12345',
+  name: 'Test Driver',
+  country: 'US',
+  joinedAt: new Date().toISOString(),
+});
+
+const createMockLeagueConfigData = () => ({
+  form: {
+    scoring: {
+      presetId: 'preset-1',
+    },
+  },
+});
+
+describe('LeagueDetailPageQuery Integration', () => {
+  let mockLeaguesApiClient: MockLeaguesApiClient;
+
+  beforeEach(() => {
+    mockLeaguesApiClient = new MockLeaguesApiClient();
+  });
+
+  afterEach(() => {
+    mockLeaguesApiClient.clearMocks();
+  });
+
+  describe('Happy Path', () => {
+    it('should return valid league detail data when API returns success', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      const mockLeaguesData = createMockLeagueDetailData();
+      const mockMembershipsData = createMockMembershipsData();
+      const mockRacesPageData = createMockRacesPageData();
+      const mockDriverData = createMockDriverData();
+      const mockLeagueConfigData = createMockLeagueConfigData();
+
+      // Mock fetch to return different data based on the URL
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve(createMockResponse(mockLeaguesData));
+        }
+        if (url.includes('/memberships')) {
+          return Promise.resolve(createMockResponse(mockMembershipsData));
+        }
+        if (url.includes('/races/page-data')) {
+          return Promise.resolve(createMockResponse(mockRacesPageData));
+        }
+        if (url.includes('/drivers/driver-1')) {
+          return Promise.resolve(createMockResponse(mockDriverData));
+        }
+        if (url.includes('/config')) {
+          return Promise.resolve(createMockResponse(mockLeagueConfigData));
+        }
+        return Promise.resolve(createMockErrorResponse(404, 'Not Found', 'Not Found'));
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const data = result.unwrap();
+      
+      expect(data).toBeDefined();
+      expect(data.league).toBeDefined();
+      expect(data.league.id).toBe('league-1');
+      expect(data.league.name).toBe('Test League');
+      expect(data.league.capacity).toBe(10);
+      expect(data.league.currentMembers).toBe(5);
+      
+      expect(data.owner).toBeDefined();
+      expect(data.owner?.id).toBe('driver-1');
+      expect(data.owner?.name).toBe('Test Driver');
+      
+      expect(data.memberships).toBeDefined();
+      expect(data.memberships.members).toBeDefined();
+      expect(data.memberships.members.length).toBe(1);
+      
+      expect(data.races).toBeDefined();
+      expect(data.races.length).toBe(1);
+      expect(data.races[0].id).toBe('race-1');
+      expect(data.races[0].name).toBe('Test Track - Test Car');
+      
+      expect(data.scoringConfig).toBeDefined();
+      expect(data.scoringConfig?.scoringPresetId).toBe('preset-1');
+    });
+
+    it('should handle league without owner', async () => {
+      // Arrange
+      const leagueId = 'league-2';
+      const mockLeaguesData = {
+        leagues: [
+          {
+            id: 'league-2',
+            name: 'League Without Owner',
+            description: 'A league without an owner',
+            capacity: 15,
+            currentMembers: 8,
+            // No ownerId
+            status: 'active' as const,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          },
+        ],
+      };
+      const mockMembershipsData = createMockMembershipsData();
+      const mockRacesPageData = createMockRacesPageData();
+
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve(createMockResponse(mockLeaguesData));
+        }
+        if (url.includes('/memberships')) {
+          return Promise.resolve(createMockResponse(mockMembershipsData));
+        }
+        if (url.includes('/races/page-data')) {
+          return Promise.resolve(createMockResponse(mockRacesPageData));
+        }
+        return Promise.resolve(createMockErrorResponse(404, 'Not Found', 'Not Found'));
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const data = result.unwrap();
+      
+      expect(data.owner).toBeNull();
+      expect(data.league.id).toBe('league-2');
+      expect(data.league.name).toBe('League Without Owner');
+    });
+
+    it('should handle league with no races', async () => {
+      // Arrange
+      const leagueId = 'league-3';
+      const mockLeaguesData = createMockLeagueDetailData();
+      const mockMembershipsData = createMockMembershipsData();
+      const mockRacesPageData = { races: [] };
+
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve(createMockResponse(mockLeaguesData));
+        }
+        if (url.includes('/memberships')) {
+          return Promise.resolve(createMockResponse(mockMembershipsData));
+        }
+        if (url.includes('/races/page-data')) {
+          return Promise.resolve(createMockResponse(mockRacesPageData));
+        }
+        return Promise.resolve(createMockErrorResponse(404, 'Not Found', 'Not Found'));
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const data = result.unwrap();
+      
+      expect(data.races).toBeDefined();
+      expect(data.races.length).toBe(0);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle 404 error when league not found', async () => {
+      // Arrange
+      const leagueId = 'non-existent-league';
+      
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve(createMockResponse({ leagues: [] }));
+        }
+        return Promise.resolve(createMockErrorResponse(404, 'Not Found', 'League not found'));
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error).toBe('notFound');
+    });
+
+    it('should handle 500 error when API server error', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve(createMockErrorResponse(500, 'Internal Server Error', 'Internal Server Error'));
+        }
+        return Promise.resolve(createMockErrorResponse(500, 'Internal Server Error', 'Internal Server Error'));
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error).toBe('serverError');
+    });
+
+    it('should handle network error', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      
+      global.fetch = vi.fn().mockRejectedValue(new Error('Network error: Unable to reach the API server'));
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error).toBe('serverError');
+    });
+
+    it('should handle timeout error', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      const timeoutError = new Error('Request timed out after 30 seconds');
+      timeoutError.name = 'AbortError';
+      
+      global.fetch = vi.fn().mockRejectedValue(timeoutError);
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error).toBe('serverError');
+    });
+
+    it('should handle unauthorized error', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: false,
+            status: 401,
+            statusText: 'Unauthorized',
+            text: async () => 'Unauthorized',
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 401,
+          statusText: 'Unauthorized',
+          text: async () => 'Unauthorized',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error).toBe('unauthorized');
+    });
+
+    it('should handle forbidden error', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: false,
+            status: 403,
+            statusText: 'Forbidden',
+            text: async () => 'Forbidden',
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 403,
+          statusText: 'Forbidden',
+          text: async () => 'Forbidden',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error).toBe('unauthorized');
+    });
+  });
+
+  describe('Missing Data', () => {
+    it('should handle API returning partial data (missing memberships)', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      const mockLeaguesData = createMockLeagueDetailData();
+      const mockRacesPageData = createMockRacesPageData();
+
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockLeaguesData,
+          });
+        }
+        if (url.includes('/memberships')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => ({ members: [] }),
+          });
+        }
+        if (url.includes('/races/page-data')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockRacesPageData,
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          text: async () => 'Not Found',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const data = result.unwrap();
+      
+      expect(data.memberships).toBeDefined();
+      expect(data.memberships.members).toBeDefined();
+      expect(data.memberships.members.length).toBe(0);
+    });
+
+    it('should handle API returning partial data (missing races)', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      const mockLeaguesData = createMockLeagueDetailData();
+      const mockMembershipsData = createMockMembershipsData();
+
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockLeaguesData,
+          });
+        }
+        if (url.includes('/memberships')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockMembershipsData,
+          });
+        }
+        if (url.includes('/races/page-data')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => ({ races: [] }),
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          text: async () => 'Not Found',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const data = result.unwrap();
+      
+      expect(data.races).toBeDefined();
+      expect(data.races.length).toBe(0);
+    });
+
+    it('should handle API returning partial data (missing scoring config)', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      const mockLeaguesData = createMockLeagueDetailData();
+      const mockMembershipsData = createMockMembershipsData();
+      const mockRacesPageData = createMockRacesPageData();
+
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockLeaguesData,
+          });
+        }
+        if (url.includes('/memberships')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockMembershipsData,
+          });
+        }
+        if (url.includes('/races/page-data')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockRacesPageData,
+          });
+        }
+        if (url.includes('/config')) {
+          return Promise.resolve({
+            ok: false,
+            status: 404,
+            statusText: 'Not Found',
+            text: async () => 'Config not found',
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          text: async () => 'Not Found',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const data = result.unwrap();
+      
+      expect(data.scoringConfig).toBeNull();
+    });
+
+    it('should handle API returning partial data (missing owner)', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      const mockLeaguesData = {
+        leagues: [
+          {
+            id: 'league-1',
+            name: 'Test League',
+            description: 'A test league',
+            capacity: 10,
+            currentMembers: 5,
+            ownerId: 'driver-1',
+            status: 'active' as const,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          },
+        ],
+      };
+      const mockMembershipsData = createMockMembershipsData();
+      const mockRacesPageData = createMockRacesPageData();
+
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockLeaguesData,
+          });
+        }
+        if (url.includes('/memberships')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockMembershipsData,
+          });
+        }
+        if (url.includes('/races/page-data')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => mockRacesPageData,
+          });
+        }
+        if (url.includes('/drivers/driver-1')) {
+          return Promise.resolve({
+            ok: false,
+            status: 404,
+            statusText: 'Not Found',
+            text: async () => 'Driver not found',
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          text: async () => 'Not Found',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isOk()).toBe(true);
+      const data = result.unwrap();
+      
+      expect(data.owner).toBeNull();
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle API returning empty leagues array', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => ({ leagues: [] }),
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          text: async () => 'Not Found',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error.type).toBe('notFound');
+      expect(error.message).toContain('Leagues not found');
+    });
+
+    it('should handle API returning null data', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => null,
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          text: async () => 'Not Found',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error.type).toBe('notFound');
+      expect(error.message).toContain('Leagues not found');
+    });
+
+    it('should handle API returning malformed data', async () => {
+      // Arrange
+      const leagueId = 'league-1';
+      
+      global.fetch = vi.fn((url: string) => {
+        if (url.includes('/leagues/all-with-capacity-and-scoring')) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => ({ someOtherProperty: 'value' }),
+          });
+        }
+        return Promise.resolve({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          text: async () => 'Not Found',
+        });
+      });
+      
+      // Act
+      const result = await LeagueDetailPageQuery.execute(leagueId);
+
+      // Assert
+      expect(result.isErr()).toBe(true);
+      const error = result.getError();
+      expect(error.type).toBe('notFound');
+      expect(error.message).toContain('Leagues not found');
+    });
+  });
+});