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

integration tests
Some checks failed
CI / lint-typecheck (pull_request) Failing after 4m50s
Details
CI / tests (pull_request) Has been skipped
Details
CI / contract-tests (pull_request) Has been skipped
Details
CI / e2e-tests (pull_request) Has been skipped
Details
CI / comment-pr (pull_request) Has been skipped
Details
CI / commit-types (pull_request) Has been skipped
Details

Browse Source
This commit is contained in:
Marc Mintel
2026-01-23 11:44:59 +01:00
parent a0f41f242f
commit 6df38a462a
125 changed files with 4712 additions and 19184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
tests/integration/profile/ProfileTestContext.ts Normal file
View File

@@ -0,0 +1,78 @@
import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
import { InMemoryTeamRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamRepository';
import { InMemoryTeamMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamMembershipRepository';
import { InMemorySocialGraphRepository } from '../../../adapters/social/persistence/inmemory/InMemorySocialAndFeed';
import { InMemoryDriverExtendedProfileProvider } from '../../../adapters/racing/ports/InMemoryDriverExtendedProfileProvider';
import { InMemoryDriverStatsRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverStatsRepository';
import { InMemoryLiveryRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLiveryRepository';
import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
import { InMemoryLeagueMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
import { InMemorySponsorshipRequestRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorshipRequestRepository';
import { InMemorySponsorRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { InMemoryResultRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryResultRepository';
import { InMemoryStandingRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryStandingRepository';
import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
import { Logger } from '../../../core/shared/domain/Logger';
export class ProfileTestContext {
public readonly driverRepository: InMemoryDriverRepository;
public readonly teamRepository: InMemoryTeamRepository;
public readonly teamMembershipRepository: InMemoryTeamMembershipRepository;
public readonly socialRepository: InMemorySocialGraphRepository;
public readonly driverExtendedProfileProvider: InMemoryDriverExtendedProfileProvider;
public readonly driverStatsRepository: InMemoryDriverStatsRepository;
public readonly liveryRepository: InMemoryLiveryRepository;
public readonly leagueRepository: InMemoryLeagueRepository;
public readonly leagueMembershipRepository: InMemoryLeagueMembershipRepository;
public readonly sponsorshipRequestRepository: InMemorySponsorshipRequestRepository;
public readonly sponsorRepository: InMemorySponsorRepository;
public readonly eventPublisher: InMemoryEventPublisher;
public readonly resultRepository: InMemoryResultRepository;
public readonly standingRepository: InMemoryStandingRepository;
public readonly raceRepository: InMemoryRaceRepository;
public readonly logger: Logger;
constructor() {
this.logger = {
info: () => {},
debug: () => {},
warn: () => {},
error: () => {},
} as unknown as Logger;
this.driverRepository = new InMemoryDriverRepository(this.logger);
this.teamRepository = new InMemoryTeamRepository(this.logger);
this.teamMembershipRepository = new InMemoryTeamMembershipRepository(this.logger);
this.socialRepository = new InMemorySocialGraphRepository(this.logger);
this.driverExtendedProfileProvider = new InMemoryDriverExtendedProfileProvider(this.logger);
this.driverStatsRepository = new InMemoryDriverStatsRepository(this.logger);
this.liveryRepository = new InMemoryLiveryRepository(this.logger);
this.leagueRepository = new InMemoryLeagueRepository(this.logger);
this.leagueMembershipRepository = new InMemoryLeagueMembershipRepository(this.logger);
this.sponsorshipRequestRepository = new InMemorySponsorshipRequestRepository(this.logger);
this.sponsorRepository = new InMemorySponsorRepository(this.logger);
this.eventPublisher = new InMemoryEventPublisher();
this.raceRepository = new InMemoryRaceRepository(this.logger);
this.resultRepository = new InMemoryResultRepository(this.logger, this.raceRepository);
this.standingRepository = new InMemoryStandingRepository(this.logger, {}, this.resultRepository, this.raceRepository);
}
public async clear(): Promise<void> {
await this.driverRepository.clear();
await this.teamRepository.clear();
await this.teamMembershipRepository.clear();
await this.socialRepository.clear();
await this.driverExtendedProfileProvider.clear();
await this.driverStatsRepository.clear();
await this.liveryRepository.clear();
await this.leagueRepository.clear();
await this.leagueMembershipRepository.clear();
await this.sponsorshipRequestRepository.clear();
await this.sponsorRepository.clear();
this.eventPublisher.clear();
await this.raceRepository.clear();
await this.resultRepository.clear();
await this.standingRepository.clear();
}
}

556
tests/integration/profile/profile-leagues-use-cases.integration.test.ts
View File

@@ -1,556 +0,0 @@
/**
* Integration Test: Profile Leagues Use Case Orchestration
*
* Tests the orchestration logic of profile leagues-related Use Cases:
* - GetProfileLeaguesUseCase: Retrieves driver's league memberships
* - LeaveLeagueUseCase: Allows driver to leave a league from profile
* - GetLeagueDetailsUseCase: Retrieves league details from profile
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - Uses In-Memory adapters for fast, deterministic testing
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemoryDriverRepository } from '../../../adapters/drivers/persistence/inmemory/InMemoryDriverRepository';
import { InMemoryLeagueRepository } from '../../../adapters/leagues/persistence/inmemory/InMemoryLeagueRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetProfileLeaguesUseCase } from '../../../core/profile/use-cases/GetProfileLeaguesUseCase';
import { LeaveLeagueUseCase } from '../../../core/leagues/use-cases/LeaveLeagueUseCase';
import { GetLeagueDetailsUseCase } from '../../../core/leagues/use-cases/GetLeagueDetailsUseCase';
import { ProfileLeaguesQuery } from '../../../core/profile/ports/ProfileLeaguesQuery';
import { LeaveLeagueCommand } from '../../../core/leagues/ports/LeaveLeagueCommand';
import { LeagueDetailsQuery } from '../../../core/leagues/ports/LeagueDetailsQuery';
describe('Profile Leagues Use Case Orchestration', () => {
let driverRepository: InMemoryDriverRepository;
let leagueRepository: InMemoryLeagueRepository;
let eventPublisher: InMemoryEventPublisher;
let getProfileLeaguesUseCase: GetProfileLeaguesUseCase;
let leaveLeagueUseCase: LeaveLeagueUseCase;
let getLeagueDetailsUseCase: GetLeagueDetailsUseCase;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// driverRepository = new InMemoryDriverRepository();
// leagueRepository = new InMemoryLeagueRepository();
// eventPublisher = new InMemoryEventPublisher();
// getProfileLeaguesUseCase = new GetProfileLeaguesUseCase({
// driverRepository,
// leagueRepository,
// eventPublisher,
// });
// leaveLeagueUseCase = new LeaveLeagueUseCase({
// driverRepository,
// leagueRepository,
// eventPublisher,
// });
// getLeagueDetailsUseCase = new GetLeagueDetailsUseCase({
// leagueRepository,
// eventPublisher,
// });
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// driverRepository.clear();
// leagueRepository.clear();
// eventPublisher.clear();
});
describe('GetProfileLeaguesUseCase - Success Path', () => {
it('should retrieve complete list of league memberships', async () => {
// TODO: Implement test
// Scenario: Driver with multiple league memberships
// Given: A driver exists
// And: The driver is a member of 3 leagues
// And: Each league has different status (Active/Inactive)
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should contain all league memberships
// And: Each league should display name, status, and upcoming races
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with minimal data', async () => {
// TODO: Implement test
// Scenario: Driver with minimal league memberships
// Given: A driver exists
// And: The driver is a member of 1 league
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should contain the league membership
// And: The league should display basic information
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with upcoming races', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having upcoming races
// Given: A driver exists
// And: The driver is a member of a league with upcoming races
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show upcoming races for the league
// And: Each race should display track name, date, and time
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league status', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having different statuses
// Given: A driver exists
// And: The driver is a member of an active league
// And: The driver is a member of an inactive league
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show status for each league
// And: Active leagues should be clearly marked
// And: Inactive leagues should be clearly marked
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with member count', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having member counts
// Given: A driver exists
// And: The driver is a member of a league with 50 members
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show member count for the league
// And: The count should be accurate
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with driver role', async () => {
// TODO: Implement test
// Scenario: Driver with different roles in leagues
// Given: A driver exists
// And: The driver is a member of a league as "Member"
// And: The driver is an admin of another league
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show role for each league
// And: The role should be clearly indicated
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league category tags', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having category tags
// Given: A driver exists
// And: The driver is a member of a league with category tags
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show category tags for the league
// And: Tags should include game type, skill level, etc.
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league rating', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having ratings
// Given: A driver exists
// And: The driver is a member of a league with average rating
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show rating for the league
// And: The rating should be displayed as stars or numeric value
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league prize pool', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having prize pools
// Given: A driver exists
// And: The driver is a member of a league with prize pool
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show prize pool for the league
// And: The prize pool should be displayed as currency amount
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league sponsor count', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having sponsors
// Given: A driver exists
// And: The driver is a member of a league with sponsors
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show sponsor count for the league
// And: The count should be accurate
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league race count', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having races
// Given: A driver exists
// And: The driver is a member of a league with races
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show race count for the league
// And: The count should be accurate
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league championship count', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having championships
// Given: A driver exists
// And: The driver is a member of a league with championships
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show championship count for the league
// And: The count should be accurate
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league visibility', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having different visibility
// Given: A driver exists
// And: The driver is a member of a public league
// And: The driver is a member of a private league
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show visibility for each league
// And: The visibility should be clearly indicated
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league creation date', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having creation dates
// Given: A driver exists
// And: The driver is a member of a league created on a specific date
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show creation date for the league
// And: The date should be formatted correctly
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should retrieve league memberships with league owner information', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having owners
// Given: A driver exists
// And: The driver is a member of a league with an owner
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should show owner name for the league
// And: The owner name should be clickable to view profile
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
});
describe('GetProfileLeaguesUseCase - Edge Cases', () => {
it('should handle driver with no league memberships', async () => {
// TODO: Implement test
// Scenario: Driver without league memberships
// Given: A driver exists without league memberships
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should contain empty list
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should handle driver with only active leagues', async () => {
// TODO: Implement test
// Scenario: Driver with only active leagues
// Given: A driver exists
// And: The driver is a member of only active leagues
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should contain only active leagues
// And: All leagues should show Active status
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should handle driver with only inactive leagues', async () => {
// TODO: Implement test
// Scenario: Driver with only inactive leagues
// Given: A driver exists
// And: The driver is a member of only inactive leagues
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should contain only inactive leagues
// And: All leagues should show Inactive status
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should handle driver with leagues having no upcoming races', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having no upcoming races
// Given: A driver exists
// And: The driver is a member of leagues with no upcoming races
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should contain league memberships
// And: Upcoming races section should be empty
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
it('should handle driver with leagues having no sponsors', async () => {
// TODO: Implement test
// Scenario: Driver with leagues having no sponsors
// Given: A driver exists
// And: The driver is a member of leagues with no sponsors
// When: GetProfileLeaguesUseCase.execute() is called with driver ID
// Then: The result should contain league memberships
// And: Sponsor count should be zero
// And: EventPublisher should emit ProfileLeaguesAccessedEvent
});
});
describe('GetProfileLeaguesUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: GetProfileLeaguesUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: GetProfileLeaguesUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during query
// When: GetProfileLeaguesUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('LeaveLeagueUseCase - Success Path', () => {
it('should allow driver to leave a league', async () => {
// TODO: Implement test
// Scenario: Driver leaves a league
// Given: A driver exists
// And: The driver is a member of a league
// When: LeaveLeagueUseCase.execute() is called with driver ID and league ID
// Then: The driver should be removed from the league roster
// And: EventPublisher should emit LeagueLeftEvent
});
it('should allow driver to leave multiple leagues', async () => {
// TODO: Implement test
// Scenario: Driver leaves multiple leagues
// Given: A driver exists
// And: The driver is a member of 3 leagues
// When: LeaveLeagueUseCase.execute() is called for each league
// Then: The driver should be removed from all league rosters
// And: EventPublisher should emit LeagueLeftEvent for each league
});
it('should allow admin to leave league', async () => {
// TODO: Implement test
// Scenario: Admin leaves a league
// Given: A driver exists as admin of a league
// When: LeaveLeagueUseCase.execute() is called with admin driver ID and league ID
// Then: The admin should be removed from the league roster
// And: EventPublisher should emit LeagueLeftEvent
});
it('should allow owner to leave league', async () => {
// TODO: Implement test
// Scenario: Owner leaves a league
// Given: A driver exists as owner of a league
// When: LeaveLeagueUseCase.execute() is called with owner driver ID and league ID
// Then: The owner should be removed from the league roster
// And: EventPublisher should emit LeagueLeftEvent
});
});
describe('LeaveLeagueUseCase - Validation', () => {
it('should reject leaving league when driver is not a member', async () => {
// TODO: Implement test
// Scenario: Driver not a member of league
// Given: A driver exists
// And: The driver is not a member of a league
// When: LeaveLeagueUseCase.execute() is called with driver ID and league ID
// Then: Should throw NotMemberError
// And: EventPublisher should NOT emit any events
});
it('should reject leaving league with invalid league ID', async () => {
// TODO: Implement test
// Scenario: Invalid league ID
// Given: A driver exists
// When: LeaveLeagueUseCase.execute() is called with invalid league ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('LeaveLeagueUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: LeaveLeagueUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when league does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent league
// Given: A driver exists
// And: No league exists with the given ID
// When: LeaveLeagueUseCase.execute() is called with non-existent league ID
// Then: Should throw LeagueNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: LeagueRepository throws an error during update
// When: LeaveLeagueUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('GetLeagueDetailsUseCase - Success Path', () => {
it('should retrieve complete league details', async () => {
// TODO: Implement test
// Scenario: League with complete details
// Given: A league exists with complete information
// And: The league has name, status, members, races, championships
// When: GetLeagueDetailsUseCase.execute() is called with league ID
// Then: The result should contain all league details
// And: EventPublisher should emit LeagueDetailsAccessedEvent
});
it('should retrieve league details with minimal information', async () => {
// TODO: Implement test
// Scenario: League with minimal details
// Given: A league exists with minimal information
// And: The league has only name and status
// When: GetLeagueDetailsUseCase.execute() is called with league ID
// Then: The result should contain basic league details
// And: EventPublisher should emit LeagueDetailsAccessedEvent
});
it('should retrieve league details with upcoming races', async () => {
// TODO: Implement test
// Scenario: League with upcoming races
// Given: A league exists with upcoming races
// When: GetLeagueDetailsUseCase.execute() is called with league ID
// Then: The result should show upcoming races
// And: Each race should display track name, date, and time
// And: EventPublisher should emit LeagueDetailsAccessedEvent
});
it('should retrieve league details with member list', async () => {
// TODO: Implement test
// Scenario: League with member list
// Given: A league exists with members
// When: GetLeagueDetailsUseCase.execute() is called with league ID
// Then: The result should show member list
// And: Each member should display name and role
// And: EventPublisher should emit LeagueDetailsAccessedEvent
});
});
describe('GetLeagueDetailsUseCase - Error Handling', () => {
it('should throw error when league does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent league
// Given: No league exists with the given ID
// When: GetLeagueDetailsUseCase.execute() is called with non-existent league ID
// Then: Should throw LeagueNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when league ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid league ID
// Given: An invalid league ID (e.g., empty string, null, undefined)
// When: GetLeagueDetailsUseCase.execute() is called with invalid league ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('Profile Leagues Data Orchestration', () => {
it('should correctly format league status with visual cues', async () => {
// TODO: Implement test
// Scenario: League status formatting
// Given: A driver exists
// And: The driver is a member of an active league
// And: The driver is a member of an inactive league
// When: GetProfileLeaguesUseCase.execute() is called
// Then: Active leagues should show "Active" status with green indicator
// And: Inactive leagues should show "Inactive" status with gray indicator
});
it('should correctly format upcoming races with proper details', async () => {
// TODO: Implement test
// Scenario: Upcoming races formatting
// Given: A driver exists
// And: The driver is a member of a league with upcoming races
// When: GetProfileLeaguesUseCase.execute() is called
// Then: Upcoming races should show:
// - Track name
// - Race date and time (formatted correctly)
// - Race type (if available)
});
it('should correctly format league rating with stars or numeric value', async () => {
// TODO: Implement test
// Scenario: League rating formatting
// Given: A driver exists
// And: The driver is a member of a league with rating 4.5
// When: GetProfileLeaguesUseCase.execute() is called
// Then: League rating should show as stars (4.5/5) or numeric value (4.5)
});
it('should correctly format league prize pool as currency', async () => {
// TODO: Implement test
// Scenario: League prize pool formatting
// Given: A driver exists
// And: The driver is a member of a league with prize pool $1000
// When: GetProfileLeaguesUseCase.execute() is called
// Then: League prize pool should show as "$1,000" or "1000 USD"
});
it('should correctly format league creation date', async () => {
// TODO: Implement test
// Scenario: League creation date formatting
// Given: A driver exists
// And: The driver is a member of a league created on 2024-01-15
// When: GetProfileLeaguesUseCase.execute() is called
// Then: League creation date should show as "January 15, 2024" or similar format
});
it('should correctly identify driver role in each league', async () => {
// TODO: Implement test
// Scenario: Driver role identification
// Given: A driver exists
// And: The driver is a member of League A as "Member"
// And: The driver is an admin of League B
// And: The driver is the owner of League C
// When: GetProfileLeaguesUseCase.execute() is called
// Then: League A should show role "Member"
// And: League B should show role "Admin"
// And: League C should show role "Owner"
});
it('should correctly filter leagues by status', async () => {
// TODO: Implement test
// Scenario: League filtering by status
// Given: A driver exists
// And: The driver is a member of 2 active leagues and 1 inactive league
// When: GetProfileLeaguesUseCase.execute() is called with status filter "Active"
// Then: The result should show only the 2 active leagues
// And: The inactive league should be hidden
});
it('should correctly search leagues by name', async () => {
// TODO: Implement test
// Scenario: League search by name
// Given: A driver exists
// And: The driver is a member of "European GT League" and "Formula League"
// When: GetProfileLeaguesUseCase.execute() is called with search term "European"
// Then: The result should show only "European GT League"
// And: "Formula League" should be hidden
});
});
});

518
tests/integration/profile/profile-liveries-use-cases.integration.test.ts
View File

@@ -1,518 +0,0 @@
/**
* Integration Test: Profile Liveries Use Case Orchestration
*
* Tests the orchestration logic of profile liveries-related Use Cases:
* - GetProfileLiveriesUseCase: Retrieves driver's uploaded liveries
* - GetLiveryDetailsUseCase: Retrieves livery details
* - DeleteLiveryUseCase: Deletes a livery
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - Uses In-Memory adapters for fast, deterministic testing
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemoryDriverRepository } from '../../../adapters/drivers/persistence/inmemory/InMemoryDriverRepository';
import { InMemoryLiveryRepository } from '../../../adapters/media/persistence/inmemory/InMemoryLiveryRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetProfileLiveriesUseCase } from '../../../core/profile/use-cases/GetProfileLiveriesUseCase';
import { GetLiveryDetailsUseCase } from '../../../core/media/use-cases/GetLiveryDetailsUseCase';
import { DeleteLiveryUseCase } from '../../../core/media/use-cases/DeleteLiveryUseCase';
import { ProfileLiveriesQuery } from '../../../core/profile/ports/ProfileLiveriesQuery';
import { LiveryDetailsQuery } from '../../../core/media/ports/LiveryDetailsQuery';
import { DeleteLiveryCommand } from '../../../core/media/ports/DeleteLiveryCommand';
describe('Profile Liveries Use Case Orchestration', () => {
let driverRepository: InMemoryDriverRepository;
let liveryRepository: InMemoryLiveryRepository;
let eventPublisher: InMemoryEventPublisher;
let getProfileLiveriesUseCase: GetProfileLiveriesUseCase;
let getLiveryDetailsUseCase: GetLiveryDetailsUseCase;
let deleteLiveryUseCase: DeleteLiveryUseCase;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// driverRepository = new InMemoryDriverRepository();
// liveryRepository = new InMemoryLiveryRepository();
// eventPublisher = new InMemoryEventPublisher();
// getProfileLiveriesUseCase = new GetProfileLiveriesUseCase({
// driverRepository,
// liveryRepository,
// eventPublisher,
// });
// getLiveryDetailsUseCase = new GetLiveryDetailsUseCase({
// liveryRepository,
// eventPublisher,
// });
// deleteLiveryUseCase = new DeleteLiveryUseCase({
// driverRepository,
// liveryRepository,
// eventPublisher,
// });
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// driverRepository.clear();
// liveryRepository.clear();
// eventPublisher.clear();
});
describe('GetProfileLiveriesUseCase - Success Path', () => {
it('should retrieve complete list of uploaded liveries', async () => {
// TODO: Implement test
// Scenario: Driver with multiple liveries
// Given: A driver exists
// And: The driver has uploaded 3 liveries
// And: Each livery has different validation status (Validated/Pending)
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should contain all liveries
// And: Each livery should display car name, thumbnail, and validation status
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with minimal data', async () => {
// TODO: Implement test
// Scenario: Driver with minimal liveries
// Given: A driver exists
// And: The driver has uploaded 1 livery
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should contain the livery
// And: The livery should display basic information
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with validation status', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having different validation statuses
// Given: A driver exists
// And: The driver has a validated livery
// And: The driver has a pending livery
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show validation status for each livery
// And: Validated liveries should be clearly marked
// And: Pending liveries should be clearly marked
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with upload date', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having upload dates
// Given: A driver exists
// And: The driver has liveries uploaded on different dates
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show upload date for each livery
// And: The date should be formatted correctly
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with car name', async () => {
// TODO: Implement test
// Scenario: Driver with liveries for different cars
// Given: A driver exists
// And: The driver has liveries for Porsche 911 GT3, Ferrari 488, etc.
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show car name for each livery
// And: The car name should be accurate
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with car ID', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having car IDs
// Given: A driver exists
// And: The driver has liveries with car IDs
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show car ID for each livery
// And: The car ID should be accurate
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with livery preview', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having previews
// Given: A driver exists
// And: The driver has liveries with preview images
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show preview image for each livery
// And: The preview should be accessible
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with file metadata', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having file metadata
// Given: A driver exists
// And: The driver has liveries with file size, format, etc.
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show file metadata for each livery
// And: Metadata should include file size, format, and upload date
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with file size', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having file sizes
// Given: A driver exists
// And: The driver has liveries with different file sizes
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show file size for each livery
// And: The file size should be formatted correctly (e.g., MB, KB)
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with file format', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having different file formats
// Given: A driver exists
// And: The driver has liveries in PNG, DDS, etc. formats
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show file format for each livery
// And: The format should be clearly indicated
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should retrieve liveries with error state', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having error state
// Given: A driver exists
// And: The driver has a livery that failed to load
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should show error state for the livery
// And: The livery should show error placeholder
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
});
describe('GetProfileLiveriesUseCase - Edge Cases', () => {
it('should handle driver with no liveries', async () => {
// TODO: Implement test
// Scenario: Driver without liveries
// Given: A driver exists without liveries
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should contain empty list
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should handle driver with only validated liveries', async () => {
// TODO: Implement test
// Scenario: Driver with only validated liveries
// Given: A driver exists
// And: The driver has only validated liveries
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should contain only validated liveries
// And: All liveries should show Validated status
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should handle driver with only pending liveries', async () => {
// TODO: Implement test
// Scenario: Driver with only pending liveries
// Given: A driver exists
// And: The driver has only pending liveries
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should contain only pending liveries
// And: All liveries should show Pending status
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should handle driver with liveries having no preview', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having no preview
// Given: A driver exists
// And: The driver has liveries without preview images
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should contain liveries
// And: Preview section should show placeholder
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
it('should handle driver with liveries having no metadata', async () => {
// TODO: Implement test
// Scenario: Driver with liveries having no metadata
// Given: A driver exists
// And: The driver has liveries without file metadata
// When: GetProfileLiveriesUseCase.execute() is called with driver ID
// Then: The result should contain liveries
// And: Metadata section should be empty
// And: EventPublisher should emit ProfileLiveriesAccessedEvent
});
});
describe('GetProfileLiveriesUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: GetProfileLiveriesUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: GetProfileLiveriesUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during query
// When: GetProfileLiveriesUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('GetLiveryDetailsUseCase - Success Path', () => {
it('should retrieve complete livery details', async () => {
// TODO: Implement test
// Scenario: Livery with complete details
// Given: A livery exists with complete information
// And: The livery has car name, car ID, validation status, upload date
// And: The livery has file size, format, preview
// When: GetLiveryDetailsUseCase.execute() is called with livery ID
// Then: The result should contain all livery details
// And: EventPublisher should emit LiveryDetailsAccessedEvent
});
it('should retrieve livery details with minimal information', async () => {
// TODO: Implement test
// Scenario: Livery with minimal details
// Given: A livery exists with minimal information
// And: The livery has only car name and validation status
// When: GetLiveryDetailsUseCase.execute() is called with livery ID
// Then: The result should contain basic livery details
// And: EventPublisher should emit LiveryDetailsAccessedEvent
});
it('should retrieve livery details with validation status', async () => {
// TODO: Implement test
// Scenario: Livery with validation status
// Given: A livery exists with validation status
// When: GetLiveryDetailsUseCase.execute() is called with livery ID
// Then: The result should show validation status
// And: The status should be clearly indicated
// And: EventPublisher should emit LiveryDetailsAccessedEvent
});
it('should retrieve livery details with file metadata', async () => {
// TODO: Implement test
// Scenario: Livery with file metadata
// Given: A livery exists with file metadata
// When: GetLiveryDetailsUseCase.execute() is called with livery ID
// Then: The result should show file metadata
// And: Metadata should include file size, format, and upload date
// And: EventPublisher should emit LiveryDetailsAccessedEvent
});
it('should retrieve livery details with preview', async () => {
// TODO: Implement test
// Scenario: Livery with preview
// Given: A livery exists with preview image
// When: GetLiveryDetailsUseCase.execute() is called with livery ID
// Then: The result should show preview image
// And: The preview should be accessible
// And: EventPublisher should emit LiveryDetailsAccessedEvent
});
});
describe('GetLiveryDetailsUseCase - Error Handling', () => {
it('should throw error when livery does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent livery
// Given: No livery exists with the given ID
// When: GetLiveryDetailsUseCase.execute() is called with non-existent livery ID
// Then: Should throw LiveryNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when livery ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid livery ID
// Given: An invalid livery ID (e.g., empty string, null, undefined)
// When: GetLiveryDetailsUseCase.execute() is called with invalid livery ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('DeleteLiveryUseCase - Success Path', () => {
it('should allow driver to delete a livery', async () => {
// TODO: Implement test
// Scenario: Driver deletes a livery
// Given: A driver exists
// And: The driver has uploaded a livery
// When: DeleteLiveryUseCase.execute() is called with driver ID and livery ID
// Then: The livery should be removed from the driver's list
// And: EventPublisher should emit LiveryDeletedEvent
});
it('should allow driver to delete multiple liveries', async () => {
// TODO: Implement test
// Scenario: Driver deletes multiple liveries
// Given: A driver exists
// And: The driver has uploaded 3 liveries
// When: DeleteLiveryUseCase.execute() is called for each livery
// Then: All liveries should be removed from the driver's list
// And: EventPublisher should emit LiveryDeletedEvent for each livery
});
it('should allow driver to delete validated livery', async () => {
// TODO: Implement test
// Scenario: Driver deletes validated livery
// Given: A driver exists
// And: The driver has a validated livery
// When: DeleteLiveryUseCase.execute() is called with driver ID and livery ID
// Then: The validated livery should be removed
// And: EventPublisher should emit LiveryDeletedEvent
});
it('should allow driver to delete pending livery', async () => {
// TODO: Implement test
// Scenario: Driver deletes pending livery
// Given: A driver exists
// And: The driver has a pending livery
// When: DeleteLiveryUseCase.execute() is called with driver ID and livery ID
// Then: The pending livery should be removed
// And: EventPublisher should emit LiveryDeletedEvent
});
});
describe('DeleteLiveryUseCase - Validation', () => {
it('should reject deleting livery when driver is not owner', async () => {
// TODO: Implement test
// Scenario: Driver not owner of livery
// Given: A driver exists
// And: The driver is not the owner of a livery
// When: DeleteLiveryUseCase.execute() is called with driver ID and livery ID
// Then: Should throw NotOwnerError
// And: EventPublisher should NOT emit any events
});
it('should reject deleting livery with invalid livery ID', async () => {
// TODO: Implement test
// Scenario: Invalid livery ID
// Given: A driver exists
// When: DeleteLiveryUseCase.execute() is called with invalid livery ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('DeleteLiveryUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: DeleteLiveryUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when livery does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent livery
// Given: A driver exists
// And: No livery exists with the given ID
// When: DeleteLiveryUseCase.execute() is called with non-existent livery ID
// Then: Should throw LiveryNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: LiveryRepository throws an error during delete
// When: DeleteLiveryUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('Profile Liveries Data Orchestration', () => {
it('should correctly format validation status with visual cues', async () => {
// TODO: Implement test
// Scenario: Livery validation status formatting
// Given: A driver exists
// And: The driver has a validated livery
// And: The driver has a pending livery
// When: GetProfileLiveriesUseCase.execute() is called
// Then: Validated liveries should show "Validated" status with green indicator
// And: Pending liveries should show "Pending" status with yellow indicator
});
it('should correctly format upload date', async () => {
// TODO: Implement test
// Scenario: Livery upload date formatting
// Given: A driver exists
// And: The driver has a livery uploaded on 2024-01-15
// When: GetProfileLiveriesUseCase.execute() is called
// Then: Upload date should show as "January 15, 2024" or similar format
});
it('should correctly format file size', async () => {
// TODO: Implement test
// Scenario: Livery file size formatting
// Given: A driver exists
// And: The driver has a livery with file size 5242880 bytes (5 MB)
// When: GetProfileLiveriesUseCase.execute() is called
// Then: File size should show as "5 MB" or "5.0 MB"
});
it('should correctly format file format', async () => {
// TODO: Implement test
// Scenario: Livery file format formatting
// Given: A driver exists
// And: The driver has liveries in PNG and DDS formats
// When: GetProfileLiveriesUseCase.execute() is called
// Then: File format should show as "PNG" or "DDS"
});
it('should correctly filter liveries by validation status', async () => {
// TODO: Implement test
// Scenario: Livery filtering by validation status
// Given: A driver exists
// And: The driver has 2 validated liveries and 1 pending livery
// When: GetProfileLiveriesUseCase.execute() is called with status filter "Validated"
// Then: The result should show only the 2 validated liveries
// And: The pending livery should be hidden
});
it('should correctly search liveries by car name', async () => {
// TODO: Implement test
// Scenario: Livery search by car name
// Given: A driver exists
// And: The driver has liveries for "Porsche 911 GT3" and "Ferrari 488"
// When: GetProfileLiveriesUseCase.execute() is called with search term "Porsche"
// Then: The result should show only "Porsche 911 GT3" livery
// And: "Ferrari 488" livery should be hidden
});
it('should correctly identify livery owner', async () => {
// TODO: Implement test
// Scenario: Livery owner identification
// Given: A driver exists
// And: The driver has uploaded a livery
// When: GetProfileLiveriesUseCase.execute() is called
// Then: The livery should be associated with the driver
// And: The driver should be able to delete the livery
});
it('should correctly handle livery error state', async () => {
// TODO: Implement test
// Scenario: Livery error state handling
// Given: A driver exists
// And: The driver has a livery that failed to load
// When: GetProfileLiveriesUseCase.execute() is called
// Then: The livery should show error state
// And: The livery should show retry option
});
});
});

654
tests/integration/profile/profile-main-use-cases.integration.test.ts
View File

@@ -1,654 +0,0 @@
/**
* Integration Test: Profile Main Use Case Orchestration
*
* Tests the orchestration logic of profile-related Use Cases:
* - GetProfileUseCase: Retrieves driver's profile information
* - GetProfileStatisticsUseCase: Retrieves driver's statistics and achievements
* - GetProfileCompletionUseCase: Calculates profile completion percentage
* - UpdateProfileUseCase: Updates driver's profile information
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - Uses In-Memory adapters for fast, deterministic testing
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemoryDriverRepository } from '../../../adapters/drivers/persistence/inmemory/InMemoryDriverRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetProfileUseCase } from '../../../core/profile/use-cases/GetProfileUseCase';
import { GetProfileStatisticsUseCase } from '../../../core/profile/use-cases/GetProfileStatisticsUseCase';
import { GetProfileCompletionUseCase } from '../../../core/profile/use-cases/GetProfileCompletionUseCase';
import { UpdateProfileUseCase } from '../../../core/profile/use-cases/UpdateProfileUseCase';
import { ProfileQuery } from '../../../core/profile/ports/ProfileQuery';
import { ProfileStatisticsQuery } from '../../../core/profile/ports/ProfileStatisticsQuery';
import { ProfileCompletionQuery } from '../../../core/profile/ports/ProfileCompletionQuery';
import { UpdateProfileCommand } from '../../../core/profile/ports/UpdateProfileCommand';
describe('Profile Main Use Case Orchestration', () => {
let driverRepository: InMemoryDriverRepository;
let eventPublisher: InMemoryEventPublisher;
let getProfileUseCase: GetProfileUseCase;
let getProfileStatisticsUseCase: GetProfileStatisticsUseCase;
let getProfileCompletionUseCase: GetProfileCompletionUseCase;
let updateProfileUseCase: UpdateProfileUseCase;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// driverRepository = new InMemoryDriverRepository();
// eventPublisher = new InMemoryEventPublisher();
// getProfileUseCase = new GetProfileUseCase({
// driverRepository,
// eventPublisher,
// });
// getProfileStatisticsUseCase = new GetProfileStatisticsUseCase({
// driverRepository,
// eventPublisher,
// });
// getProfileCompletionUseCase = new GetProfileCompletionUseCase({
// driverRepository,
// eventPublisher,
// });
// updateProfileUseCase = new UpdateProfileUseCase({
// driverRepository,
// eventPublisher,
// });
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// driverRepository.clear();
// eventPublisher.clear();
});
describe('GetProfileUseCase - Success Path', () => {
it('should retrieve complete driver profile with all personal information', async () => {
// TODO: Implement test
// Scenario: Driver with complete profile
// Given: A driver exists with complete personal information
// And: The driver has name, email, avatar, bio, location
// And: The driver has social links configured
// And: The driver has team affiliation
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain all driver information
// And: The result should display name, email, avatar, bio, location
// And: The result should display social links
// And: The result should display team affiliation
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should retrieve driver profile with minimal information', async () => {
// TODO: Implement test
// Scenario: Driver with minimal profile
// Given: A driver exists with minimal information
// And: The driver has only name and email
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain basic driver information
// And: The result should display name and email
// And: The result should show empty values for optional fields
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should retrieve driver profile with avatar', async () => {
// TODO: Implement test
// Scenario: Driver with avatar
// Given: A driver exists with an avatar
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain avatar URL
// And: The avatar should be accessible
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should retrieve driver profile with social links', async () => {
// TODO: Implement test
// Scenario: Driver with social links
// Given: A driver exists with social links
// And: The driver has Discord, Twitter, iRacing links
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain social links
// And: Each link should have correct URL format
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should retrieve driver profile with team affiliation', async () => {
// TODO: Implement test
// Scenario: Driver with team affiliation
// Given: A driver exists with team affiliation
// And: The driver is affiliated with Team XYZ
// And: The driver has role "Driver"
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain team information
// And: The result should show team name and logo
// And: The result should show driver role
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should retrieve driver profile with bio', async () => {
// TODO: Implement test
// Scenario: Driver with bio
// Given: A driver exists with a bio
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain bio text
// And: The bio should be displayed correctly
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should retrieve driver profile with location', async () => {
// TODO: Implement test
// Scenario: Driver with location
// Given: A driver exists with location
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain location
// And: The location should be displayed correctly
// And: EventPublisher should emit ProfileAccessedEvent
});
});
describe('GetProfileUseCase - Edge Cases', () => {
it('should handle driver with no avatar', async () => {
// TODO: Implement test
// Scenario: Driver without avatar
// Given: A driver exists without avatar
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain driver information
// And: The result should show default avatar or placeholder
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should handle driver with no social links', async () => {
// TODO: Implement test
// Scenario: Driver without social links
// Given: A driver exists without social links
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain driver information
// And: The result should show empty social links section
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should handle driver with no team affiliation', async () => {
// TODO: Implement test
// Scenario: Driver without team affiliation
// Given: A driver exists without team affiliation
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain driver information
// And: The result should show empty team section
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should handle driver with no bio', async () => {
// TODO: Implement test
// Scenario: Driver without bio
// Given: A driver exists without bio
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain driver information
// And: The result should show empty bio section
// And: EventPublisher should emit ProfileAccessedEvent
});
it('should handle driver with no location', async () => {
// TODO: Implement test
// Scenario: Driver without location
// Given: A driver exists without location
// When: GetProfileUseCase.execute() is called with driver ID
// Then: The result should contain driver information
// And: The result should show empty location section
// And: EventPublisher should emit ProfileAccessedEvent
});
});
describe('GetProfileUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: GetProfileUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: GetProfileUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during query
// When: GetProfileUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('GetProfileStatisticsUseCase - Success Path', () => {
it('should retrieve complete driver statistics', async () => {
// TODO: Implement test
// Scenario: Driver with complete statistics
// Given: A driver exists with complete statistics
// And: The driver has rating, rank, starts, wins, podiums
// And: The driver has win percentage
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should contain all statistics
// And: The result should display rating, rank, starts, wins, podiums
// And: The result should display win percentage
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
it('should retrieve driver statistics with minimal data', async () => {
// TODO: Implement test
// Scenario: Driver with minimal statistics
// Given: A driver exists with minimal statistics
// And: The driver has only rating and rank
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should contain basic statistics
// And: The result should display rating and rank
// And: The result should show zero values for other statistics
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
it('should retrieve driver statistics with win percentage calculation', async () => {
// TODO: Implement test
// Scenario: Driver with win percentage
// Given: A driver exists with 10 starts and 3 wins
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should show win percentage as 30%
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
it('should retrieve driver statistics with podium rate calculation', async () => {
// TODO: Implement test
// Scenario: Driver with podium rate
// Given: A driver exists with 10 starts and 5 podiums
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should show podium rate as 50%
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
it('should retrieve driver statistics with rating trend', async () => {
// TODO: Implement test
// Scenario: Driver with rating trend
// Given: A driver exists with rating trend data
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should show rating trend
// And: The trend should show improvement or decline
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
it('should retrieve driver statistics with rank trend', async () => {
// TODO: Implement test
// Scenario: Driver with rank trend
// Given: A driver exists with rank trend data
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should show rank trend
// And: The trend should show improvement or decline
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
it('should retrieve driver statistics with points trend', async () => {
// TODO: Implement test
// Scenario: Driver with points trend
// Given: A driver exists with points trend data
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should show points trend
// And: The trend should show improvement or decline
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
});
describe('GetProfileStatisticsUseCase - Edge Cases', () => {
it('should handle driver with no statistics', async () => {
// TODO: Implement test
// Scenario: Driver without statistics
// Given: A driver exists without statistics
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should contain default statistics
// And: All values should be zero or default
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
it('should handle driver with no race history', async () => {
// TODO: Implement test
// Scenario: Driver without race history
// Given: A driver exists without race history
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should contain statistics with zero values
// And: Win percentage should be 0%
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
it('should handle driver with no trend data', async () => {
// TODO: Implement test
// Scenario: Driver without trend data
// Given: A driver exists without trend data
// When: GetProfileStatisticsUseCase.execute() is called with driver ID
// Then: The result should contain statistics
// And: Trend sections should be empty
// And: EventPublisher should emit ProfileStatisticsAccessedEvent
});
});
describe('GetProfileStatisticsUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: GetProfileStatisticsUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: GetProfileStatisticsUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('GetProfileCompletionUseCase - Success Path', () => {
it('should calculate profile completion for complete profile', async () => {
// TODO: Implement test
// Scenario: Complete profile
// Given: A driver exists with complete profile
// And: The driver has all required fields filled
// And: The driver has avatar, bio, location, social links
// When: GetProfileCompletionUseCase.execute() is called with driver ID
// Then: The result should show 100% completion
// And: The result should show no incomplete sections
// And: EventPublisher should emit ProfileCompletionCalculatedEvent
});
it('should calculate profile completion for partial profile', async () => {
// TODO: Implement test
// Scenario: Partial profile
// Given: A driver exists with partial profile
// And: The driver has name and email only
// And: The driver is missing avatar, bio, location, social links
// When: GetProfileCompletionUseCase.execute() is called with driver ID
// Then: The result should show less than 100% completion
// And: The result should show incomplete sections
// And: EventPublisher should emit ProfileCompletionCalculatedEvent
});
it('should calculate profile completion for minimal profile', async () => {
// TODO: Implement test
// Scenario: Minimal profile
// Given: A driver exists with minimal profile
// And: The driver has only name and email
// When: GetProfileCompletionUseCase.execute() is called with driver ID
// Then: The result should show low completion percentage
// And: The result should show many incomplete sections
// And: EventPublisher should emit ProfileCompletionCalculatedEvent
});
it('should calculate profile completion with suggestions', async () => {
// TODO: Implement test
// Scenario: Profile with suggestions
// Given: A driver exists with partial profile
// When: GetProfileCompletionUseCase.execute() is called with driver ID
// Then: The result should show completion percentage
// And: The result should show suggestions for completion
// And: The result should show which sections are incomplete
// And: EventPublisher should emit ProfileCompletionCalculatedEvent
});
});
describe('GetProfileCompletionUseCase - Edge Cases', () => {
it('should handle driver with no profile data', async () => {
// TODO: Implement test
// Scenario: Driver without profile data
// Given: A driver exists without profile data
// When: GetProfileCompletionUseCase.execute() is called with driver ID
// Then: The result should show 0% completion
// And: The result should show all sections as incomplete
// And: EventPublisher should emit ProfileCompletionCalculatedEvent
});
it('should handle driver with only required fields', async () => {
// TODO: Implement test
// Scenario: Driver with only required fields
// Given: A driver exists with only required fields
// And: The driver has name and email only
// When: GetProfileCompletionUseCase.execute() is called with driver ID
// Then: The result should show partial completion
// And: The result should show required fields as complete
// And: The result should show optional fields as incomplete
// And: EventPublisher should emit ProfileCompletionCalculatedEvent
});
});
describe('GetProfileCompletionUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: GetProfileCompletionUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: GetProfileCompletionUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('UpdateProfileUseCase - Success Path', () => {
it('should update driver name', async () => {
// TODO: Implement test
// Scenario: Update driver name
// Given: A driver exists with name "John Doe"
// When: UpdateProfileUseCase.execute() is called with new name "Jane Doe"
// Then: The driver's name should be updated to "Jane Doe"
// And: EventPublisher should emit ProfileUpdatedEvent
});
it('should update driver email', async () => {
// TODO: Implement test
// Scenario: Update driver email
// Given: A driver exists with email "john@example.com"
// When: UpdateProfileUseCase.execute() is called with new email "jane@example.com"
// Then: The driver's email should be updated to "jane@example.com"
// And: EventPublisher should emit ProfileUpdatedEvent
});
it('should update driver bio', async () => {
// TODO: Implement test
// Scenario: Update driver bio
// Given: A driver exists with bio "Original bio"
// When: UpdateProfileUseCase.execute() is called with new bio "Updated bio"
// Then: The driver's bio should be updated to "Updated bio"
// And: EventPublisher should emit ProfileUpdatedEvent
});
it('should update driver location', async () => {
// TODO: Implement test
// Scenario: Update driver location
// Given: A driver exists with location "USA"
// When: UpdateProfileUseCase.execute() is called with new location "Germany"
// Then: The driver's location should be updated to "Germany"
// And: EventPublisher should emit ProfileUpdatedEvent
});
it('should update driver avatar', async () => {
// TODO: Implement test
// Scenario: Update driver avatar
// Given: A driver exists with avatar "avatar1.jpg"
// When: UpdateProfileUseCase.execute() is called with new avatar "avatar2.jpg"
// Then: The driver's avatar should be updated to "avatar2.jpg"
// And: EventPublisher should emit ProfileUpdatedEvent
});
it('should update driver social links', async () => {
// TODO: Implement test
// Scenario: Update driver social links
// Given: A driver exists with social links
// When: UpdateProfileUseCase.execute() is called with new social links
// Then: The driver's social links should be updated
// And: EventPublisher should emit ProfileUpdatedEvent
});
it('should update driver team affiliation', async () => {
// TODO: Implement test
// Scenario: Update driver team affiliation
// Given: A driver exists with team affiliation "Team A"
// When: UpdateProfileUseCase.execute() is called with new team affiliation "Team B"
// Then: The driver's team affiliation should be updated to "Team B"
// And: EventPublisher should emit ProfileUpdatedEvent
});
it('should update multiple profile fields at once', async () => {
// TODO: Implement test
// Scenario: Update multiple fields
// Given: A driver exists with name "John Doe" and email "john@example.com"
// When: UpdateProfileUseCase.execute() is called with new name "Jane Doe" and new email "jane@example.com"
// Then: The driver's name should be updated to "Jane Doe"
// And: The driver's email should be updated to "jane@example.com"
// And: EventPublisher should emit ProfileUpdatedEvent
});
});
describe('UpdateProfileUseCase - Validation', () => {
it('should reject update with invalid email format', async () => {
// TODO: Implement test
// Scenario: Invalid email format
// Given: A driver exists
// When: UpdateProfileUseCase.execute() is called with invalid email "invalid-email"
// Then: Should throw ValidationError
// And: The driver's email should NOT be updated
// And: EventPublisher should NOT emit any events
});
it('should reject update with empty required fields', async () => {
// TODO: Implement test
// Scenario: Empty required fields
// Given: A driver exists
// When: UpdateProfileUseCase.execute() is called with empty name
// Then: Should throw ValidationError
// And: The driver's name should NOT be updated
// And: EventPublisher should NOT emit any events
});
it('should reject update with invalid avatar file', async () => {
// TODO: Implement test
// Scenario: Invalid avatar file
// Given: A driver exists
// When: UpdateProfileUseCase.execute() is called with invalid avatar file
// Then: Should throw ValidationError
// And: The driver's avatar should NOT be updated
// And: EventPublisher should NOT emit any events
});
});
describe('UpdateProfileUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: UpdateProfileUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: UpdateProfileUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during update
// When: UpdateProfileUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('Profile Data Orchestration', () => {
it('should correctly calculate win percentage from race results', async () => {
// TODO: Implement test
// Scenario: Win percentage calculation
// Given: A driver exists
// And: The driver has 10 race starts
// And: The driver has 3 wins
// When: GetProfileStatisticsUseCase.execute() is called
// Then: The result should show win percentage as 30%
});
it('should correctly calculate podium rate from race results', async () => {
// TODO: Implement test
// Scenario: Podium rate calculation
// Given: A driver exists
// And: The driver has 10 race starts
// And: The driver has 5 podiums
// When: GetProfileStatisticsUseCase.execute() is called
// Then: The result should show podium rate as 50%
});
it('should correctly format social links with proper URLs', async () => {
// TODO: Implement test
// Scenario: Social links formatting
// Given: A driver exists
// And: The driver has social links (Discord, Twitter, iRacing)
// When: GetProfileUseCase.execute() is called
// Then: Social links should show:
// - Discord: https://discord.gg/username
// - Twitter: https://twitter.com/username
// - iRacing: https://members.iracing.com/membersite/member/profile?username=username
});
it('should correctly format team affiliation with role', async () => {
// TODO: Implement test
// Scenario: Team affiliation formatting
// Given: A driver exists
// And: The driver is affiliated with Team XYZ
// And: The driver's role is "Driver"
// When: GetProfileUseCase.execute() is called
// Then: Team affiliation should show:
// - Team name: Team XYZ
// - Team logo: (if available)
// - Driver role: Driver
});
it('should correctly calculate profile completion percentage', async () => {
// TODO: Implement test
// Scenario: Profile completion calculation
// Given: A driver exists
// And: The driver has name, email, avatar, bio, location, social links
// When: GetProfileCompletionUseCase.execute() is called
// Then: The result should show 100% completion
// And: The result should show no incomplete sections
});
it('should correctly identify incomplete profile sections', async () => {
// TODO: Implement test
// Scenario: Incomplete profile sections
// Given: A driver exists
// And: The driver has name and email only
// When: GetProfileCompletionUseCase.execute() is called
// Then: The result should show incomplete sections:
// - Avatar
// - Bio
// - Location
// - Social links
// - Team affiliation
});
});
});

968
tests/integration/profile/profile-overview-use-cases.integration.test.ts
View File

@@ -1,968 +0,0 @@
/**
* Integration Test: Profile Overview Use Case Orchestration
*
* Tests the orchestration logic of profile overview-related Use Cases:
* - GetProfileOverviewUseCase: Retrieves driver's profile overview with stats, team memberships, and social summary
* - UpdateDriverProfileUseCase: Updates driver's profile information
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - Uses In-Memory adapters for fast, deterministic testing
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
import { InMemoryTeamRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamRepository';
import { InMemoryTeamMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamMembershipRepository';
import { InMemorySocialGraphRepository } from '../../../adapters/social/persistence/inmemory/InMemorySocialAndFeed';
import { InMemoryDriverStatsRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverStatsRepository';
import { InMemoryDriverExtendedProfileProvider } from '../../../adapters/racing/ports/InMemoryDriverExtendedProfileProvider';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { InMemoryResultRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryResultRepository';
import { InMemoryStandingRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryStandingRepository';
import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
import { GetProfileOverviewUseCase } from '../../../core/racing/application/use-cases/GetProfileOverviewUseCase';
import { UpdateDriverProfileUseCase } from '../../../core/racing/application/use-cases/UpdateDriverProfileUseCase';
import { DriverStatsUseCase } from '../../../core/racing/application/use-cases/DriverStatsUseCase';
import { RankingUseCase } from '../../../core/racing/application/use-cases/RankingUseCase';
import { Driver } from '../../../core/racing/domain/entities/Driver';
import { Team } from '../../../core/racing/domain/entities/Team';
import { TeamMembership } from '../../../core/racing/domain/types/TeamMembership';
import { DriverStats } from '../../../core/racing/application/use-cases/DriverStatsUseCase';
import { DriverRanking } from '../../../core/racing/application/use-cases/RankingUseCase';
import { Logger } from '../../../core/shared/domain/Logger';
// Mock logger for testing
class MockLogger implements Logger {
debug(message: string, ...args: any[]): void {}
info(message: string, ...args: any[]): void {}
warn(message: string, ...args: any[]): void {}
error(message: string, ...args: any[]): void {}
}
describe('Profile Overview Use Case Orchestration', () => {
let driverRepository: InMemoryDriverRepository;
let teamRepository: InMemoryTeamRepository;
let teamMembershipRepository: InMemoryTeamMembershipRepository;
let socialRepository: InMemorySocialGraphRepository;
let driverStatsRepository: InMemoryDriverStatsRepository;
let driverExtendedProfileProvider: InMemoryDriverExtendedProfileProvider;
let eventPublisher: InMemoryEventPublisher;
let resultRepository: InMemoryResultRepository;
let standingRepository: InMemoryStandingRepository;
let raceRepository: InMemoryRaceRepository;
let driverStatsUseCase: DriverStatsUseCase;
let rankingUseCase: RankingUseCase;
let getProfileOverviewUseCase: GetProfileOverviewUseCase;
let updateDriverProfileUseCase: UpdateDriverProfileUseCase;
let logger: MockLogger;
beforeAll(() => {
logger = new MockLogger();
driverRepository = new InMemoryDriverRepository(logger);
teamRepository = new InMemoryTeamRepository(logger);
teamMembershipRepository = new InMemoryTeamMembershipRepository(logger);
socialRepository = new InMemorySocialGraphRepository(logger);
driverStatsRepository = new InMemoryDriverStatsRepository(logger);
driverExtendedProfileProvider = new InMemoryDriverExtendedProfileProvider(logger);
eventPublisher = new InMemoryEventPublisher();
resultRepository = new InMemoryResultRepository(logger, raceRepository);
standingRepository = new InMemoryStandingRepository(logger, {}, resultRepository, raceRepository);
raceRepository = new InMemoryRaceRepository(logger);
driverStatsUseCase = new DriverStatsUseCase(resultRepository, standingRepository, driverStatsRepository, logger);
rankingUseCase = new RankingUseCase(standingRepository, driverRepository, driverStatsRepository, logger);
getProfileOverviewUseCase = new GetProfileOverviewUseCase(
driverRepository,
teamRepository,
teamMembershipRepository,
socialRepository,
driverExtendedProfileProvider,
driverStatsUseCase,
rankingUseCase
);
updateDriverProfileUseCase = new UpdateDriverProfileUseCase(driverRepository, logger);
});
beforeEach(async () => {
await driverRepository.clear();
await teamRepository.clear();
await teamMembershipRepository.clear();
await socialRepository.clear();
await driverStatsRepository.clear();
eventPublisher.clear();
});
describe('GetProfileOverviewUseCase - Success Path', () => {
it('should retrieve complete profile overview for driver with all data', async () => {
// Scenario: Driver with complete profile data
// Given: A driver exists with complete personal information
const driverId = 'driver-123';
const driver = Driver.create({
id: driverId,
iracingId: '12345',
name: 'John Doe',
country: 'US',
bio: 'Professional racing driver with 10 years experience',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has complete statistics
const stats: DriverStats = {
totalRaces: 50,
wins: 15,
podiums: 25,
dnfs: 5,
avgFinish: 8.5,
bestFinish: 1,
worstFinish: 20,
finishRate: 90,
winRate: 30,
podiumRate: 50,
percentile: 85,
rating: 1850,
consistency: 92,
overallRank: 42,
};
await driverStatsRepository.saveDriverStats(driverId, stats);
// And: The driver is a member of a team
const team = Team.create({
id: 'team-1',
name: 'Racing Team',
tag: 'RT',
description: 'Professional racing team',
ownerId: 'owner-1',
isRecruiting: true,
});
await teamRepository.create(team);
const membership: TeamMembership = {
teamId: 'team-1',
driverId: driverId,
role: 'Driver',
status: 'active',
joinedAt: new Date('2024-01-01'),
};
await teamMembershipRepository.saveMembership(membership);
// And: The driver has friends
const friendDriver = Driver.create({
id: 'friend-1',
iracingId: '67890',
name: 'Jane Smith',
country: 'UK',
avatarRef: undefined,
});
await driverRepository.create(friendDriver);
await socialRepository.seed({
drivers: [driver, friendDriver],
friendships: [{ driverId: driverId, friendId: 'friend-1' }],
feedEvents: [],
});
// When: GetProfileOverviewUseCase.execute() is called with driver ID
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should contain all profile sections
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
// And: Driver info should be complete
expect(profile.driverInfo.driver.id).toBe(driverId);
expect(profile.driverInfo.driver.name.toString()).toBe('John Doe');
expect(profile.driverInfo.driver.country.toString()).toBe('US');
expect(profile.driverInfo.driver.bio?.toString()).toBe('Professional racing driver with 10 years experience');
expect(profile.driverInfo.totalDrivers).toBeGreaterThan(0);
expect(profile.driverInfo.globalRank).toBe(42);
expect(profile.driverInfo.consistency).toBe(92);
expect(profile.driverInfo.rating).toBe(1850);
// And: Stats should be complete
expect(profile.stats).not.toBeNull();
expect(profile.stats!.totalRaces).toBe(50);
expect(profile.stats!.wins).toBe(15);
expect(profile.stats!.podiums).toBe(25);
expect(profile.stats!.dnfs).toBe(5);
expect(profile.stats!.avgFinish).toBe(8.5);
expect(profile.stats!.bestFinish).toBe(1);
expect(profile.stats!.worstFinish).toBe(20);
expect(profile.stats!.finishRate).toBe(90);
expect(profile.stats!.winRate).toBe(30);
expect(profile.stats!.podiumRate).toBe(50);
expect(profile.stats!.percentile).toBe(85);
expect(profile.stats!.rating).toBe(1850);
expect(profile.stats!.consistency).toBe(92);
expect(profile.stats!.overallRank).toBe(42);
// And: Finish distribution should be calculated
expect(profile.finishDistribution).not.toBeNull();
expect(profile.finishDistribution!.totalRaces).toBe(50);
expect(profile.finishDistribution!.wins).toBe(15);
expect(profile.finishDistribution!.podiums).toBe(25);
expect(profile.finishDistribution!.dnfs).toBe(5);
expect(profile.finishDistribution!.topTen).toBeGreaterThan(0);
expect(profile.finishDistribution!.other).toBeGreaterThan(0);
// And: Team memberships should be present
expect(profile.teamMemberships).toHaveLength(1);
expect(profile.teamMemberships[0].team.id).toBe('team-1');
expect(profile.teamMemberships[0].team.name.toString()).toBe('Racing Team');
expect(profile.teamMemberships[0].membership.role).toBe('Driver');
expect(profile.teamMemberships[0].membership.status).toBe('active');
// And: Social summary should show friends
expect(profile.socialSummary.friendsCount).toBe(1);
expect(profile.socialSummary.friends).toHaveLength(1);
expect(profile.socialSummary.friends[0].id).toBe('friend-1');
expect(profile.socialSummary.friends[0].name.toString()).toBe('Jane Smith');
// And: Extended profile should be present (generated by provider)
expect(profile.extendedProfile).not.toBeNull();
expect(profile.extendedProfile!.socialHandles).toBeInstanceOf(Array);
expect(profile.extendedProfile!.achievements).toBeInstanceOf(Array);
});
it('should retrieve profile overview for driver with minimal data', async () => {
// Scenario: Driver with minimal profile data
// Given: A driver exists with minimal information
const driverId = 'driver-456';
const driver = Driver.create({
id: driverId,
iracingId: '78901',
name: 'New Driver',
country: 'DE',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has no statistics
// And: The driver is not a member of any team
// And: The driver has no friends
// When: GetProfileOverviewUseCase.execute() is called with driver ID
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should contain basic driver info
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
// And: Driver info should be present
expect(profile.driverInfo.driver.id).toBe(driverId);
expect(profile.driverInfo.driver.name.toString()).toBe('New Driver');
expect(profile.driverInfo.driver.country.toString()).toBe('DE');
expect(profile.driverInfo.totalDrivers).toBeGreaterThan(0);
// And: Stats should be null (no data)
expect(profile.stats).toBeNull();
// And: Finish distribution should be null
expect(profile.finishDistribution).toBeNull();
// And: Team memberships should be empty
expect(profile.teamMemberships).toHaveLength(0);
// And: Social summary should show no friends
expect(profile.socialSummary.friendsCount).toBe(0);
expect(profile.socialSummary.friends).toHaveLength(0);
// And: Extended profile should be present (generated by provider)
expect(profile.extendedProfile).not.toBeNull();
});
it('should retrieve profile overview with multiple team memberships', async () => {
// Scenario: Driver with multiple team memberships
// Given: A driver exists
const driverId = 'driver-789';
const driver = Driver.create({
id: driverId,
iracingId: '11111',
name: 'Multi Team Driver',
country: 'FR',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver is a member of multiple teams
const team1 = Team.create({
id: 'team-1',
name: 'Team A',
tag: 'TA',
description: 'Team A',
ownerId: 'owner-1',
isRecruiting: true,
});
await teamRepository.create(team1);
const team2 = Team.create({
id: 'team-2',
name: 'Team B',
tag: 'TB',
description: 'Team B',
ownerId: 'owner-2',
isRecruiting: false,
});
await teamRepository.create(team2);
const membership1: TeamMembership = {
teamId: 'team-1',
driverId: driverId,
role: 'Driver',
status: 'active',
joinedAt: new Date('2024-01-01'),
};
await teamMembershipRepository.saveMembership(membership1);
const membership2: TeamMembership = {
teamId: 'team-2',
driverId: driverId,
role: 'Admin',
status: 'active',
joinedAt: new Date('2024-02-01'),
};
await teamMembershipRepository.saveMembership(membership2);
// When: GetProfileOverviewUseCase.execute() is called with driver ID
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should contain all team memberships
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
// And: Team memberships should include both teams
expect(profile.teamMemberships).toHaveLength(2);
expect(profile.teamMemberships[0].team.id).toBe('team-1');
expect(profile.teamMemberships[0].membership.role).toBe('Driver');
expect(profile.teamMemberships[1].team.id).toBe('team-2');
expect(profile.teamMemberships[1].membership.role).toBe('Admin');
// And: Team memberships should be sorted by joined date
expect(profile.teamMemberships[0].membership.joinedAt.getTime()).toBeLessThan(
profile.teamMemberships[1].membership.joinedAt.getTime()
);
});
it('should retrieve profile overview with multiple friends', async () => {
// Scenario: Driver with multiple friends
// Given: A driver exists
const driverId = 'driver-friends';
const driver = Driver.create({
id: driverId,
iracingId: '22222',
name: 'Social Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has multiple friends
const friend1 = Driver.create({
id: 'friend-1',
iracingId: '33333',
name: 'Friend 1',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(friend1);
const friend2 = Driver.create({
id: 'friend-2',
iracingId: '44444',
name: 'Friend 2',
country: 'UK',
avatarRef: undefined,
});
await driverRepository.create(friend2);
const friend3 = Driver.create({
id: 'friend-3',
iracingId: '55555',
name: 'Friend 3',
country: 'DE',
avatarRef: undefined,
});
await driverRepository.create(friend3);
await socialRepository.seed({
drivers: [driver, friend1, friend2, friend3],
friendships: [
{ driverId: driverId, friendId: 'friend-1' },
{ driverId: driverId, friendId: 'friend-2' },
{ driverId: driverId, friendId: 'friend-3' },
],
feedEvents: [],
});
// When: GetProfileOverviewUseCase.execute() is called with driver ID
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should contain all friends
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
// And: Social summary should show 3 friends
expect(profile.socialSummary.friendsCount).toBe(3);
expect(profile.socialSummary.friends).toHaveLength(3);
// And: All friends should be present
const friendIds = profile.socialSummary.friends.map(f => f.id);
expect(friendIds).toContain('friend-1');
expect(friendIds).toContain('friend-2');
expect(friendIds).toContain('friend-3');
});
});
describe('GetProfileOverviewUseCase - Edge Cases', () => {
it('should handle driver with no statistics', async () => {
// Scenario: Driver without statistics
// Given: A driver exists
const driverId = 'driver-no-stats';
const driver = Driver.create({
id: driverId,
iracingId: '66666',
name: 'No Stats Driver',
country: 'CA',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has no statistics
// When: GetProfileOverviewUseCase.execute() is called with driver ID
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should contain driver info with null stats
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
expect(profile.driverInfo.driver.id).toBe(driverId);
expect(profile.stats).toBeNull();
expect(profile.finishDistribution).toBeNull();
});
it('should handle driver with no team memberships', async () => {
// Scenario: Driver without team memberships
// Given: A driver exists
const driverId = 'driver-no-teams';
const driver = Driver.create({
id: driverId,
iracingId: '77777',
name: 'Solo Driver',
country: 'IT',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver is not a member of any team
// When: GetProfileOverviewUseCase.execute() is called with driver ID
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should contain driver info with empty team memberships
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
expect(profile.driverInfo.driver.id).toBe(driverId);
expect(profile.teamMemberships).toHaveLength(0);
});
it('should handle driver with no friends', async () => {
// Scenario: Driver without friends
// Given: A driver exists
const driverId = 'driver-no-friends';
const driver = Driver.create({
id: driverId,
iracingId: '88888',
name: 'Lonely Driver',
country: 'ES',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has no friends
// When: GetProfileOverviewUseCase.execute() is called with driver ID
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should contain driver info with empty social summary
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
expect(profile.driverInfo.driver.id).toBe(driverId);
expect(profile.socialSummary.friendsCount).toBe(0);
expect(profile.socialSummary.friends).toHaveLength(0);
});
});
describe('GetProfileOverviewUseCase - Error Handling', () => {
it('should return error when driver does not exist', async () => {
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
const nonExistentDriverId = 'non-existent-driver';
// When: GetProfileOverviewUseCase.execute() is called with non-existent driver ID
const result = await getProfileOverviewUseCase.execute({ driverId: nonExistentDriverId });
// Then: Should return error
expect(result.isErr()).toBe(true);
const error = result.getError();
expect(error.code).toBe('DRIVER_NOT_FOUND');
expect(error.details.message).toBe('Driver not found');
});
it('should return error when driver ID is invalid', async () => {
// Scenario: Invalid driver ID
// Given: An invalid driver ID (empty string)
const invalidDriverId = '';
// When: GetProfileOverviewUseCase.execute() is called with invalid driver ID
const result = await getProfileOverviewUseCase.execute({ driverId: invalidDriverId });
// Then: Should return error
expect(result.isErr()).toBe(true);
const error = result.getError();
expect(error.code).toBe('DRIVER_NOT_FOUND');
expect(error.details.message).toBe('Driver not found');
});
});
describe('UpdateDriverProfileUseCase - Success Path', () => {
it('should update driver bio', async () => {
// Scenario: Update driver bio
// Given: A driver exists with bio
const driverId = 'driver-update-bio';
const driver = Driver.create({
id: driverId,
iracingId: '99999',
name: 'Update Driver',
country: 'US',
bio: 'Original bio',
avatarRef: undefined,
});
await driverRepository.create(driver);
// When: UpdateDriverProfileUseCase.execute() is called with new bio
const result = await updateDriverProfileUseCase.execute({
driverId,
bio: 'Updated bio',
});
// Then: The operation should succeed
expect(result.isOk()).toBe(true);
// And: The driver's bio should be updated
const updatedDriver = await driverRepository.findById(driverId);
expect(updatedDriver).not.toBeNull();
expect(updatedDriver!.bio?.toString()).toBe('Updated bio');
});
it('should update driver country', async () => {
// Scenario: Update driver country
// Given: A driver exists with country
const driverId = 'driver-update-country';
const driver = Driver.create({
id: driverId,
iracingId: '10101',
name: 'Country Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// When: UpdateDriverProfileUseCase.execute() is called with new country
const result = await updateDriverProfileUseCase.execute({
driverId,
country: 'DE',
});
// Then: The operation should succeed
expect(result.isOk()).toBe(true);
// And: The driver's country should be updated
const updatedDriver = await driverRepository.findById(driverId);
expect(updatedDriver).not.toBeNull();
expect(updatedDriver!.country.toString()).toBe('DE');
});
it('should update multiple profile fields at once', async () => {
// Scenario: Update multiple fields
// Given: A driver exists
const driverId = 'driver-update-multiple';
const driver = Driver.create({
id: driverId,
iracingId: '11111',
name: 'Multi Update Driver',
country: 'US',
bio: 'Original bio',
avatarRef: undefined,
});
await driverRepository.create(driver);
// When: UpdateDriverProfileUseCase.execute() is called with multiple updates
const result = await updateDriverProfileUseCase.execute({
driverId,
bio: 'Updated bio',
country: 'FR',
});
// Then: The operation should succeed
expect(result.isOk()).toBe(true);
// And: Both fields should be updated
const updatedDriver = await driverRepository.findById(driverId);
expect(updatedDriver).not.toBeNull();
expect(updatedDriver!.bio?.toString()).toBe('Updated bio');
expect(updatedDriver!.country.toString()).toBe('FR');
});
});
describe('UpdateDriverProfileUseCase - Validation', () => {
it('should reject update with empty bio', async () => {
// Scenario: Empty bio
// Given: A driver exists
const driverId = 'driver-empty-bio';
const driver = Driver.create({
id: driverId,
iracingId: '12121',
name: 'Empty Bio Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// When: UpdateDriverProfileUseCase.execute() is called with empty bio
const result = await updateDriverProfileUseCase.execute({
driverId,
bio: '',
});
// Then: Should return error
expect(result.isErr()).toBe(true);
const error = result.getError();
expect(error.code).toBe('INVALID_PROFILE_DATA');
expect(error.details.message).toBe('Profile data is invalid');
});
it('should reject update with empty country', async () => {
// Scenario: Empty country
// Given: A driver exists
const driverId = 'driver-empty-country';
const driver = Driver.create({
id: driverId,
iracingId: '13131',
name: 'Empty Country Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// When: UpdateDriverProfileUseCase.execute() is called with empty country
const result = await updateDriverProfileUseCase.execute({
driverId,
country: '',
});
// Then: Should return error
expect(result.isErr()).toBe(true);
const error = result.getError();
expect(error.code).toBe('INVALID_PROFILE_DATA');
expect(error.details.message).toBe('Profile data is invalid');
});
});
describe('UpdateDriverProfileUseCase - Error Handling', () => {
it('should return error when driver does not exist', async () => {
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
const nonExistentDriverId = 'non-existent-driver';
// When: UpdateDriverProfileUseCase.execute() is called with non-existent driver ID
const result = await updateDriverProfileUseCase.execute({
driverId: nonExistentDriverId,
bio: 'New bio',
});
// Then: Should return error
expect(result.isErr()).toBe(true);
const error = result.getError();
expect(error.code).toBe('DRIVER_NOT_FOUND');
expect(error.details.message).toContain('Driver with id');
});
it('should return error when driver ID is invalid', async () => {
// Scenario: Invalid driver ID
// Given: An invalid driver ID (empty string)
const invalidDriverId = '';
// When: UpdateDriverProfileUseCase.execute() is called with invalid driver ID
const result = await updateDriverProfileUseCase.execute({
driverId: invalidDriverId,
bio: 'New bio',
});
// Then: Should return error
expect(result.isErr()).toBe(true);
const error = result.getError();
expect(error.code).toBe('DRIVER_NOT_FOUND');
expect(error.details.message).toContain('Driver with id');
});
});
describe('Profile Data Orchestration', () => {
it('should correctly calculate win percentage from race results', async () => {
// Scenario: Win percentage calculation
// Given: A driver exists
const driverId = 'driver-win-percentage';
const driver = Driver.create({
id: driverId,
iracingId: '14141',
name: 'Win Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has 10 race starts and 3 wins
const stats: DriverStats = {
totalRaces: 10,
wins: 3,
podiums: 5,
dnfs: 0,
avgFinish: 5.0,
bestFinish: 1,
worstFinish: 10,
finishRate: 100,
winRate: 30,
podiumRate: 50,
percentile: 70,
rating: 1600,
consistency: 85,
overallRank: 100,
};
await driverStatsRepository.saveDriverStats(driverId, stats);
// When: GetProfileOverviewUseCase.execute() is called
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should show win percentage as 30%
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
expect(profile.stats!.winRate).toBe(30);
});
it('should correctly calculate podium rate from race results', async () => {
// Scenario: Podium rate calculation
// Given: A driver exists
const driverId = 'driver-podium-rate';
const driver = Driver.create({
id: driverId,
iracingId: '15151',
name: 'Podium Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has 10 race starts and 5 podiums
const stats: DriverStats = {
totalRaces: 10,
wins: 2,
podiums: 5,
dnfs: 0,
avgFinish: 4.0,
bestFinish: 1,
worstFinish: 8,
finishRate: 100,
winRate: 20,
podiumRate: 50,
percentile: 60,
rating: 1550,
consistency: 80,
overallRank: 150,
};
await driverStatsRepository.saveDriverStats(driverId, stats);
// When: GetProfileOverviewUseCase.execute() is called
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should show podium rate as 50%
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
expect(profile.stats!.podiumRate).toBe(50);
});
it('should correctly calculate finish distribution', async () => {
// Scenario: Finish distribution calculation
// Given: A driver exists
const driverId = 'driver-finish-dist';
const driver = Driver.create({
id: driverId,
iracingId: '16161',
name: 'Finish Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has 20 race starts with various finishes
const stats: DriverStats = {
totalRaces: 20,
wins: 5,
podiums: 8,
dnfs: 2,
avgFinish: 6.5,
bestFinish: 1,
worstFinish: 15,
finishRate: 90,
winRate: 25,
podiumRate: 40,
percentile: 75,
rating: 1700,
consistency: 88,
overallRank: 75,
};
await driverStatsRepository.saveDriverStats(driverId, stats);
// When: GetProfileOverviewUseCase.execute() is called
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should show correct finish distribution
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
expect(profile.finishDistribution!.totalRaces).toBe(20);
expect(profile.finishDistribution!.wins).toBe(5);
expect(profile.finishDistribution!.podiums).toBe(8);
expect(profile.finishDistribution!.dnfs).toBe(2);
expect(profile.finishDistribution!.topTen).toBeGreaterThan(0);
expect(profile.finishDistribution!.other).toBeGreaterThan(0);
});
it('should correctly format team affiliation with role', async () => {
// Scenario: Team affiliation formatting
// Given: A driver exists
const driverId = 'driver-team-affiliation';
const driver = Driver.create({
id: driverId,
iracingId: '17171',
name: 'Team Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver is affiliated with a team
const team = Team.create({
id: 'team-affiliation',
name: 'Affiliation Team',
tag: 'AT',
description: 'Team for testing',
ownerId: 'owner-1',
isRecruiting: true,
});
await teamRepository.create(team);
const membership: TeamMembership = {
teamId: 'team-affiliation',
driverId: driverId,
role: 'Driver',
status: 'active',
joinedAt: new Date('2024-01-01'),
};
await teamMembershipRepository.saveMembership(membership);
// When: GetProfileOverviewUseCase.execute() is called
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: Team affiliation should show team name and role
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
expect(profile.teamMemberships).toHaveLength(1);
expect(profile.teamMemberships[0].team.name.toString()).toBe('Affiliation Team');
expect(profile.teamMemberships[0].membership.role).toBe('Driver');
});
it('should correctly identify driver role in each team', async () => {
// Scenario: Driver role identification
// Given: A driver exists
const driverId = 'driver-roles';
const driver = Driver.create({
id: driverId,
iracingId: '18181',
name: 'Role Driver',
country: 'US',
avatarRef: undefined,
});
await driverRepository.create(driver);
// And: The driver has different roles in different teams
const team1 = Team.create({
id: 'team-role-1',
name: 'Team A',
tag: 'TA',
description: 'Team A',
ownerId: 'owner-1',
isRecruiting: true,
});
await teamRepository.create(team1);
const team2 = Team.create({
id: 'team-role-2',
name: 'Team B',
tag: 'TB',
description: 'Team B',
ownerId: 'owner-2',
isRecruiting: false,
});
await teamRepository.create(team2);
const team3 = Team.create({
id: 'team-role-3',
name: 'Team C',
tag: 'TC',
description: 'Team C',
ownerId: driverId,
isRecruiting: true,
});
await teamRepository.create(team3);
const membership1: TeamMembership = {
teamId: 'team-role-1',
driverId: driverId,
role: 'Driver',
status: 'active',
joinedAt: new Date('2024-01-01'),
};
await teamMembershipRepository.saveMembership(membership1);
const membership2: TeamMembership = {
teamId: 'team-role-2',
driverId: driverId,
role: 'Admin',
status: 'active',
joinedAt: new Date('2024-02-01'),
};
await teamMembershipRepository.saveMembership(membership2);
const membership3: TeamMembership = {
teamId: 'team-role-3',
driverId: driverId,
role: 'Owner',
status: 'active',
joinedAt: new Date('2024-03-01'),
};
await teamMembershipRepository.saveMembership(membership3);
// When: GetProfileOverviewUseCase.execute() is called
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: Each team should show the correct role
expect(result.isOk()).toBe(true);
const profile = result.unwrap();
expect(profile.teamMemberships).toHaveLength(3);
const teamARole = profile.teamMemberships.find(m => m.team.id === 'team-role-1')?.membership.role;
const teamBRole = profile.teamMemberships.find(m => m.team.id === 'team-role-2')?.membership.role;
const teamCRole = profile.teamMemberships.find(m => m.team.id === 'team-role-3')?.membership.role;
expect(teamARole).toBe('Driver');
expect(teamBRole).toBe('Admin');
expect(teamCRole).toBe('Owner');
});
});
});

668
tests/integration/profile/profile-settings-use-cases.integration.test.ts
View File

@@ -1,668 +0,0 @@
/**
* Integration Test: Profile Settings Use Case Orchestration
*
* Tests the orchestration logic of profile settings-related Use Cases:
* - GetProfileSettingsUseCase: Retrieves driver's current profile settings
* - UpdateProfileSettingsUseCase: Updates driver's profile settings
* - UpdateAvatarUseCase: Updates driver's avatar
* - ClearAvatarUseCase: Clears driver's avatar
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - Uses In-Memory adapters for fast, deterministic testing
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemoryDriverRepository } from '../../../adapters/drivers/persistence/inmemory/InMemoryDriverRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetProfileSettingsUseCase } from '../../../core/profile/use-cases/GetProfileSettingsUseCase';
import { UpdateProfileSettingsUseCase } from '../../../core/profile/use-cases/UpdateProfileSettingsUseCase';
import { UpdateAvatarUseCase } from '../../../core/media/use-cases/UpdateAvatarUseCase';
import { ClearAvatarUseCase } from '../../../core/media/use-cases/ClearAvatarUseCase';
import { ProfileSettingsQuery } from '../../../core/profile/ports/ProfileSettingsQuery';
import { UpdateProfileSettingsCommand } from '../../../core/profile/ports/UpdateProfileSettingsCommand';
import { UpdateAvatarCommand } from '../../../core/media/ports/UpdateAvatarCommand';
import { ClearAvatarCommand } from '../../../core/media/ports/ClearAvatarCommand';
describe('Profile Settings Use Case Orchestration', () => {
let driverRepository: InMemoryDriverRepository;
let eventPublisher: InMemoryEventPublisher;
let getProfileSettingsUseCase: GetProfileSettingsUseCase;
let updateProfileSettingsUseCase: UpdateProfileSettingsUseCase;
let updateAvatarUseCase: UpdateAvatarUseCase;
let clearAvatarUseCase: ClearAvatarUseCase;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// driverRepository = new InMemoryDriverRepository();
// eventPublisher = new InMemoryEventPublisher();
// getProfileSettingsUseCase = new GetProfileSettingsUseCase({
// driverRepository,
// eventPublisher,
// });
// updateProfileSettingsUseCase = new UpdateProfileSettingsUseCase({
// driverRepository,
// eventPublisher,
// });
// updateAvatarUseCase = new UpdateAvatarUseCase({
// driverRepository,
// eventPublisher,
// });
// clearAvatarUseCase = new ClearAvatarUseCase({
// driverRepository,
// eventPublisher,
// });
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// driverRepository.clear();
// eventPublisher.clear();
});
describe('GetProfileSettingsUseCase - Success Path', () => {
it('should retrieve complete driver profile settings', async () => {
// TODO: Implement test
// Scenario: Driver with complete profile settings
// Given: A driver exists with complete profile settings
// And: The driver has name, email, avatar, bio, location
// And: The driver has social links configured
// And: The driver has team affiliation
// And: The driver has notification preferences
// And: The driver has privacy settings
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain all profile settings
// And: The result should display name, email, avatar, bio, location
// And: The result should display social links
// And: The result should display team affiliation
// And: The result should display notification preferences
// And: The result should display privacy settings
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should retrieve driver profile settings with minimal information', async () => {
// TODO: Implement test
// Scenario: Driver with minimal profile settings
// Given: A driver exists with minimal information
// And: The driver has only name and email
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain basic profile settings
// And: The result should display name and email
// And: The result should show empty values for optional fields
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should retrieve driver profile settings with avatar', async () => {
// TODO: Implement test
// Scenario: Driver with avatar
// Given: A driver exists with an avatar
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain avatar URL
// And: The avatar should be accessible
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should retrieve driver profile settings with social links', async () => {
// TODO: Implement test
// Scenario: Driver with social links
// Given: A driver exists with social links
// And: The driver has Discord, Twitter, iRacing links
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain social links
// And: Each link should have correct URL format
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should retrieve driver profile settings with team affiliation', async () => {
// TODO: Implement test
// Scenario: Driver with team affiliation
// Given: A driver exists with team affiliation
// And: The driver is affiliated with Team XYZ
// And: The driver has role "Driver"
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain team information
// And: The result should show team name and logo
// And: The result should show driver role
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should retrieve driver profile settings with notification preferences', async () => {
// TODO: Implement test
// Scenario: Driver with notification preferences
// Given: A driver exists with notification preferences
// And: The driver has email notifications enabled
// And: The driver has push notifications disabled
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain notification preferences
// And: The result should show email notification status
// And: The result should show push notification status
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should retrieve driver profile settings with privacy settings', async () => {
// TODO: Implement test
// Scenario: Driver with privacy settings
// Given: A driver exists with privacy settings
// And: The driver has profile visibility set to "Public"
// And: The driver has race results visibility set to "Friends Only"
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain privacy settings
// And: The result should show profile visibility
// And: The result should show race results visibility
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should retrieve driver profile settings with bio', async () => {
// TODO: Implement test
// Scenario: Driver with bio
// Given: A driver exists with a bio
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain bio text
// And: The bio should be displayed correctly
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should retrieve driver profile settings with location', async () => {
// TODO: Implement test
// Scenario: Driver with location
// Given: A driver exists with location
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain location
// And: The location should be displayed correctly
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
});
describe('GetProfileSettingsUseCase - Edge Cases', () => {
it('should handle driver with no avatar', async () => {
// TODO: Implement test
// Scenario: Driver without avatar
// Given: A driver exists without avatar
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain profile settings
// And: The result should show default avatar or placeholder
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should handle driver with no social links', async () => {
// TODO: Implement test
// Scenario: Driver without social links
// Given: A driver exists without social links
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain profile settings
// And: The result should show empty social links section
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should handle driver with no team affiliation', async () => {
// TODO: Implement test
// Scenario: Driver without team affiliation
// Given: A driver exists without team affiliation
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain profile settings
// And: The result should show empty team section
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should handle driver with no bio', async () => {
// TODO: Implement test
// Scenario: Driver without bio
// Given: A driver exists without bio
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain profile settings
// And: The result should show empty bio section
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should handle driver with no location', async () => {
// TODO: Implement test
// Scenario: Driver without location
// Given: A driver exists without location
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain profile settings
// And: The result should show empty location section
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should handle driver with no notification preferences', async () => {
// TODO: Implement test
// Scenario: Driver without notification preferences
// Given: A driver exists without notification preferences
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain profile settings
// And: The result should show default notification preferences
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
it('should handle driver with no privacy settings', async () => {
// TODO: Implement test
// Scenario: Driver without privacy settings
// Given: A driver exists without privacy settings
// When: GetProfileSettingsUseCase.execute() is called with driver ID
// Then: The result should contain profile settings
// And: The result should show default privacy settings
// And: EventPublisher should emit ProfileSettingsAccessedEvent
});
});
describe('GetProfileSettingsUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: GetProfileSettingsUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: GetProfileSettingsUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during query
// When: GetProfileSettingsUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('UpdateProfileSettingsUseCase - Success Path', () => {
it('should update driver name', async () => {
// TODO: Implement test
// Scenario: Update driver name
// Given: A driver exists with name "John Doe"
// When: UpdateProfileSettingsUseCase.execute() is called with new name "Jane Doe"
// Then: The driver's name should be updated to "Jane Doe"
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should update driver email', async () => {
// TODO: Implement test
// Scenario: Update driver email
// Given: A driver exists with email "john@example.com"
// When: UpdateProfileSettingsUseCase.execute() is called with new email "jane@example.com"
// Then: The driver's email should be updated to "jane@example.com"
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should update driver bio', async () => {
// TODO: Implement test
// Scenario: Update driver bio
// Given: A driver exists with bio "Original bio"
// When: UpdateProfileSettingsUseCase.execute() is called with new bio "Updated bio"
// Then: The driver's bio should be updated to "Updated bio"
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should update driver location', async () => {
// TODO: Implement test
// Scenario: Update driver location
// Given: A driver exists with location "USA"
// When: UpdateProfileSettingsUseCase.execute() is called with new location "Germany"
// Then: The driver's location should be updated to "Germany"
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should update driver social links', async () => {
// TODO: Implement test
// Scenario: Update driver social links
// Given: A driver exists with social links
// When: UpdateProfileSettingsUseCase.execute() is called with new social links
// Then: The driver's social links should be updated
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should update driver team affiliation', async () => {
// TODO: Implement test
// Scenario: Update driver team affiliation
// Given: A driver exists with team affiliation "Team A"
// When: UpdateProfileSettingsUseCase.execute() is called with new team affiliation "Team B"
// Then: The driver's team affiliation should be updated to "Team B"
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should update driver notification preferences', async () => {
// TODO: Implement test
// Scenario: Update driver notification preferences
// Given: A driver exists with notification preferences
// When: UpdateProfileSettingsUseCase.execute() is called with new notification preferences
// Then: The driver's notification preferences should be updated
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should update driver privacy settings', async () => {
// TODO: Implement test
// Scenario: Update driver privacy settings
// Given: A driver exists with privacy settings
// When: UpdateProfileSettingsUseCase.execute() is called with new privacy settings
// Then: The driver's privacy settings should be updated
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should update multiple profile settings at once', async () => {
// TODO: Implement test
// Scenario: Update multiple settings
// Given: A driver exists with name "John Doe" and email "john@example.com"
// When: UpdateProfileSettingsUseCase.execute() is called with new name "Jane Doe" and new email "jane@example.com"
// Then: The driver's name should be updated to "Jane Doe"
// And: The driver's email should be updated to "jane@example.com"
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
});
describe('UpdateProfileSettingsUseCase - Validation', () => {
it('should reject update with invalid email format', async () => {
// TODO: Implement test
// Scenario: Invalid email format
// Given: A driver exists
// When: UpdateProfileSettingsUseCase.execute() is called with invalid email "invalid-email"
// Then: Should throw ValidationError
// And: The driver's email should NOT be updated
// And: EventPublisher should NOT emit any events
});
it('should reject update with empty required fields', async () => {
// TODO: Implement test
// Scenario: Empty required fields
// Given: A driver exists
// When: UpdateProfileSettingsUseCase.execute() is called with empty name
// Then: Should throw ValidationError
// And: The driver's name should NOT be updated
// And: EventPublisher should NOT emit any events
});
it('should reject update with invalid social link URL', async () => {
// TODO: Implement test
// Scenario: Invalid social link URL
// Given: A driver exists
// When: UpdateProfileSettingsUseCase.execute() is called with invalid social link URL
// Then: Should throw ValidationError
// And: The driver's social links should NOT be updated
// And: EventPublisher should NOT emit any events
});
});
describe('UpdateProfileSettingsUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: UpdateProfileSettingsUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: UpdateProfileSettingsUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during update
// When: UpdateProfileSettingsUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('UpdateAvatarUseCase - Success Path', () => {
it('should update driver avatar', async () => {
// TODO: Implement test
// Scenario: Update driver avatar
// Given: A driver exists with avatar "avatar1.jpg"
// When: UpdateAvatarUseCase.execute() is called with new avatar "avatar2.jpg"
// Then: The driver's avatar should be updated to "avatar2.jpg"
// And: EventPublisher should emit AvatarUpdatedEvent
});
it('should update driver avatar with validation', async () => {
// TODO: Implement test
// Scenario: Update driver avatar with validation
// Given: A driver exists
// When: UpdateAvatarUseCase.execute() is called with valid avatar file
// Then: The driver's avatar should be updated
// And: The avatar should be validated
// And: EventPublisher should emit AvatarUpdatedEvent
});
});
describe('UpdateAvatarUseCase - Validation', () => {
it('should reject update with invalid avatar file', async () => {
// TODO: Implement test
// Scenario: Invalid avatar file
// Given: A driver exists
// When: UpdateAvatarUseCase.execute() is called with invalid avatar file
// Then: Should throw ValidationError
// And: The driver's avatar should NOT be updated
// And: EventPublisher should NOT emit any events
});
it('should reject update with invalid file format', async () => {
// TODO: Implement test
// Scenario: Invalid file format
// Given: A driver exists
// When: UpdateAvatarUseCase.execute() is called with invalid file format
// Then: Should throw ValidationError
// And: The driver's avatar should NOT be updated
// And: EventPublisher should NOT emit any events
});
it('should reject update with file exceeding size limit', async () => {
// TODO: Implement test
// Scenario: File exceeding size limit
// Given: A driver exists
// When: UpdateAvatarUseCase.execute() is called with file exceeding size limit
// Then: Should throw ValidationError
// And: The driver's avatar should NOT be updated
// And: EventPublisher should NOT emit any events
});
});
describe('UpdateAvatarUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: UpdateAvatarUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: UpdateAvatarUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during update
// When: UpdateAvatarUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('ClearAvatarUseCase - Success Path', () => {
it('should clear driver avatar', async () => {
// TODO: Implement test
// Scenario: Clear driver avatar
// Given: A driver exists with avatar "avatar.jpg"
// When: ClearAvatarUseCase.execute() is called with driver ID
// Then: The driver's avatar should be cleared
// And: The driver should have default avatar or placeholder
// And: EventPublisher should emit AvatarClearedEvent
});
it('should clear driver avatar when no avatar exists', async () => {
// TODO: Implement test
// Scenario: Clear avatar when no avatar exists
// Given: A driver exists without avatar
// When: ClearAvatarUseCase.execute() is called with driver ID
// Then: The operation should succeed
// And: EventPublisher should emit AvatarClearedEvent
});
});
describe('ClearAvatarUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: ClearAvatarUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: ClearAvatarUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during update
// When: ClearAvatarUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('Profile Settings Data Orchestration', () => {
it('should correctly format social links with proper URLs', async () => {
// TODO: Implement test
// Scenario: Social links formatting
// Given: A driver exists
// And: The driver has social links (Discord, Twitter, iRacing)
// When: GetProfileSettingsUseCase.execute() is called
// Then: Social links should show:
// - Discord: https://discord.gg/username
// - Twitter: https://twitter.com/username
// - iRacing: https://members.iracing.com/membersite/member/profile?username=username
});
it('should correctly format team affiliation with role', async () => {
// TODO: Implement test
// Scenario: Team affiliation formatting
// Given: A driver exists
// And: The driver is affiliated with Team XYZ
// And: The driver's role is "Driver"
// When: GetProfileSettingsUseCase.execute() is called
// Then: Team affiliation should show:
// - Team name: Team XYZ
// - Team logo: (if available)
// - Driver role: Driver
});
it('should correctly format notification preferences', async () => {
// TODO: Implement test
// Scenario: Notification preferences formatting
// Given: A driver exists
// And: The driver has email notifications enabled
// And: The driver has push notifications disabled
// When: GetProfileSettingsUseCase.execute() is called
// Then: Notification preferences should show:
// - Email notifications: Enabled
// - Push notifications: Disabled
});
it('should correctly format privacy settings', async () => {
// TODO: Implement test
// Scenario: Privacy settings formatting
// Given: A driver exists
// And: The driver has profile visibility set to "Public"
// And: The driver has race results visibility set to "Friends Only"
// When: GetProfileSettingsUseCase.execute() is called
// Then: Privacy settings should show:
// - Profile visibility: Public
// - Race results visibility: Friends Only
});
it('should correctly validate email format', async () => {
// TODO: Implement test
// Scenario: Email validation
// Given: A driver exists
// When: UpdateProfileSettingsUseCase.execute() is called with valid email "test@example.com"
// Then: The email should be accepted
// And: EventPublisher should emit ProfileSettingsUpdatedEvent
});
it('should correctly reject invalid email format', async () => {
// TODO: Implement test
// Scenario: Invalid email format
// Given: A driver exists
// When: UpdateProfileSettingsUseCase.execute() is called with invalid email "invalid-email"
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should correctly validate avatar file', async () => {
// TODO: Implement test
// Scenario: Avatar file validation
// Given: A driver exists
// When: UpdateAvatarUseCase.execute() is called with valid avatar file
// Then: The avatar should be accepted
// And: EventPublisher should emit AvatarUpdatedEvent
});
it('should correctly reject invalid avatar file', async () => {
// TODO: Implement test
// Scenario: Invalid avatar file
// Given: A driver exists
// When: UpdateAvatarUseCase.execute() is called with invalid avatar file
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should correctly calculate profile completion percentage', async () => {
// TODO: Implement test
// Scenario: Profile completion calculation
// Given: A driver exists
// And: The driver has name, email, avatar, bio, location, social links
// When: GetProfileSettingsUseCase.execute() is called
// Then: The result should show 100% completion
// And: The result should show no incomplete sections
});
it('should correctly identify incomplete profile sections', async () => {
// TODO: Implement test
// Scenario: Incomplete profile sections
// Given: A driver exists
// And: The driver has name and email only
// When: GetProfileSettingsUseCase.execute() is called
// Then: The result should show incomplete sections:
// - Avatar
// - Bio
// - Location
// - Social links
// - Team affiliation
});
});
});

666
tests/integration/profile/profile-sponsorship-requests-use-cases.integration.test.ts
View File

@@ -1,666 +0,0 @@
/**
* Integration Test: Profile Sponsorship Requests Use Case Orchestration
*
* Tests the orchestration logic of profile sponsorship requests-related Use Cases:
* - GetProfileSponsorshipRequestsUseCase: Retrieves driver's sponsorship requests
* - GetSponsorshipRequestDetailsUseCase: Retrieves sponsorship request details
* - AcceptSponsorshipRequestUseCase: Accepts a sponsorship offer
* - RejectSponsorshipRequestUseCase: Rejects a sponsorship offer
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - Uses In-Memory adapters for fast, deterministic testing
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemoryDriverRepository } from '../../../adapters/drivers/persistence/inmemory/InMemoryDriverRepository';
import { InMemorySponsorshipRepository } from '../../../adapters/sponsorship/persistence/inmemory/InMemorySponsorshipRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetProfileSponsorshipRequestsUseCase } from '../../../core/profile/use-cases/GetProfileSponsorshipRequestsUseCase';
import { GetSponsorshipRequestDetailsUseCase } from '../../../core/sponsorship/use-cases/GetSponsorshipRequestDetailsUseCase';
import { AcceptSponsorshipRequestUseCase } from '../../../core/sponsorship/use-cases/AcceptSponsorshipRequestUseCase';
import { RejectSponsorshipRequestUseCase } from '../../../core/sponsorship/use-cases/RejectSponsorshipRequestUseCase';
import { ProfileSponsorshipRequestsQuery } from '../../../core/profile/ports/ProfileSponsorshipRequestsQuery';
import { SponsorshipRequestDetailsQuery } from '../../../core/sponsorship/ports/SponsorshipRequestDetailsQuery';
import { AcceptSponsorshipRequestCommand } from '../../../core/sponsorship/ports/AcceptSponsorshipRequestCommand';
import { RejectSponsorshipRequestCommand } from '../../../core/sponsorship/ports/RejectSponsorshipRequestCommand';
describe('Profile Sponsorship Requests Use Case Orchestration', () => {
let driverRepository: InMemoryDriverRepository;
let sponsorshipRepository: InMemorySponsorshipRepository;
let eventPublisher: InMemoryEventPublisher;
let getProfileSponsorshipRequestsUseCase: GetProfileSponsorshipRequestsUseCase;
let getSponsorshipRequestDetailsUseCase: GetSponsorshipRequestDetailsUseCase;
let acceptSponsorshipRequestUseCase: AcceptSponsorshipRequestUseCase;
let rejectSponsorshipRequestUseCase: RejectSponsorshipRequestUseCase;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// driverRepository = new InMemoryDriverRepository();
// sponsorshipRepository = new InMemorySponsorshipRepository();
// eventPublisher = new InMemoryEventPublisher();
// getProfileSponsorshipRequestsUseCase = new GetProfileSponsorshipRequestsUseCase({
// driverRepository,
// sponsorshipRepository,
// eventPublisher,
// });
// getSponsorshipRequestDetailsUseCase = new GetSponsorshipRequestDetailsUseCase({
// sponsorshipRepository,
// eventPublisher,
// });
// acceptSponsorshipRequestUseCase = new AcceptSponsorshipRequestUseCase({
// driverRepository,
// sponsorshipRepository,
// eventPublisher,
// });
// rejectSponsorshipRequestUseCase = new RejectSponsorshipRequestUseCase({
// driverRepository,
// sponsorshipRepository,
// eventPublisher,
// });
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// driverRepository.clear();
// sponsorshipRepository.clear();
// eventPublisher.clear();
});
describe('GetProfileSponsorshipRequestsUseCase - Success Path', () => {
it('should retrieve complete list of sponsorship requests', async () => {
// TODO: Implement test
// Scenario: Driver with multiple sponsorship requests
// Given: A driver exists
// And: The driver has 3 sponsorship requests
// And: Each request has different status (Pending/Accepted/Rejected)
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should contain all sponsorship requests
// And: Each request should display sponsor name, offer details, and status
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with minimal data', async () => {
// TODO: Implement test
// Scenario: Driver with minimal sponsorship requests
// Given: A driver exists
// And: The driver has 1 sponsorship request
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should contain the sponsorship request
// And: The request should display basic information
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with sponsor information', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having sponsor info
// Given: A driver exists
// And: The driver has sponsorship requests with sponsor details
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show sponsor information for each request
// And: Sponsor info should include name, logo, and description
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with offer terms', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having offer terms
// Given: A driver exists
// And: The driver has sponsorship requests with offer terms
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show offer terms for each request
// And: Terms should include financial offer and required commitments
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with status', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having different statuses
// Given: A driver exists
// And: The driver has a pending sponsorship request
// And: The driver has an accepted sponsorship request
// And: The driver has a rejected sponsorship request
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show status for each request
// And: Pending requests should be clearly marked
// And: Accepted requests should be clearly marked
// And: Rejected requests should be clearly marked
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with duration', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having duration
// Given: A driver exists
// And: The driver has sponsorship requests with duration
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show duration for each request
// And: Duration should include start and end dates
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with financial details', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having financial details
// Given: A driver exists
// And: The driver has sponsorship requests with financial offers
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show financial details for each request
// And: Financial details should include offer amount and payment terms
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with requirements', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having requirements
// Given: A driver exists
// And: The driver has sponsorship requests with requirements
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show requirements for each request
// And: Requirements should include deliverables and commitments
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with expiration date', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having expiration dates
// Given: A driver exists
// And: The driver has sponsorship requests with expiration dates
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show expiration date for each request
// And: The date should be formatted correctly
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with creation date', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having creation dates
// Given: A driver exists
// And: The driver has sponsorship requests with creation dates
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show creation date for each request
// And: The date should be formatted correctly
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should retrieve sponsorship requests with revenue tracking', async () => {
// TODO: Implement test
// Scenario: Driver with sponsorship requests having revenue tracking
// Given: A driver exists
// And: The driver has accepted sponsorship requests with revenue tracking
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should show revenue tracking for each request
// And: Revenue tracking should include total earnings and payment history
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
});
describe('GetProfileSponsorshipRequestsUseCase - Edge Cases', () => {
it('should handle driver with no sponsorship requests', async () => {
// TODO: Implement test
// Scenario: Driver without sponsorship requests
// Given: A driver exists without sponsorship requests
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should contain empty list
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should handle driver with only pending requests', async () => {
// TODO: Implement test
// Scenario: Driver with only pending requests
// Given: A driver exists
// And: The driver has only pending sponsorship requests
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should contain only pending requests
// And: All requests should show Pending status
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should handle driver with only accepted requests', async () => {
// TODO: Implement test
// Scenario: Driver with only accepted requests
// Given: A driver exists
// And: The driver has only accepted sponsorship requests
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should contain only accepted requests
// And: All requests should show Accepted status
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should handle driver with only rejected requests', async () => {
// TODO: Implement test
// Scenario: Driver with only rejected requests
// Given: A driver exists
// And: The driver has only rejected sponsorship requests
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should contain only rejected requests
// And: All requests should show Rejected status
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
it('should handle driver with expired requests', async () => {
// TODO: Implement test
// Scenario: Driver with expired requests
// Given: A driver exists
// And: The driver has sponsorship requests that have expired
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with driver ID
// Then: The result should contain expired requests
// And: Expired requests should be clearly marked
// And: EventPublisher should emit ProfileSponsorshipRequestsAccessedEvent
});
});
describe('GetProfileSponsorshipRequestsUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when driver ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid driver ID
// Given: An invalid driver ID (e.g., empty string, null, undefined)
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with invalid driver ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: DriverRepository throws an error during query
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('GetSponsorshipRequestDetailsUseCase - Success Path', () => {
it('should retrieve complete sponsorship request details', async () => {
// TODO: Implement test
// Scenario: Sponsorship request with complete details
// Given: A sponsorship request exists with complete information
// And: The request has sponsor info, offer terms, duration, requirements
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with request ID
// Then: The result should contain all request details
// And: EventPublisher should emit SponsorshipRequestDetailsAccessedEvent
});
it('should retrieve sponsorship request details with minimal information', async () => {
// TODO: Implement test
// Scenario: Sponsorship request with minimal details
// Given: A sponsorship request exists with minimal information
// And: The request has only sponsor name and offer amount
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with request ID
// Then: The result should contain basic request details
// And: EventPublisher should emit SponsorshipRequestDetailsAccessedEvent
});
it('should retrieve sponsorship request details with sponsor information', async () => {
// TODO: Implement test
// Scenario: Sponsorship request with sponsor info
// Given: A sponsorship request exists with sponsor details
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with request ID
// Then: The result should show sponsor information
// And: Sponsor info should include name, logo, and description
// And: EventPublisher should emit SponsorshipRequestDetailsAccessedEvent
});
it('should retrieve sponsorship request details with offer terms', async () => {
// TODO: Implement test
// Scenario: Sponsorship request with offer terms
// Given: A sponsorship request exists with offer terms
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with request ID
// Then: The result should show offer terms
// And: Terms should include financial offer and required commitments
// And: EventPublisher should emit SponsorshipRequestDetailsAccessedEvent
});
it('should retrieve sponsorship request details with duration', async () => {
// TODO: Implement test
// Scenario: Sponsorship request with duration
// Given: A sponsorship request exists with duration
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with request ID
// Then: The result should show duration
// And: Duration should include start and end dates
// And: EventPublisher should emit SponsorshipRequestDetailsAccessedEvent
});
it('should retrieve sponsorship request details with financial details', async () => {
// TODO: Implement test
// Scenario: Sponsorship request with financial details
// Given: A sponsorship request exists with financial details
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with request ID
// Then: The result should show financial details
// And: Financial details should include offer amount and payment terms
// And: EventPublisher should emit SponsorshipRequestDetailsAccessedEvent
});
it('should retrieve sponsorship request details with requirements', async () => {
// TODO: Implement test
// Scenario: Sponsorship request with requirements
// Given: A sponsorship request exists with requirements
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with request ID
// Then: The result should show requirements
// And: Requirements should include deliverables and commitments
// And: EventPublisher should emit SponsorshipRequestDetailsAccessedEvent
});
});
describe('GetSponsorshipRequestDetailsUseCase - Error Handling', () => {
it('should throw error when sponsorship request does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent sponsorship request
// Given: No sponsorship request exists with the given ID
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with non-existent request ID
// Then: Should throw SponsorshipRequestNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when sponsorship request ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid sponsorship request ID
// Given: An invalid sponsorship request ID (e.g., empty string, null, undefined)
// When: GetSponsorshipRequestDetailsUseCase.execute() is called with invalid request ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('AcceptSponsorshipRequestUseCase - Success Path', () => {
it('should allow driver to accept a sponsorship offer', async () => {
// TODO: Implement test
// Scenario: Driver accepts a sponsorship offer
// Given: A driver exists
// And: The driver has a pending sponsorship request
// When: AcceptSponsorshipRequestUseCase.execute() is called with driver ID and request ID
// Then: The sponsorship should be accepted
// And: EventPublisher should emit SponsorshipAcceptedEvent
});
it('should allow driver to accept multiple sponsorship offers', async () => {
// TODO: Implement test
// Scenario: Driver accepts multiple sponsorship offers
// Given: A driver exists
// And: The driver has 3 pending sponsorship requests
// When: AcceptSponsorshipRequestUseCase.execute() is called for each request
// Then: All sponsorships should be accepted
// And: EventPublisher should emit SponsorshipAcceptedEvent for each request
});
it('should allow driver to accept sponsorship with revenue tracking', async () => {
// TODO: Implement test
// Scenario: Driver accepts sponsorship with revenue tracking
// Given: A driver exists
// And: The driver has a pending sponsorship request with revenue tracking
// When: AcceptSponsorshipRequestUseCase.execute() is called with driver ID and request ID
// Then: The sponsorship should be accepted
// And: Revenue tracking should be initialized
// And: EventPublisher should emit SponsorshipAcceptedEvent
});
});
describe('AcceptSponsorshipRequestUseCase - Validation', () => {
it('should reject accepting sponsorship when request is not pending', async () => {
// TODO: Implement test
// Scenario: Request not pending
// Given: A driver exists
// And: The driver has an accepted sponsorship request
// When: AcceptSponsorshipRequestUseCase.execute() is called with driver ID and request ID
// Then: Should throw NotPendingError
// And: EventPublisher should NOT emit any events
});
it('should reject accepting sponsorship with invalid request ID', async () => {
// TODO: Implement test
// Scenario: Invalid request ID
// Given: A driver exists
// When: AcceptSponsorshipRequestUseCase.execute() is called with invalid request ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('AcceptSponsorshipRequestUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: AcceptSponsorshipRequestUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when sponsorship request does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent sponsorship request
// Given: A driver exists
// And: No sponsorship request exists with the given ID
// When: AcceptSponsorshipRequestUseCase.execute() is called with non-existent request ID
// Then: Should throw SponsorshipRequestNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: SponsorshipRepository throws an error during update
// When: AcceptSponsorshipRequestUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('RejectSponsorshipRequestUseCase - Success Path', () => {
it('should allow driver to reject a sponsorship offer', async () => {
// TODO: Implement test
// Scenario: Driver rejects a sponsorship offer
// Given: A driver exists
// And: The driver has a pending sponsorship request
// When: RejectSponsorshipRequestUseCase.execute() is called with driver ID and request ID
// Then: The sponsorship should be rejected
// And: EventPublisher should emit SponsorshipRejectedEvent
});
it('should allow driver to reject multiple sponsorship offers', async () => {
// TODO: Implement test
// Scenario: Driver rejects multiple sponsorship offers
// Given: A driver exists
// And: The driver has 3 pending sponsorship requests
// When: RejectSponsorshipRequestUseCase.execute() is called for each request
// Then: All sponsorships should be rejected
// And: EventPublisher should emit SponsorshipRejectedEvent for each request
});
it('should allow driver to reject sponsorship with reason', async () => {
// TODO: Implement test
// Scenario: Driver rejects sponsorship with reason
// Given: A driver exists
// And: The driver has a pending sponsorship request
// When: RejectSponsorshipRequestUseCase.execute() is called with driver ID, request ID, and reason
// Then: The sponsorship should be rejected
// And: The rejection reason should be recorded
// And: EventPublisher should emit SponsorshipRejectedEvent
});
});
describe('RejectSponsorshipRequestUseCase - Validation', () => {
it('should reject rejecting sponsorship when request is not pending', async () => {
// TODO: Implement test
// Scenario: Request not pending
// Given: A driver exists
// And: The driver has an accepted sponsorship request
// When: RejectSponsorshipRequestUseCase.execute() is called with driver ID and request ID
// Then: Should throw NotPendingError
// And: EventPublisher should NOT emit any events
});
it('should reject rejecting sponsorship with invalid request ID', async () => {
// TODO: Implement test
// Scenario: Invalid request ID
// Given: A driver exists
// When: RejectSponsorshipRequestUseCase.execute() is called with invalid request ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('RejectSponsorshipRequestUseCase - Error Handling', () => {
it('should throw error when driver does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent driver
// Given: No driver exists with the given ID
// When: RejectSponsorshipRequestUseCase.execute() is called with non-existent driver ID
// Then: Should throw DriverNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when sponsorship request does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent sponsorship request
// Given: A driver exists
// And: No sponsorship request exists with the given ID
// When: RejectSponsorshipRequestUseCase.execute() is called with non-existent request ID
// Then: Should throw SponsorshipRequestNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should handle repository errors gracefully', async () => {
// TODO: Implement test
// Scenario: Repository throws error
// Given: A driver exists
// And: SponsorshipRepository throws an error during update
// When: RejectSponsorshipRequestUseCase.execute() is called
// Then: Should propagate the error appropriately
// And: EventPublisher should NOT emit any events
});
});
describe('Profile Sponsorship Requests Data Orchestration', () => {
it('should correctly format sponsorship status with visual cues', async () => {
// TODO: Implement test
// Scenario: Sponsorship status formatting
// Given: A driver exists
// And: The driver has a pending sponsorship request
// And: The driver has an accepted sponsorship request
// And: The driver has a rejected sponsorship request
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: Pending requests should show "Pending" status with yellow indicator
// And: Accepted requests should show "Accepted" status with green indicator
// And: Rejected requests should show "Rejected" status with red indicator
});
it('should correctly format sponsorship duration', async () => {
// TODO: Implement test
// Scenario: Sponsorship duration formatting
// Given: A driver exists
// And: The driver has a sponsorship request with duration from 2024-01-15 to 2024-12-31
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: Duration should show as "January 15, 2024 - December 31, 2024" or similar format
});
it('should correctly format financial offer as currency', async () => {
// TODO: Implement test
// Scenario: Financial offer formatting
// Given: A driver exists
// And: The driver has a sponsorship request with offer $1000
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: Financial offer should show as "$1,000" or "1000 USD"
});
it('should correctly format sponsorship expiration date', async () => {
// TODO: Implement test
// Scenario: Sponsorship expiration date formatting
// Given: A driver exists
// And: The driver has a sponsorship request with expiration date 2024-06-30
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: Expiration date should show as "June 30, 2024" or similar format
});
it('should correctly format sponsorship creation date', async () => {
// TODO: Implement test
// Scenario: Sponsorship creation date formatting
// Given: A driver exists
// And: The driver has a sponsorship request created on 2024-01-15
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: Creation date should show as "January 15, 2024" or similar format
});
it('should correctly filter sponsorship requests by status', async () => {
// TODO: Implement test
// Scenario: Sponsorship filtering by status
// Given: A driver exists
// And: The driver has 2 pending requests and 1 accepted request
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with status filter "Pending"
// Then: The result should show only the 2 pending requests
// And: The accepted request should be hidden
});
it('should correctly search sponsorship requests by sponsor name', async () => {
// TODO: Implement test
// Scenario: Sponsorship search by sponsor name
// Given: A driver exists
// And: The driver has sponsorship requests from "Sponsor A" and "Sponsor B"
// When: GetProfileSponsorshipRequestsUseCase.execute() is called with search term "Sponsor A"
// Then: The result should show only "Sponsor A" request
// And: "Sponsor B" request should be hidden
});
it('should correctly identify sponsorship request owner', async () => {
// TODO: Implement test
// Scenario: Sponsorship request owner identification
// Given: A driver exists
// And: The driver has a sponsorship request
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: The request should be associated with the driver
// And: The driver should be able to accept or reject the request
});
it('should correctly handle sponsorship request with pending status', async () => {
// TODO: Implement test
// Scenario: Pending sponsorship request handling
// Given: A driver exists
// And: The driver has a pending sponsorship request
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: The request should show "Pending" status
// And: The request should show accept and reject buttons
});
it('should correctly handle sponsorship request with accepted status', async () => {
// TODO: Implement test
// Scenario: Accepted sponsorship request handling
// Given: A driver exists
// And: The driver has an accepted sponsorship request
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: The request should show "Accepted" status
// And: The request should show sponsorship details
});
it('should correctly handle sponsorship request with rejected status', async () => {
// TODO: Implement test
// Scenario: Rejected sponsorship request handling
// Given: A driver exists
// And: The driver has a rejected sponsorship request
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: The request should show "Rejected" status
// And: The request should show rejection reason (if available)
});
it('should correctly calculate sponsorship revenue tracking', async () => {
// TODO: Implement test
// Scenario: Sponsorship revenue tracking calculation
// Given: A driver exists
// And: The driver has an accepted sponsorship request with $1000 offer
// And: The sponsorship has 2 payments of $500 each
// When: GetProfileSponsorshipRequestsUseCase.execute() is called
// Then: Revenue tracking should show total earnings of $1000
// And: Revenue tracking should show payment history with 2 payments
});
});
});

303
tests/integration/profile/profile-use-cases.integration.test.ts
View File

@@ -1,303 +0,0 @@
/**
* Integration Test: Profile Use Cases Orchestration
*
* Tests the orchestration logic of profile-related Use Cases:
* - GetProfileOverviewUseCase: Retrieves driver profile overview
* - UpdateDriverProfileUseCase: Updates driver profile information
* - GetDriverLiveriesUseCase: Retrieves driver liveries
* - GetLeagueMembershipsUseCase: Retrieves driver league memberships (via league)
* - GetPendingSponsorshipRequestsUseCase: Retrieves pending sponsorship requests
*
* Adheres to Clean Architecture:
* - Tests Core Use Cases directly
* - Uses In-Memory adapters for repositories
* - Follows Given/When/Then pattern
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { InMemoryDriverRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverRepository';
import { InMemoryTeamRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamRepository';
import { InMemoryTeamMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryTeamMembershipRepository';
import { InMemorySocialGraphRepository } from '../../../adapters/social/persistence/inmemory/InMemorySocialAndFeed';
import { InMemoryDriverExtendedProfileProvider } from '../../../adapters/racing/ports/InMemoryDriverExtendedProfileProvider';
import { InMemoryDriverStatsRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryDriverStatsRepository';
import { InMemoryLiveryRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLiveryRepository';
import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
import { InMemoryLeagueMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
import { InMemorySponsorshipRequestRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorshipRequestRepository';
import { InMemorySponsorRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorRepository';
import { GetProfileOverviewUseCase } from '../../../core/racing/application/use-cases/GetProfileOverviewUseCase';
import { UpdateDriverProfileUseCase } from '../../../core/racing/application/use-cases/UpdateDriverProfileUseCase';
import { DriverStatsUseCase } from '../../../core/racing/application/use-cases/DriverStatsUseCase';
import { RankingUseCase } from '../../../core/racing/application/use-cases/RankingUseCase';
import { GetDriverLiveriesUseCase } from '../../../core/racing/application/use-cases/GetDriverLiveriesUseCase';
import { GetLeagueMembershipsUseCase } from '../../../core/racing/application/use-cases/GetLeagueMembershipsUseCase';
import { GetPendingSponsorshipRequestsUseCase } from '../../../core/racing/application/use-cases/GetPendingSponsorshipRequestsUseCase';
import { Driver } from '../../../core/racing/domain/entities/Driver';
import { Team } from '../../../core/racing/domain/entities/Team';
import { League } from '../../../core/racing/domain/entities/League';
import { LeagueMembership } from '../../../core/racing/domain/entities/LeagueMembership';
import { DriverLivery } from '../../../core/racing/domain/entities/DriverLivery';
import { SponsorshipRequest } from '../../../core/racing/domain/entities/SponsorshipRequest';
import { Sponsor } from '../../../core/racing/domain/entities/sponsor/Sponsor';
import { Money } from '../../../core/racing/domain/value-objects/Money';
import { Logger } from '../../../core/shared/domain/Logger';
describe('Profile Use Cases Orchestration', () => {
let driverRepository: InMemoryDriverRepository;
let teamRepository: InMemoryTeamRepository;
let teamMembershipRepository: InMemoryTeamMembershipRepository;
let socialRepository: InMemorySocialGraphRepository;
let driverExtendedProfileProvider: InMemoryDriverExtendedProfileProvider;
let driverStatsRepository: InMemoryDriverStatsRepository;
let liveryRepository: InMemoryLiveryRepository;
let leagueRepository: InMemoryLeagueRepository;
let leagueMembershipRepository: InMemoryLeagueMembershipRepository;
let sponsorshipRequestRepository: InMemorySponsorshipRequestRepository;
let sponsorRepository: InMemorySponsorRepository;
let driverStatsUseCase: DriverStatsUseCase;
let rankingUseCase: RankingUseCase;
let getProfileOverviewUseCase: GetProfileOverviewUseCase;
let updateDriverProfileUseCase: UpdateDriverProfileUseCase;
let getDriverLiveriesUseCase: GetDriverLiveriesUseCase;
let getLeagueMembershipsUseCase: GetLeagueMembershipsUseCase;
let getPendingSponsorshipRequestsUseCase: GetPendingSponsorshipRequestsUseCase;
let mockLogger: Logger;
beforeAll(() => {
mockLogger = {
info: () => {},
debug: () => {},
warn: () => {},
error: () => {},
} as unknown as Logger;
driverRepository = new InMemoryDriverRepository(mockLogger);
teamRepository = new InMemoryTeamRepository(mockLogger);
teamMembershipRepository = new InMemoryTeamMembershipRepository(mockLogger);
socialRepository = new InMemorySocialGraphRepository(mockLogger);
driverExtendedProfileProvider = new InMemoryDriverExtendedProfileProvider(mockLogger);
driverStatsRepository = new InMemoryDriverStatsRepository(mockLogger);
liveryRepository = new InMemoryLiveryRepository(mockLogger);
leagueRepository = new InMemoryLeagueRepository(mockLogger);
leagueMembershipRepository = new InMemoryLeagueMembershipRepository(mockLogger);
sponsorshipRequestRepository = new InMemorySponsorshipRequestRepository(mockLogger);
sponsorRepository = new InMemorySponsorRepository(mockLogger);
driverStatsUseCase = new DriverStatsUseCase(
{} as any,
{} as any,
driverStatsRepository,
mockLogger
);
rankingUseCase = new RankingUseCase(
{} as any,
{} as any,
driverStatsRepository,
mockLogger
);
getProfileOverviewUseCase = new GetProfileOverviewUseCase(
driverRepository,
teamRepository,
teamMembershipRepository,
socialRepository,
driverExtendedProfileProvider,
driverStatsUseCase,
rankingUseCase
);
updateDriverProfileUseCase = new UpdateDriverProfileUseCase(driverRepository, mockLogger);
getDriverLiveriesUseCase = new GetDriverLiveriesUseCase(liveryRepository, mockLogger);
getLeagueMembershipsUseCase = new GetLeagueMembershipsUseCase(leagueMembershipRepository, driverRepository, leagueRepository);
getPendingSponsorshipRequestsUseCase = new GetPendingSponsorshipRequestsUseCase(sponsorshipRequestRepository, sponsorRepository);
});
beforeEach(() => {
driverRepository.clear();
teamRepository.clear();
teamMembershipRepository.clear();
socialRepository.clear();
driverExtendedProfileProvider.clear();
driverStatsRepository.clear();
liveryRepository.clear();
leagueRepository.clear();
leagueMembershipRepository.clear();
sponsorshipRequestRepository.clear();
sponsorRepository.clear();
});
describe('GetProfileOverviewUseCase', () => {
it('should retrieve complete driver profile overview', async () => {
// Given: A driver exists with stats, team, and friends
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '1', name: 'John Doe', country: 'US' });
await driverRepository.create(driver);
await driverStatsRepository.saveDriverStats(driverId, {
rating: 2000,
totalRaces: 10,
wins: 2,
podiums: 5,
overallRank: 1,
safetyRating: 4.5,
sportsmanshipRating: 95,
dnfs: 0,
avgFinish: 3.5,
bestFinish: 1,
worstFinish: 10,
consistency: 85,
experienceLevel: 'pro'
});
const team = Team.create({ id: 't1', name: 'Team 1', tag: 'T1', description: 'Desc', ownerId: 'other', leagues: [] });
await teamRepository.create(team);
await teamMembershipRepository.saveMembership({
teamId: 't1',
driverId: driverId,
role: 'driver',
status: 'active',
joinedAt: new Date()
});
socialRepository.seed({
drivers: [driver, Driver.create({ id: 'f1', iracingId: '2', name: 'Friend 1', country: 'UK' })],
friendships: [{ driverId: driverId, friendId: 'f1' }],
feedEvents: []
});
// When: GetProfileOverviewUseCase.execute() is called
const result = await getProfileOverviewUseCase.execute({ driverId });
// Then: The result should contain all profile sections
expect(result.isOk()).toBe(true);
const overview = result.unwrap();
expect(overview.driverInfo.driver.id).toBe(driverId);
expect(overview.stats?.rating).toBe(2000);
expect(overview.teamMemberships).toHaveLength(1);
expect(overview.socialSummary.friendsCount).toBe(1);
});
});
describe('UpdateDriverProfileUseCase', () => {
it('should update driver bio and country', async () => {
// Given: A driver exists
const driverId = 'd2';
const driver = Driver.create({ id: driverId, iracingId: '2', name: 'Update Driver', country: 'US' });
await driverRepository.create(driver);
// When: UpdateDriverProfileUseCase.execute() is called
const result = await updateDriverProfileUseCase.execute({
driverId,
bio: 'New bio',
country: 'DE',
});
// Then: The driver should be updated
expect(result.isOk()).toBe(true);
const updatedDriver = await driverRepository.findById(driverId);
expect(updatedDriver?.bio?.toString()).toBe('New bio');
expect(updatedDriver?.country.toString()).toBe('DE');
});
});
describe('GetDriverLiveriesUseCase', () => {
it('should retrieve driver liveries', async () => {
// Given: A driver has liveries
const driverId = 'd3';
const livery = DriverLivery.create({
id: 'l1',
driverId,
gameId: 'iracing',
carId: 'porsche_911_gt3_r',
uploadedImageUrl: 'https://example.com/livery.png'
});
await liveryRepository.createDriverLivery(livery);
// When: GetDriverLiveriesUseCase.execute() is called
const result = await getDriverLiveriesUseCase.execute({ driverId });
// Then: It should return the liveries
expect(result.isOk()).toBe(true);
const liveries = result.unwrap();
expect(liveries).toHaveLength(1);
expect(liveries[0].id).toBe('l1');
});
});
describe('GetLeagueMembershipsUseCase', () => {
it('should retrieve league memberships for a league', async () => {
// Given: A league with members
const leagueId = 'lg1';
const driverId = 'd4';
const league = League.create({ id: leagueId, name: 'League 1', description: 'Desc', ownerId: 'owner' });
await leagueRepository.create(league);
const membership = LeagueMembership.create({
id: 'm1',
leagueId,
driverId,
role: 'member',
status: 'active'
});
await leagueMembershipRepository.saveMembership(membership);
const driver = Driver.create({ id: driverId, iracingId: '4', name: 'Member Driver', country: 'US' });
await driverRepository.create(driver);
// When: GetLeagueMembershipsUseCase.execute() is called
const result = await getLeagueMembershipsUseCase.execute({ leagueId });
// Then: It should return the memberships with driver info
expect(result.isOk()).toBe(true);
const data = result.unwrap();
expect(data.memberships).toHaveLength(1);
expect(data.memberships[0].driver?.id).toBe(driverId);
});
});
describe('GetPendingSponsorshipRequestsUseCase', () => {
it('should retrieve pending sponsorship requests for a driver', async () => {
// Given: A driver has pending sponsorship requests
const driverId = 'd5';
const sponsorId = 's1';
const sponsor = Sponsor.create({
id: sponsorId,
name: 'Sponsor 1',
contactEmail: 'sponsor@example.com'
});
await sponsorRepository.create(sponsor);
const request = SponsorshipRequest.create({
id: 'sr1',
sponsorId,
entityType: 'driver',
entityId: driverId,
tier: 'main',
offeredAmount: Money.create(1000, 'USD')
});
await sponsorshipRequestRepository.create(request);
// When: GetPendingSponsorshipRequestsUseCase.execute() is called
const result = await getPendingSponsorshipRequestsUseCase.execute({
entityType: 'driver',
entityId: driverId
});
// Then: It should return the pending requests
expect(result.isOk()).toBe(true);
const data = result.unwrap();
expect(data.requests).toHaveLength(1);
expect(data.requests[0].request.id).toBe('sr1');
expect(data.requests[0].sponsor?.id.toString()).toBe(sponsorId);
});
});
});

37
tests/integration/profile/use-cases/GetDriverLiveriesUseCase.test.ts Normal file
View File

@@ -0,0 +1,37 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { ProfileTestContext } from '../ProfileTestContext';
import { GetDriverLiveriesUseCase } from '../../../../core/racing/application/use-cases/GetDriverLiveriesUseCase';
import { DriverLivery } from '../../../../core/racing/domain/entities/DriverLivery';
describe('GetDriverLiveriesUseCase', () => {
let context: ProfileTestContext;
let useCase: GetDriverLiveriesUseCase;
beforeEach(async () => {
context = new ProfileTestContext();
useCase = new GetDriverLiveriesUseCase(context.liveryRepository, context.logger);
await context.clear();
});
it('should retrieve driver liveries', async () => {
// Given: A driver has liveries
const driverId = 'd3';
const livery = DriverLivery.create({
id: 'l1',
driverId,
gameId: 'iracing',
carId: 'porsche_911_gt3_r',
uploadedImageUrl: 'https://example.com/livery.png'
});
await context.liveryRepository.createDriverLivery(livery);
// When: GetDriverLiveriesUseCase.execute() is called
const result = await useCase.execute({ driverId });
// Then: It should return the liveries
expect(result.isOk()).toBe(true);
const liveries = result.unwrap();
expect(liveries).toHaveLength(1);
expect(liveries[0].id).toBe('l1');
});
});

50
tests/integration/profile/use-cases/GetLeagueMembershipsUseCase.test.ts Normal file
View File

@@ -0,0 +1,50 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { ProfileTestContext } from '../ProfileTestContext';
import { GetLeagueMembershipsUseCase } from '../../../../core/racing/application/use-cases/GetLeagueMembershipsUseCase';
import { Driver } from '../../../../core/racing/domain/entities/Driver';
import { League } from '../../../../core/racing/domain/entities/League';
import { LeagueMembership } from '../../../../core/racing/domain/entities/LeagueMembership';
describe('GetLeagueMembershipsUseCase', () => {
let context: ProfileTestContext;
let useCase: GetLeagueMembershipsUseCase;
beforeEach(async () => {
context = new ProfileTestContext();
useCase = new GetLeagueMembershipsUseCase(
context.leagueMembershipRepository,
context.driverRepository,
context.leagueRepository
);
await context.clear();
});
it('should retrieve league memberships for a league', async () => {
// Given: A league with members
const leagueId = 'lg1';
const driverId = 'd4';
const league = League.create({ id: leagueId, name: 'League 1', description: 'Desc', ownerId: 'owner' });
await context.leagueRepository.create(league);
const membership = LeagueMembership.create({
id: 'm1',
leagueId,
driverId,
role: 'member',
status: 'active'
});
await context.leagueMembershipRepository.saveMembership(membership);
const driver = Driver.create({ id: driverId, iracingId: '4', name: 'Member Driver', country: 'US' });
await context.driverRepository.create(driver);
// When: GetLeagueMembershipsUseCase.execute() is called
const result = await useCase.execute({ leagueId });
// Then: It should return the memberships with driver info
expect(result.isOk()).toBe(true);
const data = result.unwrap();
expect(data.memberships).toHaveLength(1);
expect(data.memberships[0].driver?.id).toBe(driverId);
});
});

56
tests/integration/profile/use-cases/GetPendingSponsorshipRequestsUseCase.test.ts Normal file
View File

@@ -0,0 +1,56 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { ProfileTestContext } from '../ProfileTestContext';
import { GetPendingSponsorshipRequestsUseCase } from '../../../../core/racing/application/use-cases/GetPendingSponsorshipRequestsUseCase';
import { Sponsor } from '../../../../core/racing/domain/entities/sponsor/Sponsor';
import { SponsorshipRequest } from '../../../../core/racing/domain/entities/SponsorshipRequest';
import { Money } from '../../../../core/racing/domain/value-objects/Money';
describe('GetPendingSponsorshipRequestsUseCase', () => {
let context: ProfileTestContext;
let useCase: GetPendingSponsorshipRequestsUseCase;
beforeEach(async () => {
context = new ProfileTestContext();
useCase = new GetPendingSponsorshipRequestsUseCase(
context.sponsorshipRequestRepository,
context.sponsorRepository
);
await context.clear();
});
it('should retrieve pending sponsorship requests for a driver', async () => {
// Given: A driver has pending sponsorship requests
const driverId = 'd5';
const sponsorId = 's1';
const sponsor = Sponsor.create({
id: sponsorId,
name: 'Sponsor 1',
contactEmail: 'sponsor@example.com'
});
await context.sponsorRepository.create(sponsor);
const request = SponsorshipRequest.create({
id: 'sr1',
sponsorId,
entityType: 'driver',
entityId: driverId,
tier: 'main',
offeredAmount: Money.create(1000, 'USD')
});
await context.sponsorshipRequestRepository.create(request);
// When: GetPendingSponsorshipRequestsUseCase.execute() is called
const result = await useCase.execute({
entityType: 'driver',
entityId: driverId
});
// Then: It should return the pending requests
expect(result.isOk()).toBe(true);
const data = result.unwrap();
expect(data.requests).toHaveLength(1);
expect(data.requests[0].request.id).toBe('sr1');
expect(data.requests[0].sponsor?.id.toString()).toBe(sponsorId);
});
});

94
tests/integration/profile/use-cases/GetProfileOverviewUseCase.test.ts Normal file
View File

@@ -0,0 +1,94 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { ProfileTestContext } from '../ProfileTestContext';
import { GetProfileOverviewUseCase } from '../../../../core/racing/application/use-cases/GetProfileOverviewUseCase';
import { DriverStatsUseCase } from '../../../../core/racing/application/use-cases/DriverStatsUseCase';
import { RankingUseCase } from '../../../../core/racing/application/use-cases/RankingUseCase';
import { Driver } from '../../../../core/racing/domain/entities/Driver';
import { Team } from '../../../../core/racing/domain/entities/Team';
describe('GetProfileOverviewUseCase', () => {
let context: ProfileTestContext;
let useCase: GetProfileOverviewUseCase;
beforeEach(async () => {
context = new ProfileTestContext();
const driverStatsUseCase = new DriverStatsUseCase(
context.resultRepository,
context.standingRepository,
context.driverStatsRepository,
context.logger
);
const rankingUseCase = new RankingUseCase(
context.standingRepository,
context.driverRepository,
context.driverStatsRepository,
context.logger
);
useCase = new GetProfileOverviewUseCase(
context.driverRepository,
context.teamRepository,
context.teamMembershipRepository,
context.socialRepository,
context.driverExtendedProfileProvider,
driverStatsUseCase,
rankingUseCase
);
await context.clear();
});
it('should retrieve complete driver profile overview', async () => {
// Given: A driver exists with stats, team, and friends
const driverId = 'd1';
const driver = Driver.create({ id: driverId, iracingId: '1', name: 'John Doe', country: 'US' });
await context.driverRepository.create(driver);
await context.driverStatsRepository.saveDriverStats(driverId, {
rating: 2000,
totalRaces: 10,
wins: 2,
podiums: 5,
overallRank: 1,
safetyRating: 4.5,
sportsmanshipRating: 95,
dnfs: 0,
avgFinish: 3.5,
bestFinish: 1,
worstFinish: 10,
consistency: 85,
experienceLevel: 'pro'
} as any);
const team = Team.create({ id: 't1', name: 'Team 1', tag: 'T1', description: 'Desc', ownerId: 'other', leagues: [] });
await context.teamRepository.create(team);
await context.teamMembershipRepository.saveMembership({
teamId: 't1',
driverId: driverId,
role: 'driver',
status: 'active',
joinedAt: new Date()
});
context.socialRepository.seed({
drivers: [driver, Driver.create({ id: 'f1', iracingId: '2', name: 'Friend 1', country: 'UK' })],
friendships: [{ driverId: driverId, friendId: 'f1' }],
feedEvents: []
});
// When: GetProfileOverviewUseCase.execute() is called
const result = await useCase.execute({ driverId });
// Then: The result should contain all profile sections
expect(result.isOk()).toBe(true);
const overview = result.unwrap();
expect(overview.driverInfo.driver.id).toBe(driverId);
expect(overview.stats?.rating).toBe(2000);
expect(overview.teamMemberships).toHaveLength(1);
expect(overview.socialSummary.friendsCount).toBe(1);
});
it('should return error when driver does not exist', async () => {
const result = await useCase.execute({ driverId: 'non-existent' });
expect(result.isErr()).toBe(true);
expect((result.error as any).code).toBe('DRIVER_NOT_FOUND');
});
});

44
tests/integration/profile/use-cases/UpdateDriverProfileUseCase.test.ts Normal file
View File

@@ -0,0 +1,44 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { ProfileTestContext } from '../ProfileTestContext';
import { UpdateDriverProfileUseCase } from '../../../../core/racing/application/use-cases/UpdateDriverProfileUseCase';
import { Driver } from '../../../../core/racing/domain/entities/Driver';
describe('UpdateDriverProfileUseCase', () => {
let context: ProfileTestContext;
let useCase: UpdateDriverProfileUseCase;
beforeEach(async () => {
context = new ProfileTestContext();
useCase = new UpdateDriverProfileUseCase(context.driverRepository, context.logger);
await context.clear();
});
it('should update driver bio and country', async () => {
// Given: A driver exists
const driverId = 'd2';
const driver = Driver.create({ id: driverId, iracingId: '2', name: 'Update Driver', country: 'US' });
await context.driverRepository.create(driver);
// When: UpdateDriverProfileUseCase.execute() is called
const result = await useCase.execute({
driverId,
bio: 'New bio',
country: 'DE',
});
// Then: The driver should be updated
expect(result.isOk()).toBe(true);
const updatedDriver = await context.driverRepository.findById(driverId);
expect(updatedDriver?.bio?.toString()).toBe('New bio');
expect(updatedDriver?.country.toString()).toBe('DE');
});
it('should return error when driver does not exist', async () => {
const result = await useCase.execute({
driverId: 'non-existent',
bio: 'New bio',
});
expect(result.isErr()).toBe(true);
expect((result.error as any).code).toBe('DRIVER_NOT_FOUND');
});
});