mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

view models

Browse Source
This commit is contained in:
Marc Mintel
2025-12-18 01:20:23 +01:00
parent 7c449af311
commit cc2553876a
216 changed files with 485 additions and 10179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

292
apps/website/lib/services/drivers/DriverRegistrationService.test.ts
View File

@@ -1,292 +0,0 @@
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { DriverRegistrationService } from './DriverRegistrationService';
import type { DriversApiClient } from '../../api/drivers/DriversApiClient';
import type { DriverRegistrationStatusPresenter } from '../../presenters/DriverRegistrationStatusPresenter';
import type { DriverRegistrationStatusDto } from '../../dtos';
import type { DriverRegistrationStatusViewModel } from '../../view-models';
describe('DriverRegistrationService', () => {
let service: DriverRegistrationService;
let mockApiClient: DriversApiClient;
let mockStatusPresenter: DriverRegistrationStatusPresenter;
beforeEach(() => {
mockApiClient = {
getRegistrationStatus: vi.fn(),
} as unknown as DriversApiClient;
mockStatusPresenter = {
present: vi.fn(),
} as unknown as DriverRegistrationStatusPresenter;
service = new DriverRegistrationService(
mockApiClient,
mockStatusPresenter
);
});
describe('constructor', () => {
it('should create instance with injected dependencies', () => {
expect(service).toBeInstanceOf(DriverRegistrationService);
});
});
describe('getDriverRegistrationStatus', () => {
it('should fetch registration status from API and transform via presenter', async () => {
// Arrange
const driverId = 'driver-123';
const raceId = 'race-456';
const mockDto: DriverRegistrationStatusDto = {
isRegistered: true,
raceId: 'race-456',
driverId: 'driver-123',
};
const mockViewModel = {
isRegistered: true,
raceId: 'race-456',
driverId: 'driver-123',
statusMessage: 'Registered for this race',
statusColor: 'green',
statusBadgeVariant: 'success',
registrationButtonText: 'Withdraw',
canRegister: false,
} as DriverRegistrationStatusViewModel;
vi.mocked(mockApiClient.getRegistrationStatus).mockResolvedValue(mockDto);
vi.mocked(mockStatusPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.getDriverRegistrationStatus(driverId, raceId);
// Assert
expect(mockApiClient.getRegistrationStatus).toHaveBeenCalledWith(driverId, raceId);
expect(mockStatusPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModel);
});
it('should handle unregistered driver status', async () => {
// Arrange
const driverId = 'driver-789';
const raceId = 'race-101';
const mockDto: DriverRegistrationStatusDto = {
isRegistered: false,
raceId: 'race-101',
driverId: 'driver-789',
};
const mockViewModel = {
isRegistered: false,
raceId: 'race-101',
driverId: 'driver-789',
statusMessage: 'Not registered',
statusColor: 'red',
statusBadgeVariant: 'warning',
registrationButtonText: 'Register',
canRegister: true,
} as DriverRegistrationStatusViewModel;
vi.mocked(mockApiClient.getRegistrationStatus).mockResolvedValue(mockDto);
vi.mocked(mockStatusPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.getDriverRegistrationStatus(driverId, raceId);
// Assert
expect(mockApiClient.getRegistrationStatus).toHaveBeenCalledWith(driverId, raceId);
expect(mockStatusPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModel);
expect(result.canRegister).toBe(true);
});
it('should propagate errors from API client', async () => {
// Arrange
const driverId = 'driver-123';
const raceId = 'race-456';
const error = new Error('Failed to fetch registration status');
vi.mocked(mockApiClient.getRegistrationStatus).mockRejectedValue(error);
// Act & Assert
await expect(service.getDriverRegistrationStatus(driverId, raceId))
.rejects.toThrow('Failed to fetch registration status');
expect(mockApiClient.getRegistrationStatus).toHaveBeenCalledWith(driverId, raceId);
expect(mockStatusPresenter.present).not.toHaveBeenCalled();
});
it('should handle network errors gracefully', async () => {
// Arrange
const driverId = 'driver-123';
const raceId = 'race-456';
const networkError = new Error('Network request failed');
vi.mocked(mockApiClient.getRegistrationStatus).mockRejectedValue(networkError);
// Act & Assert
await expect(service.getDriverRegistrationStatus(driverId, raceId))
.rejects.toThrow('Network request failed');
expect(mockApiClient.getRegistrationStatus).toHaveBeenCalledWith(driverId, raceId);
});
it('should handle API errors with proper error propagation', async () => {
// Arrange
const driverId = 'driver-123';
const raceId = 'race-456';
const apiError = new Error('Race not found');
vi.mocked(mockApiClient.getRegistrationStatus).mockRejectedValue(apiError);
// Act & Assert
await expect(service.getDriverRegistrationStatus(driverId, raceId))
.rejects.toThrow('Race not found');
expect(mockApiClient.getRegistrationStatus).toHaveBeenCalledWith(driverId, raceId);
expect(mockStatusPresenter.present).not.toHaveBeenCalled();
});
it('should handle multiple consecutive calls correctly', async () => {
// Arrange
const driverId = 'driver-123';
const raceId1 = 'race-456';
const raceId2 = 'race-789';
const mockDto1: DriverRegistrationStatusDto = {
isRegistered: true,
raceId: raceId1,
driverId,
};
const mockDto2: DriverRegistrationStatusDto = {
isRegistered: false,
raceId: raceId2,
driverId,
};
const mockViewModel1 = {
isRegistered: true,
raceId: raceId1,
driverId,
} as DriverRegistrationStatusViewModel;
const mockViewModel2 = {
isRegistered: false,
raceId: raceId2,
driverId,
} as DriverRegistrationStatusViewModel;
vi.mocked(mockApiClient.getRegistrationStatus)
.mockResolvedValueOnce(mockDto1)
.mockResolvedValueOnce(mockDto2);
vi.mocked(mockStatusPresenter.present)
.mockReturnValueOnce(mockViewModel1)
.mockReturnValueOnce(mockViewModel2);
// Act
const result1 = await service.getDriverRegistrationStatus(driverId, raceId1);
const result2 = await service.getDriverRegistrationStatus(driverId, raceId2);
// Assert
expect(mockApiClient.getRegistrationStatus).toHaveBeenCalledTimes(2);
expect(mockApiClient.getRegistrationStatus).toHaveBeenNthCalledWith(1, driverId, raceId1);
expect(mockApiClient.getRegistrationStatus).toHaveBeenNthCalledWith(2, driverId, raceId2);
expect(result1.isRegistered).toBe(true);
expect(result2.isRegistered).toBe(false);
});
it('should handle different driver IDs for same race', async () => {
// Arrange
const driverId1 = 'driver-123';
const driverId2 = 'driver-456';
const raceId = 'race-789';
const mockDto1: DriverRegistrationStatusDto = {
isRegistered: true,
raceId,
driverId: driverId1,
};
const mockDto2: DriverRegistrationStatusDto = {
isRegistered: false,
raceId,
driverId: driverId2,
};
const mockViewModel1 = {
isRegistered: true,
raceId,
driverId: driverId1,
} as DriverRegistrationStatusViewModel;
const mockViewModel2 = {
isRegistered: false,
raceId,
driverId: driverId2,
} as DriverRegistrationStatusViewModel;
vi.mocked(mockApiClient.getRegistrationStatus)
.mockResolvedValueOnce(mockDto1)
.mockResolvedValueOnce(mockDto2);
vi.mocked(mockStatusPresenter.present)
.mockReturnValueOnce(mockViewModel1)
.mockReturnValueOnce(mockViewModel2);
// Act
const result1 = await service.getDriverRegistrationStatus(driverId1, raceId);
const result2 = await service.getDriverRegistrationStatus(driverId2, raceId);
// Assert
expect(result1.driverId).toBe(driverId1);
expect(result1.isRegistered).toBe(true);
expect(result2.driverId).toBe(driverId2);
expect(result2.isRegistered).toBe(false);
});
it('should handle unauthorized access errors', async () => {
// Arrange
const driverId = 'driver-123';
const raceId = 'race-456';
const authError = new Error('Unauthorized: Driver not found');
vi.mocked(mockApiClient.getRegistrationStatus).mockRejectedValue(authError);
// Act & Assert
await expect(service.getDriverRegistrationStatus(driverId, raceId))
.rejects.toThrow('Unauthorized: Driver not found');
expect(mockApiClient.getRegistrationStatus).toHaveBeenCalledWith(driverId, raceId);
expect(mockStatusPresenter.present).not.toHaveBeenCalled();
});
it('should call presenter only after successful API response', async () => {
// Arrange
const driverId = 'driver-123';
const raceId = 'race-456';
const mockDto: DriverRegistrationStatusDto = {
isRegistered: true,
raceId: 'race-456',
driverId: 'driver-123',
};
const mockViewModel = {
isRegistered: true,
raceId: 'race-456',
driverId: 'driver-123',
} as DriverRegistrationStatusViewModel;
vi.mocked(mockApiClient.getRegistrationStatus).mockResolvedValue(mockDto);
vi.mocked(mockStatusPresenter.present).mockReturnValue(mockViewModel);
// Act
await service.getDriverRegistrationStatus(driverId, raceId);
// Assert - verify call order
expect(mockApiClient.getRegistrationStatus).toHaveBeenCalled();
expect(mockStatusPresenter.present).toHaveBeenCalledAfter(
mockApiClient.getRegistrationStatus as any
);
});
});
});

10
apps/website/lib/services/drivers/DriverRegistrationService.ts
View File

@@ -1,17 +1,15 @@
import type { DriversApiClient } from '../../api/drivers/DriversApiClient';
import type { DriverRegistrationStatusPresenter } from '../../presenters/DriverRegistrationStatusPresenter';
import type { DriverRegistrationStatusViewModel } from '../../view-models';
import { DriverRegistrationStatusViewModel } from '../../view-models';
/**
* Driver Registration Service
*
* Orchestrates driver registration status operations by coordinating API calls and presentation logic.
* Orchestrates driver registration status operations by coordinating API calls and view model creation.
* All dependencies are injected via constructor.
*/
export class DriverRegistrationService {
constructor(
private readonly apiClient: DriversApiClient,
private readonly statusPresenter: DriverRegistrationStatusPresenter
private readonly apiClient: DriversApiClient
) {}
/**
@@ -22,6 +20,6 @@ export class DriverRegistrationService {
raceId: string
): Promise<DriverRegistrationStatusViewModel> {
const dto = await this.apiClient.getRegistrationStatus(driverId, raceId);
return this.statusPresenter.present(dto);
return new DriverRegistrationStatusViewModel(dto);
}
}

296
apps/website/lib/services/drivers/DriverService.test.ts
View File

@@ -1,296 +0,0 @@
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { DriverService } from './DriverService';
import type { DriversApiClient } from '../../api/drivers/DriversApiClient';
import type { DriversLeaderboardPresenter } from '../../presenters/DriversLeaderboardPresenter';
import type { DriverPresenter } from '../../presenters/DriverPresenter';
import type { CompleteOnboardingPresenter } from '../../presenters/CompleteOnboardingPresenter';
import type { DriversLeaderboardDto, CompleteOnboardingOutputDto, DriverDto, CompleteOnboardingInputDto } from '../../dtos';
import type { DriverLeaderboardViewModel, DriverViewModel, CompleteOnboardingViewModel } from '../../view-models';
describe('DriverService', () => {
let service: DriverService;
let mockApiClient: DriversApiClient;
let mockLeaderboardPresenter: DriversLeaderboardPresenter;
let mockDriverPresenter: DriverPresenter;
let mockOnboardingPresenter: CompleteOnboardingPresenter;
beforeEach(() => {
mockApiClient = {
getLeaderboard: vi.fn(),
completeOnboarding: vi.fn(),
getCurrent: vi.fn(),
} as unknown as DriversApiClient;
mockLeaderboardPresenter = {
present: vi.fn(),
} as unknown as DriversLeaderboardPresenter;
mockDriverPresenter = {
present: vi.fn(),
} as unknown as DriverPresenter;
mockOnboardingPresenter = {
present: vi.fn(),
} as unknown as CompleteOnboardingPresenter;
service = new DriverService(
mockApiClient,
mockLeaderboardPresenter,
mockDriverPresenter,
mockOnboardingPresenter
);
});
describe('constructor', () => {
it('should create instance with injected dependencies', () => {
expect(service).toBeInstanceOf(DriverService);
});
});
describe('getDriverLeaderboard', () => {
it('should fetch leaderboard from API and transform via presenter', async () => {
// Arrange
const mockDto: DriversLeaderboardDto = {
drivers: [
{
id: 'driver-1',
name: 'John Doe',
rating: 2500,
races: 50,
wins: 10,
isActive: true,
},
{
id: 'driver-2',
name: 'Jane Smith',
rating: 2300,
races: 40,
wins: 8,
isActive: true,
},
],
};
const mockViewModel = {
drivers: [
{
id: 'driver-1',
name: 'John Doe',
rating: 2500,
races: 50,
wins: 10,
isActive: true,
},
{
id: 'driver-2',
name: 'Jane Smith',
rating: 2300,
races: 40,
wins: 8,
isActive: true,
},
],
} as DriverLeaderboardViewModel;
vi.mocked(mockApiClient.getLeaderboard).mockResolvedValue(mockDto);
vi.mocked(mockLeaderboardPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.getDriverLeaderboard();
// Assert
expect(mockApiClient.getLeaderboard).toHaveBeenCalled();
expect(mockLeaderboardPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModel);
});
it('should handle empty leaderboard', async () => {
// Arrange
const mockDto: DriversLeaderboardDto = {
drivers: [],
};
const mockViewModel = {
drivers: [],
} as DriverLeaderboardViewModel;
vi.mocked(mockApiClient.getLeaderboard).mockResolvedValue(mockDto);
vi.mocked(mockLeaderboardPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.getDriverLeaderboard();
// Assert
expect(mockApiClient.getLeaderboard).toHaveBeenCalled();
expect(mockLeaderboardPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModel);
});
it('should propagate errors from API client', async () => {
// Arrange
const error = new Error('Leaderboard fetch failed');
vi.mocked(mockApiClient.getLeaderboard).mockRejectedValue(error);
// Act & Assert
await expect(service.getDriverLeaderboard()).rejects.toThrow('Leaderboard fetch failed');
expect(mockApiClient.getLeaderboard).toHaveBeenCalled();
expect(mockLeaderboardPresenter.present).not.toHaveBeenCalled();
});
});
describe('completeDriverOnboarding', () => {
it('should complete onboarding and transform via presenter', async () => {
// Arrange
const input: CompleteOnboardingInputDto = {
iracingId: '123456',
displayName: 'John Doe',
};
const mockDto: CompleteOnboardingOutputDto = {
driverId: 'driver-123',
success: true,
};
const mockViewModel: CompleteOnboardingViewModel = {
driverId: 'driver-123',
success: true,
};
vi.mocked(mockApiClient.completeOnboarding).mockResolvedValue(mockDto);
vi.mocked(mockOnboardingPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.completeDriverOnboarding(input);
// Assert
expect(mockApiClient.completeOnboarding).toHaveBeenCalledWith(input);
expect(mockOnboardingPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModel);
});
it('should handle onboarding failure', async () => {
// Arrange
const input: CompleteOnboardingInputDto = {
iracingId: '123456',
displayName: 'John Doe',
};
const mockDto: CompleteOnboardingOutputDto = {
driverId: '',
success: false,
};
const mockViewModel: CompleteOnboardingViewModel = {
driverId: '',
success: false,
};
vi.mocked(mockApiClient.completeOnboarding).mockResolvedValue(mockDto);
vi.mocked(mockOnboardingPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.completeDriverOnboarding(input);
// Assert
expect(mockApiClient.completeOnboarding).toHaveBeenCalledWith(input);
expect(mockOnboardingPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModel);
expect(result.success).toBe(false);
});
it('should propagate errors from API client', async () => {
// Arrange
const input: CompleteOnboardingInputDto = {
iracingId: '123456',
displayName: 'John Doe',
};
const error = new Error('Onboarding failed');
vi.mocked(mockApiClient.completeOnboarding).mockRejectedValue(error);
// Act & Assert
await expect(service.completeDriverOnboarding(input)).rejects.toThrow('Onboarding failed');
expect(mockApiClient.completeOnboarding).toHaveBeenCalledWith(input);
expect(mockOnboardingPresenter.present).not.toHaveBeenCalled();
});
});
describe('getCurrentDriver', () => {
it('should fetch current driver and transform via presenter', async () => {
// Arrange
const mockDto: DriverDto = {
id: 'driver-123',
name: 'John Doe',
avatarUrl: 'https://example.com/avatar.jpg',
iracingId: '123456',
rating: 2500,
};
const mockViewModel: DriverViewModel = {
id: 'driver-123',
name: 'John Doe',
avatarUrl: 'https://example.com/avatar.jpg',
iracingId: '123456',
rating: 2500,
};
vi.mocked(mockApiClient.getCurrent).mockResolvedValue(mockDto);
vi.mocked(mockDriverPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.getCurrentDriver();
// Assert
expect(mockApiClient.getCurrent).toHaveBeenCalled();
expect(mockDriverPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModel);
});
it('should return null when no current driver', async () => {
// Arrange
vi.mocked(mockApiClient.getCurrent).mockResolvedValue(null);
// Act
const result = await service.getCurrentDriver();
// Assert
expect(mockApiClient.getCurrent).toHaveBeenCalled();
expect(mockDriverPresenter.present).not.toHaveBeenCalled();
expect(result).toBeNull();
});
it('should handle driver without optional fields', async () => {
// Arrange
const mockDto: DriverDto = {
id: 'driver-123',
name: 'John Doe',
};
const mockViewModel: DriverViewModel = {
id: 'driver-123',
name: 'John Doe',
};
vi.mocked(mockApiClient.getCurrent).mockResolvedValue(mockDto);
vi.mocked(mockDriverPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.getCurrentDriver();
// Assert
expect(mockApiClient.getCurrent).toHaveBeenCalled();
expect(mockDriverPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModel);
});
it('should propagate errors from API client', async () => {
// Arrange
const error = new Error('Failed to fetch current driver');
vi.mocked(mockApiClient.getCurrent).mockRejectedValue(error);
// Act & Assert
await expect(service.getCurrentDriver()).rejects.toThrow('Failed to fetch current driver');
expect(mockApiClient.getCurrent).toHaveBeenCalled();
expect(mockDriverPresenter.present).not.toHaveBeenCalled();
});
});
});

31
apps/website/lib/services/drivers/DriverService.ts
View File

@@ -1,51 +1,44 @@
import type { DriversApiClient } from '../../api/drivers/DriversApiClient';
import type { DriversLeaderboardPresenter } from '../../presenters/DriversLeaderboardPresenter';
import type { DriverPresenter } from '../../presenters/DriverPresenter';
import type { CompleteOnboardingPresenter } from '../../presenters/CompleteOnboardingPresenter';
import type { DriverLeaderboardViewModel } from '../../view-models';
import type { DriverViewModel } from '../../view-models/DriverViewModel';
import type { CompleteOnboardingViewModel } from '../../view-models/CompleteOnboardingViewModel';
// Import generated types instead of manual DTOs
import type { CompleteOnboardingInputDTO } from '../../types/api-helpers';
import { DriverLeaderboardViewModel } from '../../view-models';
import { DriverViewModel } from '../../view-models/DriverViewModel';
import { CompleteOnboardingViewModel } from '../../view-models/CompleteOnboardingViewModel';
import type { CompleteOnboardingInputDTO } from '../../types/generated';
/**
* Driver Service
*
* Orchestrates driver operations by coordinating API calls and presentation logic.
* Orchestrates driver operations by coordinating API calls and view model creation.
* All dependencies are injected via constructor.
*/
export class DriverService {
constructor(
private readonly apiClient: DriversApiClient,
private readonly leaderboardPresenter: DriversLeaderboardPresenter,
private readonly driverPresenter: DriverPresenter,
private readonly onboardingPresenter: CompleteOnboardingPresenter
private readonly apiClient: DriversApiClient
) {}
/**
* Get driver leaderboard with presentation transformation
* Get driver leaderboard with view model transformation
*/
async getDriverLeaderboard(): Promise<DriverLeaderboardViewModel> {
const dto = await this.apiClient.getLeaderboard();
return this.leaderboardPresenter.present(dto);
return new DriverLeaderboardViewModel(dto);
}
/**
* Complete driver onboarding with presentation transformation
* Complete driver onboarding with view model transformation
*/
async completeDriverOnboarding(input: CompleteOnboardingInputDTO): Promise<CompleteOnboardingViewModel> {
const dto = await this.apiClient.completeOnboarding(input);
return this.onboardingPresenter.present(dto);
return new CompleteOnboardingViewModel(dto);
}
/**
* Get current driver with presentation transformation
* Get current driver with view model transformation
*/
async getCurrentDriver(): Promise<DriverViewModel | null> {
const dto = await this.apiClient.getCurrent();
if (!dto) {
return null;
}
return this.driverPresenter.present(dto);
return new DriverViewModel(dto);
}
}