integration tests
Some checks failed
CI / lint-typecheck (pull_request) Failing after 4m50s
CI / tests (pull_request) Has been skipped
CI / contract-tests (pull_request) Has been skipped
CI / e2e-tests (pull_request) Has been skipped
CI / comment-pr (pull_request) Has been skipped
CI / commit-types (pull_request) Has been skipped
Some checks failed
CI / lint-typecheck (pull_request) Failing after 4m50s
CI / tests (pull_request) Has been skipped
CI / contract-tests (pull_request) Has been skipped
CI / e2e-tests (pull_request) Has been skipped
CI / comment-pr (pull_request) Has been skipped
CI / commit-types (pull_request) Has been skipped
This commit is contained in:
@@ -1,170 +0,0 @@
|
||||
# Media Integration Tests - Implementation Notes
|
||||
|
||||
## Overview
|
||||
This document describes the implementation of integration tests for media functionality in the GridPilot project.
|
||||
|
||||
## Implemented Tests
|
||||
|
||||
### Avatar Management Integration Tests
|
||||
**File:** `avatar-management.integration.test.ts`
|
||||
|
||||
**Tests Implemented:**
|
||||
- `GetAvatarUseCase` - Success Path
|
||||
- Retrieves driver avatar when avatar exists
|
||||
- Returns AVATAR_NOT_FOUND when driver has no avatar
|
||||
- `GetAvatarUseCase` - Error Handling
|
||||
- Handles repository errors gracefully
|
||||
- `UpdateAvatarUseCase` - Success Path
|
||||
- Updates existing avatar for a driver
|
||||
- Updates avatar when driver has no existing avatar
|
||||
- `UpdateAvatarUseCase` - Error Handling
|
||||
- Handles repository errors gracefully
|
||||
- `RequestAvatarGenerationUseCase` - Success Path
|
||||
- Requests avatar generation from photo
|
||||
- Requests avatar generation with default style
|
||||
- `RequestAvatarGenerationUseCase` - Validation
|
||||
- Rejects generation with invalid face photo
|
||||
- `SelectAvatarUseCase` - Success Path
|
||||
- Selects a generated avatar
|
||||
- `SelectAvatarUseCase` - Error Handling
|
||||
- Rejects selection when request does not exist
|
||||
- Rejects selection when request is not completed
|
||||
- `GetUploadedMediaUseCase` - Success Path
|
||||
- Retrieves uploaded media
|
||||
- Returns null when media does not exist
|
||||
- `DeleteMediaUseCase` - Success Path
|
||||
- Deletes media file
|
||||
- `DeleteMediaUseCase` - Error Handling
|
||||
- Returns MEDIA_NOT_FOUND when media does not exist
|
||||
|
||||
**Use Cases Tested:**
|
||||
- `GetAvatarUseCase` - Retrieves driver avatar
|
||||
- `UpdateAvatarUseCase` - Updates an existing avatar for a driver
|
||||
- `RequestAvatarGenerationUseCase` - Requests avatar generation from a photo
|
||||
- `SelectAvatarUseCase` - Selects a generated avatar
|
||||
- `GetUploadedMediaUseCase` - Retrieves uploaded media
|
||||
- `DeleteMediaUseCase` - Deletes media files
|
||||
|
||||
**In-Memory Adapters Created:**
|
||||
- `InMemoryAvatarRepository` - Stores avatar entities in memory
|
||||
- `InMemoryAvatarGenerationRepository` - Stores avatar generation requests in memory
|
||||
- `InMemoryMediaRepository` - Stores media entities in memory
|
||||
- `InMemoryMediaStorageAdapter` - Simulates file storage in memory
|
||||
- `InMemoryFaceValidationAdapter` - Simulates face validation in memory
|
||||
- `InMemoryImageServiceAdapter` - Simulates image service in memory
|
||||
- `InMemoryMediaEventPublisher` - Stores domain events in memory
|
||||
|
||||
## Placeholder Tests
|
||||
|
||||
The following test files remain as placeholders because they reference domains that are not part of the core/media directory:
|
||||
|
||||
### Category Icon Management
|
||||
**File:** `category-icon-management.integration.test.ts`
|
||||
|
||||
**Status:** Placeholder - Not implemented
|
||||
|
||||
**Reason:** Category icon management would be part of the `core/categories` domain, not `core/media`. The test placeholders reference use cases like `GetCategoryIconsUseCase`, `UploadCategoryIconUseCase`, etc., which would be implemented in the categories domain.
|
||||
|
||||
### League Media Management
|
||||
**File:** `league-media-management.integration.test.ts`
|
||||
|
||||
**Status:** Placeholder - Not implemented
|
||||
|
||||
**Reason:** League media management would be part of the `core/leagues` domain, not `core/media`. The test placeholders reference use cases like `GetLeagueMediaUseCase`, `UploadLeagueCoverUseCase`, etc., which would be implemented in the leagues domain.
|
||||
|
||||
### Sponsor Logo Management
|
||||
**File:** `sponsor-logo-management.integration.test.ts`
|
||||
|
||||
**Status:** Placeholder - Not implemented
|
||||
|
||||
**Reason:** Sponsor logo management would be part of the `core/sponsors` domain, not `core/media`. The test placeholders reference use cases like `GetSponsorLogosUseCase`, `UploadSponsorLogoUseCase`, etc., which would be implemented in the sponsors domain.
|
||||
|
||||
### Team Logo Management
|
||||
**File:** `team-logo-management.integration.test.ts`
|
||||
|
||||
**Status:** Placeholder - Not implemented
|
||||
|
||||
**Reason:** Team logo management would be part of the `core/teams` domain, not `core/media`. The test placeholders reference use cases like `GetTeamLogosUseCase`, `UploadTeamLogoUseCase`, etc., which would be implemented in the teams domain.
|
||||
|
||||
### Track Image Management
|
||||
**File:** `track-image-management.integration.test.ts`
|
||||
|
||||
**Status:** Placeholder - Not implemented
|
||||
|
||||
**Reason:** Track image management would be part of the `core/tracks` domain, not `core/media`. The test placeholders reference use cases like `GetTrackImagesUseCase`, `UploadTrackImageUseCase`, etc., which would be implemented in the tracks domain.
|
||||
|
||||
## Architecture Compliance
|
||||
|
||||
### Core Layer (Business Logic)
|
||||
✅ **Compliant:** All tests focus on Core Use Cases only
|
||||
- Tests use In-Memory adapters for repositories and event publishers
|
||||
- Tests follow Given/When/Then pattern for business logic scenarios
|
||||
- Tests verify Use Case orchestration (interaction between Use Cases and their Ports)
|
||||
- Tests do NOT test HTTP endpoints, DTOs, or Presenters
|
||||
|
||||
### Adapters Layer (Infrastructure)
|
||||
✅ **Compliant:** In-Memory adapters created for testing
|
||||
- `InMemoryAvatarRepository` implements `AvatarRepository` port
|
||||
- `InMemoryMediaRepository` implements `MediaRepository` port
|
||||
- `InMemoryMediaStorageAdapter` implements `MediaStoragePort` port
|
||||
- `InMemoryFaceValidationAdapter` implements `FaceValidationPort` port
|
||||
- `InMemoryImageServiceAdapter` implements `ImageServicePort` port
|
||||
- `InMemoryMediaEventPublisher` stores domain events for verification
|
||||
|
||||
### Test Framework
|
||||
✅ **Compliant:** Using Vitest as specified
|
||||
- All tests use Vitest's `describe`, `it`, `expect`, `beforeAll`, `beforeEach`
|
||||
- Tests are asynchronous and use `async/await`
|
||||
- Tests verify both success paths and error handling
|
||||
|
||||
## Observations
|
||||
|
||||
### Media Implementation Structure
|
||||
The core/media directory contains:
|
||||
- **Domain Layer:** Entities (Avatar, Media, AvatarGenerationRequest), Value Objects (AvatarId, MediaUrl), Repositories (AvatarRepository, MediaRepository, AvatarGenerationRepository)
|
||||
- **Application Layer:** Use Cases (GetAvatarUseCase, UpdateAvatarUseCase, RequestAvatarGenerationUseCase, SelectAvatarUseCase, GetUploadedMediaUseCase, DeleteMediaUseCase), Ports (MediaStoragePort, AvatarGenerationPort, FaceValidationPort, ImageServicePort)
|
||||
|
||||
### Missing Use Cases
|
||||
The placeholder tests reference use cases that don't exist in the core/media directory:
|
||||
- `UploadAvatarUseCase` - Not found (likely part of a different domain)
|
||||
- `DeleteAvatarUseCase` - Not found (likely part of a different domain)
|
||||
- `GenerateAvatarFromPhotoUseCase` - Not found (replaced by `RequestAvatarGenerationUseCase` + `SelectAvatarUseCase`)
|
||||
|
||||
### Domain Boundaries
|
||||
The media functionality is split across multiple domains:
|
||||
- **core/media:** Avatar management and general media management
|
||||
- **core/categories:** Category icon management (not implemented)
|
||||
- **core/leagues:** League media management (not implemented)
|
||||
- **core/sponsors:** Sponsor logo management (not implemented)
|
||||
- **core/teams:** Team logo management (not implemented)
|
||||
- **core/tracks:** Track image management (not implemented)
|
||||
|
||||
Each domain would have its own media-related use cases and repositories, following the same pattern as the core/media domain.
|
||||
|
||||
## Recommendations
|
||||
|
||||
1. **For categories, leagues, sponsors, teams, and tracks domains:**
|
||||
- Create similar integration tests in their respective test directories
|
||||
- Follow the same pattern as avatar-management.integration.test.ts
|
||||
- Use In-Memory adapters for repositories and event publishers
|
||||
- Test Use Case orchestration only, not HTTP endpoints
|
||||
|
||||
2. **For missing use cases:**
|
||||
- If `UploadAvatarUseCase` and `DeleteAvatarUseCase` are needed, they should be implemented in the appropriate domain
|
||||
- The current implementation uses `UpdateAvatarUseCase` and `DeleteMediaUseCase` instead
|
||||
|
||||
3. **For event publishing:**
|
||||
- The current implementation uses `InMemoryMediaEventPublisher` for testing
|
||||
- In production, a real event publisher would be used
|
||||
- Events should be published for all significant state changes (avatar uploaded, avatar updated, media deleted, etc.)
|
||||
|
||||
## Conclusion
|
||||
|
||||
The integration tests for avatar management have been successfully implemented following the architecture requirements:
|
||||
- ✅ Tests Core Use Cases directly
|
||||
- ✅ Use In-Memory adapters for repositories and event publishers
|
||||
- ✅ Test Use Case orchestration (interaction between Use Cases and their Ports)
|
||||
- ✅ Follow Given/When/Then pattern for business logic scenarios
|
||||
- ✅ Do NOT test HTTP endpoints, DTOs, or Presenters
|
||||
|
||||
The placeholder tests for category, league, sponsor, team, and track media management remain as placeholders because they belong to different domains and would need to be implemented in their respective test directories.
|
||||
73
tests/integration/media/MediaTestContext.ts
Normal file
73
tests/integration/media/MediaTestContext.ts
Normal file
@@ -0,0 +1,73 @@
|
||||
import { ConsoleLogger } from '@adapters/logging/ConsoleLogger';
|
||||
import { InMemoryAvatarRepository } from '@adapters/media/persistence/inmemory/InMemoryAvatarRepository';
|
||||
import { InMemoryAvatarGenerationRepository } from '@adapters/media/persistence/inmemory/InMemoryAvatarGenerationRepository';
|
||||
import { InMemoryMediaRepository } from '@adapters/media/persistence/inmemory/InMemoryMediaRepository';
|
||||
import { InMemoryMediaStorageAdapter } from '@adapters/media/ports/InMemoryMediaStorageAdapter';
|
||||
import { InMemoryFaceValidationAdapter } from '@adapters/media/ports/InMemoryFaceValidationAdapter';
|
||||
import { InMemoryAvatarGenerationAdapter } from '@adapters/media/ports/InMemoryAvatarGenerationAdapter';
|
||||
import { InMemoryMediaEventPublisher } from '@adapters/media/events/InMemoryMediaEventPublisher';
|
||||
import { GetAvatarUseCase } from '@core/media/application/use-cases/GetAvatarUseCase';
|
||||
import { UpdateAvatarUseCase } from '@core/media/application/use-cases/UpdateAvatarUseCase';
|
||||
import { RequestAvatarGenerationUseCase } from '@core/media/application/use-cases/RequestAvatarGenerationUseCase';
|
||||
import { SelectAvatarUseCase } from '@core/media/application/use-cases/SelectAvatarUseCase';
|
||||
import { GetUploadedMediaUseCase } from '@core/media/application/use-cases/GetUploadedMediaUseCase';
|
||||
import { DeleteMediaUseCase } from '@core/media/application/use-cases/DeleteMediaUseCase';
|
||||
import { UploadMediaUseCase } from '@core/media/application/use-cases/UploadMediaUseCase';
|
||||
import { GetMediaUseCase } from '@core/media/application/use-cases/GetMediaUseCase';
|
||||
|
||||
export class MediaTestContext {
|
||||
public readonly logger: ConsoleLogger;
|
||||
public readonly avatarRepository: InMemoryAvatarRepository;
|
||||
public readonly avatarGenerationRepository: InMemoryAvatarGenerationRepository;
|
||||
public readonly mediaRepository: InMemoryMediaRepository;
|
||||
public readonly mediaStorage: InMemoryMediaStorageAdapter;
|
||||
public readonly faceValidation: InMemoryFaceValidationAdapter;
|
||||
public readonly avatarGeneration: InMemoryAvatarGenerationAdapter;
|
||||
public readonly eventPublisher: InMemoryMediaEventPublisher;
|
||||
|
||||
public readonly getAvatarUseCase: GetAvatarUseCase;
|
||||
public readonly updateAvatarUseCase: UpdateAvatarUseCase;
|
||||
public readonly requestAvatarGenerationUseCase: RequestAvatarGenerationUseCase;
|
||||
public readonly selectAvatarUseCase: SelectAvatarUseCase;
|
||||
public readonly getUploadedMediaUseCase: GetUploadedMediaUseCase;
|
||||
public readonly deleteMediaUseCase: DeleteMediaUseCase;
|
||||
public readonly uploadMediaUseCase: UploadMediaUseCase;
|
||||
public readonly getMediaUseCase: GetMediaUseCase;
|
||||
|
||||
private constructor() {
|
||||
this.logger = new ConsoleLogger();
|
||||
this.avatarRepository = new InMemoryAvatarRepository(this.logger);
|
||||
this.avatarGenerationRepository = new InMemoryAvatarGenerationRepository(this.logger);
|
||||
this.mediaRepository = new InMemoryMediaRepository(this.logger);
|
||||
this.mediaStorage = new InMemoryMediaStorageAdapter(this.logger);
|
||||
this.faceValidation = new InMemoryFaceValidationAdapter(this.logger);
|
||||
this.avatarGeneration = new InMemoryAvatarGenerationAdapter(this.logger);
|
||||
this.eventPublisher = new InMemoryMediaEventPublisher(this.logger);
|
||||
|
||||
this.getAvatarUseCase = new GetAvatarUseCase(this.avatarRepository, this.logger);
|
||||
this.updateAvatarUseCase = new UpdateAvatarUseCase(this.avatarRepository, this.logger);
|
||||
this.requestAvatarGenerationUseCase = new RequestAvatarGenerationUseCase(
|
||||
this.avatarGenerationRepository,
|
||||
this.faceValidation,
|
||||
this.avatarGeneration,
|
||||
this.logger
|
||||
);
|
||||
this.selectAvatarUseCase = new SelectAvatarUseCase(this.avatarGenerationRepository, this.logger);
|
||||
this.getUploadedMediaUseCase = new GetUploadedMediaUseCase(this.mediaStorage);
|
||||
this.deleteMediaUseCase = new DeleteMediaUseCase(this.mediaRepository, this.mediaStorage, this.logger);
|
||||
this.uploadMediaUseCase = new UploadMediaUseCase(this.mediaRepository, this.mediaStorage, this.logger);
|
||||
this.getMediaUseCase = new GetMediaUseCase(this.mediaRepository, this.logger);
|
||||
}
|
||||
|
||||
public static create(): MediaTestContext {
|
||||
return new MediaTestContext();
|
||||
}
|
||||
|
||||
public reset(): void {
|
||||
this.avatarRepository.clear();
|
||||
this.avatarGenerationRepository.clear();
|
||||
this.mediaRepository.clear();
|
||||
this.mediaStorage.clear();
|
||||
this.eventPublisher.clear();
|
||||
}
|
||||
}
|
||||
@@ -1,478 +0,0 @@
|
||||
/**
|
||||
* Integration Test: Avatar Management Use Case Orchestration
|
||||
*
|
||||
* Tests the orchestration logic of avatar-related Use Cases:
|
||||
* - GetAvatarUseCase: Retrieves driver avatar
|
||||
* - UpdateAvatarUseCase: Updates an existing avatar for a driver
|
||||
* - RequestAvatarGenerationUseCase: Requests avatar generation from a photo
|
||||
* - SelectAvatarUseCase: Selects a generated avatar
|
||||
* - GetUploadedMediaUseCase: Retrieves uploaded media
|
||||
* - DeleteMediaUseCase: Deletes media files
|
||||
* - 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 { ConsoleLogger } from '@core/shared/logging/ConsoleLogger';
|
||||
import { InMemoryAvatarRepository } from '@adapters/media/persistence/inmemory/InMemoryAvatarRepository';
|
||||
import { InMemoryAvatarGenerationRepository } from '@adapters/media/persistence/inmemory/InMemoryAvatarGenerationRepository';
|
||||
import { InMemoryMediaRepository } from '@adapters/media/persistence/inmemory/InMemoryMediaRepository';
|
||||
import { InMemoryMediaStorageAdapter } from '@adapters/media/ports/InMemoryMediaStorageAdapter';
|
||||
import { InMemoryFaceValidationAdapter } from '@adapters/media/ports/InMemoryFaceValidationAdapter';
|
||||
import { InMemoryImageServiceAdapter } from '@adapters/media/ports/InMemoryImageServiceAdapter';
|
||||
import { InMemoryMediaEventPublisher } from '@adapters/media/events/InMemoryMediaEventPublisher';
|
||||
import { GetAvatarUseCase } from '@core/media/application/use-cases/GetAvatarUseCase';
|
||||
import { UpdateAvatarUseCase } from '@core/media/application/use-cases/UpdateAvatarUseCase';
|
||||
import { RequestAvatarGenerationUseCase } from '@core/media/application/use-cases/RequestAvatarGenerationUseCase';
|
||||
import { SelectAvatarUseCase } from '@core/media/application/use-cases/SelectAvatarUseCase';
|
||||
import { GetUploadedMediaUseCase } from '@core/media/application/use-cases/GetUploadedMediaUseCase';
|
||||
import { DeleteMediaUseCase } from '@core/media/application/use-cases/DeleteMediaUseCase';
|
||||
import { Avatar } from '@core/media/domain/entities/Avatar';
|
||||
import { AvatarGenerationRequest } from '@core/media/domain/entities/AvatarGenerationRequest';
|
||||
import { Media } from '@core/media/domain/entities/Media';
|
||||
|
||||
describe('Avatar Management Use Case Orchestration', () => {
|
||||
let avatarRepository: InMemoryAvatarRepository;
|
||||
let avatarGenerationRepository: InMemoryAvatarGenerationRepository;
|
||||
let mediaRepository: InMemoryMediaRepository;
|
||||
let mediaStorage: InMemoryMediaStorageAdapter;
|
||||
let faceValidation: InMemoryFaceValidationAdapter;
|
||||
let imageService: InMemoryImageServiceAdapter;
|
||||
let eventPublisher: InMemoryMediaEventPublisher;
|
||||
let logger: ConsoleLogger;
|
||||
let getAvatarUseCase: GetAvatarUseCase;
|
||||
let updateAvatarUseCase: UpdateAvatarUseCase;
|
||||
let requestAvatarGenerationUseCase: RequestAvatarGenerationUseCase;
|
||||
let selectAvatarUseCase: SelectAvatarUseCase;
|
||||
let getUploadedMediaUseCase: GetUploadedMediaUseCase;
|
||||
let deleteMediaUseCase: DeleteMediaUseCase;
|
||||
|
||||
beforeAll(() => {
|
||||
logger = new ConsoleLogger();
|
||||
avatarRepository = new InMemoryAvatarRepository(logger);
|
||||
avatarGenerationRepository = new InMemoryAvatarGenerationRepository(logger);
|
||||
mediaRepository = new InMemoryMediaRepository(logger);
|
||||
mediaStorage = new InMemoryMediaStorageAdapter(logger);
|
||||
faceValidation = new InMemoryFaceValidationAdapter(logger);
|
||||
imageService = new InMemoryImageServiceAdapter(logger);
|
||||
eventPublisher = new InMemoryMediaEventPublisher(logger);
|
||||
|
||||
getAvatarUseCase = new GetAvatarUseCase(avatarRepository, logger);
|
||||
updateAvatarUseCase = new UpdateAvatarUseCase(avatarRepository, logger);
|
||||
requestAvatarGenerationUseCase = new RequestAvatarGenerationUseCase(
|
||||
avatarGenerationRepository,
|
||||
faceValidation,
|
||||
imageService,
|
||||
logger
|
||||
);
|
||||
selectAvatarUseCase = new SelectAvatarUseCase(avatarGenerationRepository, logger);
|
||||
getUploadedMediaUseCase = new GetUploadedMediaUseCase(mediaStorage);
|
||||
deleteMediaUseCase = new DeleteMediaUseCase(mediaRepository, mediaStorage, logger);
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
avatarRepository.clear();
|
||||
avatarGenerationRepository.clear();
|
||||
mediaRepository.clear();
|
||||
mediaStorage.clear();
|
||||
eventPublisher.clear();
|
||||
});
|
||||
|
||||
describe('GetAvatarUseCase - Success Path', () => {
|
||||
it('should retrieve driver avatar when avatar exists', async () => {
|
||||
// Scenario: Driver with existing avatar
|
||||
// Given: A driver exists with an avatar
|
||||
const avatar = Avatar.create({
|
||||
id: 'avatar-1',
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/avatar.png',
|
||||
});
|
||||
await avatarRepository.save(avatar);
|
||||
|
||||
// When: GetAvatarUseCase.execute() is called with driver ID
|
||||
const result = await getAvatarUseCase.execute({ driverId: 'driver-1' });
|
||||
|
||||
// Then: The result should contain the avatar data
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.avatar.id).toBe('avatar-1');
|
||||
expect(successResult.avatar.driverId).toBe('driver-1');
|
||||
expect(successResult.avatar.mediaUrl).toBe('https://example.com/avatar.png');
|
||||
expect(successResult.avatar.selectedAt).toBeInstanceOf(Date);
|
||||
});
|
||||
|
||||
it('should return AVATAR_NOT_FOUND when driver has no avatar', async () => {
|
||||
// Scenario: Driver without avatar
|
||||
// Given: A driver exists without an avatar
|
||||
// When: GetAvatarUseCase.execute() is called with driver ID
|
||||
const result = await getAvatarUseCase.execute({ driverId: 'driver-1' });
|
||||
|
||||
// Then: Should return AVATAR_NOT_FOUND error
|
||||
expect(result.isErr()).toBe(true);
|
||||
const err = result.unwrapErr();
|
||||
expect(err.code).toBe('AVATAR_NOT_FOUND');
|
||||
expect(err.details.message).toBe('Avatar not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetAvatarUseCase - Error Handling', () => {
|
||||
it('should handle repository errors gracefully', async () => {
|
||||
// Scenario: Repository error
|
||||
// Given: AvatarRepository throws an error
|
||||
const originalFind = avatarRepository.findActiveByDriverId;
|
||||
avatarRepository.findActiveByDriverId = async () => {
|
||||
throw new Error('Database connection error');
|
||||
};
|
||||
|
||||
// When: GetAvatarUseCase.execute() is called
|
||||
const result = await getAvatarUseCase.execute({ driverId: 'driver-1' });
|
||||
|
||||
// Then: Should return REPOSITORY_ERROR
|
||||
expect(result.isErr()).toBe(true);
|
||||
const err = result.unwrapErr();
|
||||
expect(err.code).toBe('REPOSITORY_ERROR');
|
||||
expect(err.details.message).toContain('Database connection error');
|
||||
|
||||
// Restore original method
|
||||
avatarRepository.findActiveByDriverId = originalFind;
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateAvatarUseCase - Success Path', () => {
|
||||
it('should update existing avatar for a driver', async () => {
|
||||
// Scenario: Driver updates existing avatar
|
||||
// Given: A driver exists with an existing avatar
|
||||
const existingAvatar = Avatar.create({
|
||||
id: 'avatar-1',
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/old-avatar.png',
|
||||
});
|
||||
await avatarRepository.save(existingAvatar);
|
||||
|
||||
// When: UpdateAvatarUseCase.execute() is called with driver ID and new image data
|
||||
const result = await updateAvatarUseCase.execute({
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/new-avatar.png',
|
||||
});
|
||||
|
||||
// Then: The old avatar should be deactivated and new one created
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.avatarId).toBeDefined();
|
||||
expect(successResult.driverId).toBe('driver-1');
|
||||
|
||||
// Verify old avatar is deactivated
|
||||
const oldAvatar = await avatarRepository.findById('avatar-1');
|
||||
expect(oldAvatar?.isActive).toBe(false);
|
||||
|
||||
// Verify new avatar exists
|
||||
const newAvatar = await avatarRepository.findActiveByDriverId('driver-1');
|
||||
expect(newAvatar).not.toBeNull();
|
||||
expect(newAvatar?.mediaUrl.value).toBe('https://example.com/new-avatar.png');
|
||||
});
|
||||
|
||||
it('should update avatar when driver has no existing avatar', async () => {
|
||||
// Scenario: Driver updates avatar when no avatar exists
|
||||
// Given: A driver exists without an avatar
|
||||
// When: UpdateAvatarUseCase.execute() is called
|
||||
const result = await updateAvatarUseCase.execute({
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/avatar.png',
|
||||
});
|
||||
|
||||
// Then: A new avatar should be created
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.avatarId).toBeDefined();
|
||||
expect(successResult.driverId).toBe('driver-1');
|
||||
|
||||
// Verify new avatar exists
|
||||
const newAvatar = await avatarRepository.findActiveByDriverId('driver-1');
|
||||
expect(newAvatar).not.toBeNull();
|
||||
expect(newAvatar?.mediaUrl.value).toBe('https://example.com/avatar.png');
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateAvatarUseCase - Error Handling', () => {
|
||||
it('should handle repository errors gracefully', async () => {
|
||||
// Scenario: Repository error
|
||||
// Given: AvatarRepository throws an error
|
||||
const originalSave = avatarRepository.save;
|
||||
avatarRepository.save = async () => {
|
||||
throw new Error('Database connection error');
|
||||
};
|
||||
|
||||
// When: UpdateAvatarUseCase.execute() is called
|
||||
const result = await updateAvatarUseCase.execute({
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/avatar.png',
|
||||
});
|
||||
|
||||
// Then: Should return REPOSITORY_ERROR
|
||||
expect(result.isErr()).toBe(true);
|
||||
const err = result.unwrapErr();
|
||||
expect(err.code).toBe('REPOSITORY_ERROR');
|
||||
expect(err.details.message).toContain('Database connection error');
|
||||
|
||||
// Restore original method
|
||||
avatarRepository.save = originalSave;
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
describe('RequestAvatarGenerationUseCase - Success Path', () => {
|
||||
it('should request avatar generation from photo', async () => {
|
||||
// Scenario: Driver requests avatar generation from photo
|
||||
// Given: A driver exists
|
||||
// And: Valid photo data is provided
|
||||
// When: RequestAvatarGenerationUseCase.execute() is called with driver ID and photo data
|
||||
const result = await requestAvatarGenerationUseCase.execute({
|
||||
userId: 'user-1',
|
||||
facePhotoData: 'https://example.com/face-photo.jpg',
|
||||
suitColor: 'red',
|
||||
style: 'realistic',
|
||||
});
|
||||
|
||||
// Then: An avatar generation request should be created
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.requestId).toBeDefined();
|
||||
expect(successResult.status).toBe('completed');
|
||||
expect(successResult.avatarUrls).toBeDefined();
|
||||
expect(successResult.avatarUrls?.length).toBeGreaterThan(0);
|
||||
|
||||
// Verify request was saved
|
||||
const request = await avatarGenerationRepository.findById(successResult.requestId);
|
||||
expect(request).not.toBeNull();
|
||||
expect(request?.status).toBe('completed');
|
||||
});
|
||||
|
||||
it('should request avatar generation with default style', async () => {
|
||||
// Scenario: Driver requests avatar generation with default style
|
||||
// Given: A driver exists
|
||||
// When: RequestAvatarGenerationUseCase.execute() is called without style
|
||||
const result = await requestAvatarGenerationUseCase.execute({
|
||||
userId: 'user-1',
|
||||
facePhotoData: 'https://example.com/face-photo.jpg',
|
||||
suitColor: 'blue',
|
||||
});
|
||||
|
||||
// Then: An avatar generation request should be created with default style
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.requestId).toBeDefined();
|
||||
expect(successResult.status).toBe('completed');
|
||||
});
|
||||
});
|
||||
|
||||
describe('RequestAvatarGenerationUseCase - Validation', () => {
|
||||
it('should reject generation with invalid face photo', async () => {
|
||||
// Scenario: Invalid face photo
|
||||
// Given: A driver exists
|
||||
// And: Face validation fails
|
||||
const originalValidate = faceValidation.validateFacePhoto;
|
||||
faceValidation.validateFacePhoto = async () => ({
|
||||
isValid: false,
|
||||
hasFace: false,
|
||||
faceCount: 0,
|
||||
confidence: 0.0,
|
||||
errorMessage: 'No face detected',
|
||||
});
|
||||
|
||||
// When: RequestAvatarGenerationUseCase.execute() is called
|
||||
const result = await requestAvatarGenerationUseCase.execute({
|
||||
userId: 'user-1',
|
||||
facePhotoData: 'https://example.com/invalid-photo.jpg',
|
||||
suitColor: 'red',
|
||||
});
|
||||
|
||||
// Then: Should return FACE_VALIDATION_FAILED error
|
||||
expect(result.isErr()).toBe(true);
|
||||
const err = result.unwrapErr();
|
||||
expect(err.code).toBe('FACE_VALIDATION_FAILED');
|
||||
expect(err.details.message).toContain('No face detected');
|
||||
|
||||
// Restore original method
|
||||
faceValidation.validateFacePhoto = originalValidate;
|
||||
});
|
||||
});
|
||||
|
||||
describe('SelectAvatarUseCase - Success Path', () => {
|
||||
it('should select a generated avatar', async () => {
|
||||
// Scenario: Driver selects a generated avatar
|
||||
// Given: A completed avatar generation request exists
|
||||
const request = AvatarGenerationRequest.create({
|
||||
id: 'request-1',
|
||||
userId: 'user-1',
|
||||
facePhotoUrl: 'https://example.com/face-photo.jpg',
|
||||
suitColor: 'red',
|
||||
style: 'realistic',
|
||||
});
|
||||
request.completeWithAvatars([
|
||||
'https://example.com/avatar-1.png',
|
||||
'https://example.com/avatar-2.png',
|
||||
'https://example.com/avatar-3.png',
|
||||
]);
|
||||
await avatarGenerationRepository.save(request);
|
||||
|
||||
// When: SelectAvatarUseCase.execute() is called with request ID and selected index
|
||||
const result = await selectAvatarUseCase.execute({
|
||||
requestId: 'request-1',
|
||||
selectedIndex: 1,
|
||||
});
|
||||
|
||||
// Then: The avatar should be selected
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.requestId).toBe('request-1');
|
||||
expect(successResult.selectedAvatarUrl).toBe('https://example.com/avatar-2.png');
|
||||
|
||||
// Verify request was updated
|
||||
const updatedRequest = await avatarGenerationRepository.findById('request-1');
|
||||
expect(updatedRequest?.selectedAvatarUrl).toBe('https://example.com/avatar-2.png');
|
||||
});
|
||||
});
|
||||
|
||||
describe('SelectAvatarUseCase - Error Handling', () => {
|
||||
it('should reject selection when request does not exist', async () => {
|
||||
// Scenario: Request does not exist
|
||||
// Given: No request exists with the given ID
|
||||
// When: SelectAvatarUseCase.execute() is called
|
||||
const result = await selectAvatarUseCase.execute({
|
||||
requestId: 'non-existent-request',
|
||||
selectedIndex: 0,
|
||||
});
|
||||
|
||||
// Then: Should return REQUEST_NOT_FOUND error
|
||||
expect(result.isErr()).toBe(true);
|
||||
const err = result.unwrapErr();
|
||||
expect(err.code).toBe('REQUEST_NOT_FOUND');
|
||||
});
|
||||
|
||||
it('should reject selection when request is not completed', async () => {
|
||||
// Scenario: Request is not completed
|
||||
// Given: An incomplete avatar generation request exists
|
||||
const request = AvatarGenerationRequest.create({
|
||||
id: 'request-1',
|
||||
userId: 'user-1',
|
||||
facePhotoUrl: 'https://example.com/face-photo.jpg',
|
||||
suitColor: 'red',
|
||||
style: 'realistic',
|
||||
});
|
||||
await avatarGenerationRepository.save(request);
|
||||
|
||||
// When: SelectAvatarUseCase.execute() is called
|
||||
const result = await selectAvatarUseCase.execute({
|
||||
requestId: 'request-1',
|
||||
selectedIndex: 0,
|
||||
});
|
||||
|
||||
// Then: Should return REQUEST_NOT_COMPLETED error
|
||||
expect(result.isErr()).toBe(true);
|
||||
const err = result.unwrapErr();
|
||||
expect(err.code).toBe('REQUEST_NOT_COMPLETED');
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetUploadedMediaUseCase - Success Path', () => {
|
||||
it('should retrieve uploaded media', async () => {
|
||||
// Scenario: Retrieve uploaded media
|
||||
// Given: Media has been uploaded
|
||||
const uploadResult = await mediaStorage.uploadMedia(
|
||||
Buffer.from('test media content'),
|
||||
{
|
||||
filename: 'test-avatar.png',
|
||||
mimeType: 'image/png',
|
||||
}
|
||||
);
|
||||
|
||||
expect(uploadResult.success).toBe(true);
|
||||
const storageKey = uploadResult.url!;
|
||||
|
||||
// When: GetUploadedMediaUseCase.execute() is called
|
||||
const result = await getUploadedMediaUseCase.execute({ storageKey });
|
||||
|
||||
// Then: The media should be retrieved
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult).not.toBeNull();
|
||||
expect(successResult?.bytes).toBeInstanceOf(Buffer);
|
||||
expect(successResult?.contentType).toBe('image/png');
|
||||
});
|
||||
|
||||
it('should return null when media does not exist', async () => {
|
||||
// Scenario: Media does not exist
|
||||
// Given: No media exists with the given storage key
|
||||
// When: GetUploadedMediaUseCase.execute() is called
|
||||
const result = await getUploadedMediaUseCase.execute({ storageKey: 'non-existent-key' });
|
||||
|
||||
// Then: Should return null
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteMediaUseCase - Success Path', () => {
|
||||
it('should delete media file', async () => {
|
||||
// Scenario: Delete media file
|
||||
// Given: Media has been uploaded
|
||||
const uploadResult = await mediaStorage.uploadMedia(
|
||||
Buffer.from('test media content'),
|
||||
{
|
||||
filename: 'test-avatar.png',
|
||||
mimeType: 'image/png',
|
||||
}
|
||||
);
|
||||
|
||||
expect(uploadResult.success).toBe(true);
|
||||
const storageKey = uploadResult.url!;
|
||||
|
||||
// Create media entity
|
||||
const media = Media.create({
|
||||
id: 'media-1',
|
||||
filename: 'test-avatar.png',
|
||||
originalName: 'test-avatar.png',
|
||||
mimeType: 'image/png',
|
||||
size: 18,
|
||||
url: storageKey,
|
||||
type: 'image',
|
||||
uploadedBy: 'user-1',
|
||||
});
|
||||
await mediaRepository.save(media);
|
||||
|
||||
// When: DeleteMediaUseCase.execute() is called
|
||||
const result = await deleteMediaUseCase.execute({ mediaId: 'media-1' });
|
||||
|
||||
// Then: The media should be deleted
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.mediaId).toBe('media-1');
|
||||
expect(successResult.deleted).toBe(true);
|
||||
|
||||
// Verify media is deleted from repository
|
||||
const deletedMedia = await mediaRepository.findById('media-1');
|
||||
expect(deletedMedia).toBeNull();
|
||||
|
||||
// Verify media is deleted from storage
|
||||
const storageExists = mediaStorage.has(storageKey);
|
||||
expect(storageExists).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteMediaUseCase - Error Handling', () => {
|
||||
it('should return MEDIA_NOT_FOUND when media does not exist', async () => {
|
||||
// Scenario: Media does not exist
|
||||
// Given: No media exists with the given ID
|
||||
// When: DeleteMediaUseCase.execute() is called
|
||||
const result = await deleteMediaUseCase.execute({ mediaId: 'non-existent-media' });
|
||||
|
||||
// Then: Should return MEDIA_NOT_FOUND error
|
||||
expect(result.isErr()).toBe(true);
|
||||
const err = result.unwrapErr();
|
||||
expect(err.code).toBe('MEDIA_NOT_FOUND');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,114 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { MediaTestContext } from '../MediaTestContext';
|
||||
import { AvatarGenerationRequest } from '@core/media/domain/entities/AvatarGenerationRequest';
|
||||
|
||||
describe('Avatar Management: Generation and Selection', () => {
|
||||
let ctx: MediaTestContext;
|
||||
|
||||
beforeEach(() => {
|
||||
ctx = MediaTestContext.create();
|
||||
ctx.reset();
|
||||
});
|
||||
|
||||
describe('RequestAvatarGenerationUseCase', () => {
|
||||
it('should request avatar generation from photo', async () => {
|
||||
const result = await ctx.requestAvatarGenerationUseCase.execute({
|
||||
userId: 'user-1',
|
||||
facePhotoData: 'https://example.com/face-photo.jpg',
|
||||
suitColor: 'red',
|
||||
style: 'realistic',
|
||||
});
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.requestId).toBeDefined();
|
||||
expect(successResult.status).toBe('completed');
|
||||
expect(successResult.avatarUrls).toHaveLength(3);
|
||||
|
||||
const request = await ctx.avatarGenerationRepository.findById(successResult.requestId);
|
||||
expect(request).not.toBeNull();
|
||||
expect(request?.status).toBe('completed');
|
||||
});
|
||||
|
||||
it('should reject generation with invalid face photo', async () => {
|
||||
const originalValidate = ctx.faceValidation.validateFacePhoto;
|
||||
ctx.faceValidation.validateFacePhoto = async () => ({
|
||||
isValid: false,
|
||||
hasFace: false,
|
||||
faceCount: 0,
|
||||
confidence: 0.0,
|
||||
errorMessage: 'No face detected',
|
||||
});
|
||||
|
||||
const result = await ctx.requestAvatarGenerationUseCase.execute({
|
||||
userId: 'user-1',
|
||||
facePhotoData: 'https://example.com/invalid-photo.jpg',
|
||||
suitColor: 'red',
|
||||
});
|
||||
|
||||
expect(result.isErr()).toBe(true);
|
||||
expect(result.unwrapErr().code).toBe('FACE_VALIDATION_FAILED');
|
||||
|
||||
ctx.faceValidation.validateFacePhoto = originalValidate;
|
||||
});
|
||||
});
|
||||
|
||||
describe('SelectAvatarUseCase', () => {
|
||||
it('should select a generated avatar', async () => {
|
||||
const request = AvatarGenerationRequest.create({
|
||||
id: 'request-1',
|
||||
userId: 'user-1',
|
||||
facePhotoUrl: 'https://example.com/face-photo.jpg',
|
||||
suitColor: 'red',
|
||||
style: 'realistic',
|
||||
});
|
||||
request.completeWithAvatars([
|
||||
'https://example.com/avatar-1.png',
|
||||
'https://example.com/avatar-2.png',
|
||||
'https://example.com/avatar-3.png',
|
||||
]);
|
||||
await ctx.avatarGenerationRepository.save(request);
|
||||
|
||||
const result = await ctx.selectAvatarUseCase.execute({
|
||||
requestId: 'request-1',
|
||||
selectedIndex: 1,
|
||||
});
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.selectedAvatarUrl).toBe('https://example.com/avatar-2.png');
|
||||
|
||||
const updatedRequest = await ctx.avatarGenerationRepository.findById('request-1');
|
||||
expect(updatedRequest?.selectedAvatarUrl).toBe('https://example.com/avatar-2.png');
|
||||
});
|
||||
|
||||
it('should reject selection when request does not exist', async () => {
|
||||
const result = await ctx.selectAvatarUseCase.execute({
|
||||
requestId: 'non-existent-request',
|
||||
selectedIndex: 0,
|
||||
});
|
||||
|
||||
expect(result.isErr()).toBe(true);
|
||||
expect(result.unwrapErr().code).toBe('REQUEST_NOT_FOUND');
|
||||
});
|
||||
|
||||
it('should reject selection when request is not completed', async () => {
|
||||
const request = AvatarGenerationRequest.create({
|
||||
id: 'request-1',
|
||||
userId: 'user-1',
|
||||
facePhotoUrl: 'https://example.com/face-photo.jpg',
|
||||
suitColor: 'red',
|
||||
style: 'realistic',
|
||||
});
|
||||
await ctx.avatarGenerationRepository.save(request);
|
||||
|
||||
const result = await ctx.selectAvatarUseCase.execute({
|
||||
requestId: 'request-1',
|
||||
selectedIndex: 0,
|
||||
});
|
||||
|
||||
expect(result.isErr()).toBe(true);
|
||||
expect(result.unwrapErr().code).toBe('REQUEST_NOT_COMPLETED');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,89 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { MediaTestContext } from '../MediaTestContext';
|
||||
import { Avatar } from '@core/media/domain/entities/Avatar';
|
||||
|
||||
describe('Avatar Management: Retrieval and Updates', () => {
|
||||
let ctx: MediaTestContext;
|
||||
|
||||
beforeEach(() => {
|
||||
ctx = MediaTestContext.create();
|
||||
ctx.reset();
|
||||
});
|
||||
|
||||
describe('GetAvatarUseCase', () => {
|
||||
it('should retrieve driver avatar when avatar exists', async () => {
|
||||
const avatar = Avatar.create({
|
||||
id: 'avatar-1',
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/avatar.png',
|
||||
});
|
||||
await ctx.avatarRepository.save(avatar);
|
||||
|
||||
const result = await ctx.getAvatarUseCase.execute({ driverId: 'driver-1' });
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.avatar.id).toBe('avatar-1');
|
||||
expect(successResult.avatar.driverId).toBe('driver-1');
|
||||
expect(successResult.avatar.mediaUrl).toBe('https://example.com/avatar.png');
|
||||
});
|
||||
|
||||
it('should return AVATAR_NOT_FOUND when driver has no avatar', async () => {
|
||||
const result = await ctx.getAvatarUseCase.execute({ driverId: 'driver-1' });
|
||||
|
||||
expect(result.isErr()).toBe(true);
|
||||
expect(result.unwrapErr().code).toBe('AVATAR_NOT_FOUND');
|
||||
});
|
||||
|
||||
it('should handle repository errors gracefully', async () => {
|
||||
const originalFind = ctx.avatarRepository.findActiveByDriverId;
|
||||
ctx.avatarRepository.findActiveByDriverId = async () => {
|
||||
throw new Error('Database connection error');
|
||||
};
|
||||
|
||||
const result = await ctx.getAvatarUseCase.execute({ driverId: 'driver-1' });
|
||||
|
||||
expect(result.isErr()).toBe(true);
|
||||
expect(result.unwrapErr().code).toBe('REPOSITORY_ERROR');
|
||||
|
||||
ctx.avatarRepository.findActiveByDriverId = originalFind;
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateAvatarUseCase', () => {
|
||||
it('should update existing avatar for a driver', async () => {
|
||||
const existingAvatar = Avatar.create({
|
||||
id: 'avatar-1',
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/old-avatar.png',
|
||||
});
|
||||
await ctx.avatarRepository.save(existingAvatar);
|
||||
|
||||
const result = await ctx.updateAvatarUseCase.execute({
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/new-avatar.png',
|
||||
});
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
|
||||
const oldAvatar = await ctx.avatarRepository.findById('avatar-1');
|
||||
expect(oldAvatar?.isActive).toBe(false);
|
||||
|
||||
const newAvatar = await ctx.avatarRepository.findActiveByDriverId('driver-1');
|
||||
expect(newAvatar).not.toBeNull();
|
||||
expect(newAvatar?.mediaUrl.value).toBe('https://example.com/new-avatar.png');
|
||||
});
|
||||
|
||||
it('should update avatar when driver has no existing avatar', async () => {
|
||||
const result = await ctx.updateAvatarUseCase.execute({
|
||||
driverId: 'driver-1',
|
||||
mediaUrl: 'https://example.com/avatar.png',
|
||||
});
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
const newAvatar = await ctx.avatarRepository.findActiveByDriverId('driver-1');
|
||||
expect(newAvatar).not.toBeNull();
|
||||
expect(newAvatar?.mediaUrl.value).toBe('https://example.com/avatar.png');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,41 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { MediaTestContext } from '../MediaTestContext';
|
||||
|
||||
describe('Category Icon Management', () => {
|
||||
let ctx: MediaTestContext;
|
||||
|
||||
beforeEach(() => {
|
||||
ctx = MediaTestContext.create();
|
||||
ctx.reset();
|
||||
});
|
||||
|
||||
it('should upload and retrieve a category icon', async () => {
|
||||
// When: An icon is uploaded
|
||||
const uploadResult = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('icon content'),
|
||||
{ filename: 'icon.png', mimeType: 'image/png' }
|
||||
);
|
||||
expect(uploadResult.success).toBe(true);
|
||||
const storageKey = uploadResult.url!;
|
||||
|
||||
// Then: The icon should be retrievable from storage
|
||||
const retrieved = await ctx.getUploadedMediaUseCase.execute({ storageKey });
|
||||
expect(retrieved.isOk()).toBe(true);
|
||||
expect(retrieved.unwrap()?.contentType).toBe('image/png');
|
||||
});
|
||||
|
||||
it('should handle multiple category icons', async () => {
|
||||
const upload1 = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('icon 1'),
|
||||
{ filename: 'icon1.png', mimeType: 'image/png' }
|
||||
);
|
||||
const upload2 = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('icon 2'),
|
||||
{ filename: 'icon2.png', mimeType: 'image/png' }
|
||||
);
|
||||
|
||||
expect(upload1.success).toBe(true);
|
||||
expect(upload2.success).toBe(true);
|
||||
expect(ctx.mediaStorage.size).toBe(2);
|
||||
});
|
||||
});
|
||||
@@ -1,313 +0,0 @@
|
||||
/**
|
||||
* Integration Test: Category Icon Management Use Case Orchestration
|
||||
*
|
||||
* Tests the orchestration logic of category icon-related Use Cases:
|
||||
* - GetCategoryIconsUseCase: Retrieves category icons
|
||||
* - UploadCategoryIconUseCase: Uploads a new category icon
|
||||
* - UpdateCategoryIconUseCase: Updates an existing category icon
|
||||
* - DeleteCategoryIconUseCase: Deletes a category icon
|
||||
* - 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';
|
||||
|
||||
describe('Category Icon Management Use Case Orchestration', () => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// let categoryIconRepository: InMemoryCategoryIconRepository;
|
||||
// let categoryRepository: InMemoryCategoryRepository;
|
||||
// let eventPublisher: InMemoryEventPublisher;
|
||||
// let getCategoryIconsUseCase: GetCategoryIconsUseCase;
|
||||
// let uploadCategoryIconUseCase: UploadCategoryIconUseCase;
|
||||
// let updateCategoryIconUseCase: UpdateCategoryIconUseCase;
|
||||
// let deleteCategoryIconUseCase: DeleteCategoryIconUseCase;
|
||||
|
||||
beforeAll(() => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// categoryIconRepository = new InMemoryCategoryIconRepository();
|
||||
// categoryRepository = new InMemoryCategoryRepository();
|
||||
// eventPublisher = new InMemoryEventPublisher();
|
||||
// getCategoryIconsUseCase = new GetCategoryIconsUseCase({
|
||||
// categoryIconRepository,
|
||||
// categoryRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// uploadCategoryIconUseCase = new UploadCategoryIconUseCase({
|
||||
// categoryIconRepository,
|
||||
// categoryRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// updateCategoryIconUseCase = new UpdateCategoryIconUseCase({
|
||||
// categoryIconRepository,
|
||||
// categoryRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// deleteCategoryIconUseCase = new DeleteCategoryIconUseCase({
|
||||
// categoryIconRepository,
|
||||
// categoryRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
// TODO: Clear all In-Memory repositories before each test
|
||||
// categoryIconRepository.clear();
|
||||
// categoryRepository.clear();
|
||||
// eventPublisher.clear();
|
||||
});
|
||||
|
||||
describe('GetCategoryIconsUseCase - Success Path', () => {
|
||||
it('should retrieve all category icons', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Multiple categories with icons
|
||||
// Given: Multiple categories exist with icons
|
||||
// When: GetCategoryIconsUseCase.execute() is called
|
||||
// Then: The result should contain all category icons
|
||||
// And: Each icon should have correct metadata
|
||||
// And: EventPublisher should emit CategoryIconsRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve category icons for specific category type', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Filter by category type
|
||||
// Given: Categories exist with different types
|
||||
// When: GetCategoryIconsUseCase.execute() is called with type filter
|
||||
// Then: The result should only contain icons for that type
|
||||
// And: EventPublisher should emit CategoryIconsRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve category icons with search query', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Search categories by name
|
||||
// Given: Categories exist with various names
|
||||
// When: GetCategoryIconsUseCase.execute() is called with search query
|
||||
// Then: The result should only contain matching categories
|
||||
// And: EventPublisher should emit CategoryIconsRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetCategoryIconsUseCase - Edge Cases', () => {
|
||||
it('should handle empty category list', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: No categories exist
|
||||
// Given: No categories exist in the system
|
||||
// When: GetCategoryIconsUseCase.execute() is called
|
||||
// Then: The result should be an empty list
|
||||
// And: EventPublisher should emit CategoryIconsRetrievedEvent
|
||||
});
|
||||
|
||||
it('should handle categories without icons', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Categories exist without icons
|
||||
// Given: Categories exist without icons
|
||||
// When: GetCategoryIconsUseCase.execute() is called
|
||||
// Then: The result should show categories with default icons
|
||||
// And: EventPublisher should emit CategoryIconsRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadCategoryIconUseCase - Success Path', () => {
|
||||
it('should upload a new category icon', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads new category icon
|
||||
// Given: A category exists without an icon
|
||||
// And: Valid icon image data is provided
|
||||
// When: UploadCategoryIconUseCase.execute() is called with category ID and image data
|
||||
// Then: The icon should be stored in the repository
|
||||
// And: The icon should have correct metadata (file size, format, upload date)
|
||||
// And: EventPublisher should emit CategoryIconUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload category icon with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads icon with validation
|
||||
// Given: A category exists
|
||||
// And: Icon data meets validation requirements (correct format, size, dimensions)
|
||||
// When: UploadCategoryIconUseCase.execute() is called
|
||||
// Then: The icon should be stored successfully
|
||||
// And: EventPublisher should emit CategoryIconUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload icon for new category creation', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin creates category with icon
|
||||
// Given: No category exists
|
||||
// When: UploadCategoryIconUseCase.execute() is called with new category details and icon
|
||||
// Then: The category should be created
|
||||
// And: The icon should be stored
|
||||
// And: EventPublisher should emit CategoryCreatedEvent and CategoryIconUploadedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadCategoryIconUseCase - Validation', () => {
|
||||
it('should reject upload with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A category exists
|
||||
// And: Icon data has invalid format (e.g., .txt, .exe)
|
||||
// When: UploadCategoryIconUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A category exists
|
||||
// And: Icon data exceeds maximum file size
|
||||
// When: UploadCategoryIconUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with invalid dimensions', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid image dimensions
|
||||
// Given: A category exists
|
||||
// And: Icon data has invalid dimensions (too small or too large)
|
||||
// When: UploadCategoryIconUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateCategoryIconUseCase - Success Path', () => {
|
||||
it('should update existing category icon', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates category icon
|
||||
// Given: A category exists with an existing icon
|
||||
// And: Valid new icon image data is provided
|
||||
// When: UpdateCategoryIconUseCase.execute() is called with category ID and new image data
|
||||
// Then: The old icon should be replaced with the new one
|
||||
// And: The new icon should have updated metadata
|
||||
// And: EventPublisher should emit CategoryIconUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update icon with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates icon with validation
|
||||
// Given: A category exists with an existing icon
|
||||
// And: New icon data meets validation requirements
|
||||
// When: UpdateCategoryIconUseCase.execute() is called
|
||||
// Then: The icon should be updated successfully
|
||||
// And: EventPublisher should emit CategoryIconUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update icon for category with multiple icons', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Category with multiple icons
|
||||
// Given: A category exists with multiple icons
|
||||
// When: UpdateCategoryIconUseCase.execute() is called
|
||||
// Then: Only the specified icon should be updated
|
||||
// And: Other icons should remain unchanged
|
||||
// And: EventPublisher should emit CategoryIconUpdatedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateCategoryIconUseCase - Validation', () => {
|
||||
it('should reject update with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A category exists with an existing icon
|
||||
// And: New icon data has invalid format
|
||||
// When: UpdateCategoryIconUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject update with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A category exists with an existing icon
|
||||
// And: New icon data exceeds maximum file size
|
||||
// When: UpdateCategoryIconUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteCategoryIconUseCase - Success Path', () => {
|
||||
it('should delete category icon', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin deletes category icon
|
||||
// Given: A category exists with an existing icon
|
||||
// When: DeleteCategoryIconUseCase.execute() is called with category ID
|
||||
// Then: The icon should be removed from the repository
|
||||
// And: The category should show a default icon
|
||||
// And: EventPublisher should emit CategoryIconDeletedEvent
|
||||
});
|
||||
|
||||
it('should delete specific icon when category has multiple icons', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Category with multiple icons
|
||||
// Given: A category exists with multiple icons
|
||||
// When: DeleteCategoryIconUseCase.execute() is called with specific icon ID
|
||||
// Then: Only that icon should be removed
|
||||
// And: Other icons should remain
|
||||
// And: EventPublisher should emit CategoryIconDeletedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteCategoryIconUseCase - Error Handling', () => {
|
||||
it('should handle deletion when category has no icon', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Category without icon
|
||||
// Given: A category exists without an icon
|
||||
// When: DeleteCategoryIconUseCase.execute() is called with category ID
|
||||
// Then: Should complete successfully (no-op)
|
||||
// And: EventPublisher should emit CategoryIconDeletedEvent
|
||||
});
|
||||
|
||||
it('should throw error when category does not exist', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Non-existent category
|
||||
// Given: No category exists with the given ID
|
||||
// When: DeleteCategoryIconUseCase.execute() is called with non-existent category ID
|
||||
// Then: Should throw CategoryNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('Category Icon Data Orchestration', () => {
|
||||
it('should correctly format category icon metadata', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Category icon metadata formatting
|
||||
// Given: A category exists with an icon
|
||||
// When: GetCategoryIconsUseCase.execute() is called
|
||||
// Then: Icon metadata should show:
|
||||
// - File size: Correctly formatted (e.g., "1.2 MB")
|
||||
// - File format: Correct format (e.g., "PNG", "SVG")
|
||||
// - Upload date: Correctly formatted date
|
||||
});
|
||||
|
||||
it('should correctly handle category icon caching', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Category icon caching
|
||||
// Given: Categories exist with icons
|
||||
// When: GetCategoryIconsUseCase.execute() is called multiple times
|
||||
// Then: Subsequent calls should return cached data
|
||||
// And: EventPublisher should emit CategoryIconsRetrievedEvent for each call
|
||||
});
|
||||
|
||||
it('should correctly handle category icon error states', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Category icon error handling
|
||||
// Given: Categories exist
|
||||
// And: CategoryIconRepository throws an error during retrieval
|
||||
// When: GetCategoryIconsUseCase.execute() is called
|
||||
// Then: Should propagate the error appropriately
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should correctly handle bulk category icon operations', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Bulk category icon operations
|
||||
// Given: Multiple categories exist
|
||||
// When: Bulk upload or export operations are performed
|
||||
// Then: All operations should complete successfully
|
||||
// And: EventPublisher should emit appropriate events for each operation
|
||||
});
|
||||
});
|
||||
});
|
||||
140
tests/integration/media/general/media-management.test.ts
Normal file
140
tests/integration/media/general/media-management.test.ts
Normal file
@@ -0,0 +1,140 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { MediaTestContext } from '../MediaTestContext';
|
||||
import { Media } from '@core/media/domain/entities/Media';
|
||||
import type { MulterFile } from '@core/media/application/use-cases/UploadMediaUseCase';
|
||||
|
||||
describe('General Media Management: Upload, Retrieval, and Deletion', () => {
|
||||
let ctx: MediaTestContext;
|
||||
|
||||
beforeEach(() => {
|
||||
ctx = MediaTestContext.create();
|
||||
ctx.reset();
|
||||
});
|
||||
|
||||
const createMockFile = (filename: string, mimeType: string, content: Buffer): MulterFile => ({
|
||||
fieldname: 'file',
|
||||
originalname: filename,
|
||||
encoding: '7bit',
|
||||
mimetype: mimeType,
|
||||
size: content.length,
|
||||
buffer: content,
|
||||
stream: null as any,
|
||||
destination: '',
|
||||
filename: filename,
|
||||
path: '',
|
||||
});
|
||||
|
||||
describe('UploadMediaUseCase', () => {
|
||||
it('should upload media successfully', async () => {
|
||||
const content = Buffer.from('test content');
|
||||
const file = createMockFile('test.png', 'image/png', content);
|
||||
|
||||
const result = await ctx.uploadMediaUseCase.execute({
|
||||
file,
|
||||
uploadedBy: 'user-1',
|
||||
});
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.mediaId).toBeDefined();
|
||||
expect(successResult.url).toBeDefined();
|
||||
|
||||
const media = await ctx.mediaRepository.findById(successResult.mediaId);
|
||||
expect(media).not.toBeNull();
|
||||
expect(media?.filename).toBe('test.png');
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetMediaUseCase', () => {
|
||||
it('should retrieve media by ID', async () => {
|
||||
const media = Media.create({
|
||||
id: 'media-1',
|
||||
filename: 'test.png',
|
||||
originalName: 'test.png',
|
||||
mimeType: 'image/png',
|
||||
size: 100,
|
||||
url: 'https://example.com/test.png',
|
||||
type: 'image',
|
||||
uploadedBy: 'user-1',
|
||||
});
|
||||
await ctx.mediaRepository.save(media);
|
||||
|
||||
const result = await ctx.getMediaUseCase.execute({ mediaId: 'media-1' });
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult.media.id).toBe('media-1');
|
||||
});
|
||||
|
||||
it('should return MEDIA_NOT_FOUND when media does not exist', async () => {
|
||||
const result = await ctx.getMediaUseCase.execute({ mediaId: 'non-existent' });
|
||||
|
||||
expect(result.isErr()).toBe(true);
|
||||
expect(result.unwrapErr().code).toBe('MEDIA_NOT_FOUND');
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetUploadedMediaUseCase', () => {
|
||||
it('should retrieve uploaded media content', async () => {
|
||||
const uploadResult = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('test content'),
|
||||
{ filename: 'test.png', mimeType: 'image/png' }
|
||||
);
|
||||
const storageKey = uploadResult.url!;
|
||||
|
||||
const result = await ctx.getUploadedMediaUseCase.execute({ storageKey });
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
const successResult = result.unwrap();
|
||||
expect(successResult?.bytes.toString()).toBe('test content');
|
||||
expect(successResult?.contentType).toBe('image/png');
|
||||
});
|
||||
|
||||
it('should return null when media does not exist in storage', async () => {
|
||||
const result = await ctx.getUploadedMediaUseCase.execute({ storageKey: 'non-existent' });
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
expect(result.unwrap()).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteMediaUseCase', () => {
|
||||
it('should delete media file and repository entry', async () => {
|
||||
const uploadResult = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('test content'),
|
||||
{ filename: 'test.png', mimeType: 'image/png' }
|
||||
);
|
||||
const storageKey = uploadResult.url!;
|
||||
|
||||
const media = Media.create({
|
||||
id: 'media-1',
|
||||
filename: 'test.png',
|
||||
originalName: 'test.png',
|
||||
mimeType: 'image/png',
|
||||
size: 12,
|
||||
url: storageKey,
|
||||
type: 'image',
|
||||
uploadedBy: 'user-1',
|
||||
});
|
||||
await ctx.mediaRepository.save(media);
|
||||
|
||||
const result = await ctx.deleteMediaUseCase.execute({ mediaId: 'media-1' });
|
||||
|
||||
expect(result.isOk()).toBe(true);
|
||||
expect(result.unwrap().deleted).toBe(true);
|
||||
|
||||
const deletedMedia = await ctx.mediaRepository.findById('media-1');
|
||||
expect(deletedMedia).toBeNull();
|
||||
|
||||
const storageExists = ctx.mediaStorage.has(storageKey);
|
||||
expect(storageExists).toBe(false);
|
||||
});
|
||||
|
||||
it('should return MEDIA_NOT_FOUND when media does not exist', async () => {
|
||||
const result = await ctx.deleteMediaUseCase.execute({ mediaId: 'non-existent' });
|
||||
|
||||
expect(result.isErr()).toBe(true);
|
||||
expect(result.unwrapErr().code).toBe('MEDIA_NOT_FOUND');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,530 +0,0 @@
|
||||
/**
|
||||
* Integration Test: League Media Management Use Case Orchestration
|
||||
*
|
||||
* Tests the orchestration logic of league media-related Use Cases:
|
||||
* - GetLeagueMediaUseCase: Retrieves league covers and logos
|
||||
* - UploadLeagueCoverUseCase: Uploads a new league cover
|
||||
* - UploadLeagueLogoUseCase: Uploads a new league logo
|
||||
* - UpdateLeagueCoverUseCase: Updates an existing league cover
|
||||
* - UpdateLeagueLogoUseCase: Updates an existing league logo
|
||||
* - DeleteLeagueCoverUseCase: Deletes a league cover
|
||||
* - DeleteLeagueLogoUseCase: Deletes a league logo
|
||||
* - SetLeagueMediaFeaturedUseCase: Sets league media as featured
|
||||
* - 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';
|
||||
|
||||
describe('League Media Management Use Case Orchestration', () => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// let leagueMediaRepository: InMemoryLeagueMediaRepository;
|
||||
// let leagueRepository: InMemoryLeagueRepository;
|
||||
// let eventPublisher: InMemoryEventPublisher;
|
||||
// let getLeagueMediaUseCase: GetLeagueMediaUseCase;
|
||||
// let uploadLeagueCoverUseCase: UploadLeagueCoverUseCase;
|
||||
// let uploadLeagueLogoUseCase: UploadLeagueLogoUseCase;
|
||||
// let updateLeagueCoverUseCase: UpdateLeagueCoverUseCase;
|
||||
// let updateLeagueLogoUseCase: UpdateLeagueLogoUseCase;
|
||||
// let deleteLeagueCoverUseCase: DeleteLeagueCoverUseCase;
|
||||
// let deleteLeagueLogoUseCase: DeleteLeagueLogoUseCase;
|
||||
// let setLeagueMediaFeaturedUseCase: SetLeagueMediaFeaturedUseCase;
|
||||
|
||||
beforeAll(() => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// leagueMediaRepository = new InMemoryLeagueMediaRepository();
|
||||
// leagueRepository = new InMemoryLeagueRepository();
|
||||
// eventPublisher = new InMemoryEventPublisher();
|
||||
// getLeagueMediaUseCase = new GetLeagueMediaUseCase({
|
||||
// leagueMediaRepository,
|
||||
// leagueRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// uploadLeagueCoverUseCase = new UploadLeagueCoverUseCase({
|
||||
// leagueMediaRepository,
|
||||
// leagueRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// uploadLeagueLogoUseCase = new UploadLeagueLogoUseCase({
|
||||
// leagueMediaRepository,
|
||||
// leagueRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// updateLeagueCoverUseCase = new UpdateLeagueCoverUseCase({
|
||||
// leagueMediaRepository,
|
||||
// leagueRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// updateLeagueLogoUseCase = new UpdateLeagueLogoUseCase({
|
||||
// leagueMediaRepository,
|
||||
// leagueRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// deleteLeagueCoverUseCase = new DeleteLeagueCoverUseCase({
|
||||
// leagueMediaRepository,
|
||||
// leagueRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// deleteLeagueLogoUseCase = new DeleteLeagueLogoUseCase({
|
||||
// leagueMediaRepository,
|
||||
// leagueRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// setLeagueMediaFeaturedUseCase = new SetLeagueMediaFeaturedUseCase({
|
||||
// leagueMediaRepository,
|
||||
// leagueRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
// TODO: Clear all In-Memory repositories before each test
|
||||
// leagueMediaRepository.clear();
|
||||
// leagueRepository.clear();
|
||||
// eventPublisher.clear();
|
||||
});
|
||||
|
||||
describe('GetLeagueMediaUseCase - Success Path', () => {
|
||||
it('should retrieve league cover and logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League with cover and logo
|
||||
// Given: A league exists with a cover and logo
|
||||
// When: GetLeagueMediaUseCase.execute() is called with league ID
|
||||
// Then: The result should contain both cover and logo
|
||||
// And: Each media should have correct metadata
|
||||
// And: EventPublisher should emit LeagueMediaRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve league with only cover', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League with only cover
|
||||
// Given: A league exists with only a cover
|
||||
// When: GetLeagueMediaUseCase.execute() is called with league ID
|
||||
// Then: The result should contain the cover
|
||||
// And: Logo should be null or default
|
||||
// And: EventPublisher should emit LeagueMediaRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve league with only logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League with only logo
|
||||
// Given: A league exists with only a logo
|
||||
// When: GetLeagueMediaUseCase.execute() is called with league ID
|
||||
// Then: The result should contain the logo
|
||||
// And: Cover should be null or default
|
||||
// And: EventPublisher should emit LeagueMediaRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve league with multiple covers', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League with multiple covers
|
||||
// Given: A league exists with multiple covers
|
||||
// When: GetLeagueMediaUseCase.execute() is called with league ID
|
||||
// Then: The result should contain all covers
|
||||
// And: Each cover should have correct metadata
|
||||
// And: EventPublisher should emit LeagueMediaRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetLeagueMediaUseCase - 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: GetLeagueMediaUseCase.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: GetLeagueMediaUseCase.execute() is called with invalid league ID
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadLeagueCoverUseCase - Success Path', () => {
|
||||
it('should upload a new league cover', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads new league cover
|
||||
// Given: A league exists without a cover
|
||||
// And: Valid cover image data is provided
|
||||
// When: UploadLeagueCoverUseCase.execute() is called with league ID and image data
|
||||
// Then: The cover should be stored in the repository
|
||||
// And: The cover should have correct metadata (file size, format, upload date)
|
||||
// And: EventPublisher should emit LeagueCoverUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload cover with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads cover with validation
|
||||
// Given: A league exists
|
||||
// And: Cover data meets validation requirements (correct format, size, dimensions)
|
||||
// When: UploadLeagueCoverUseCase.execute() is called
|
||||
// Then: The cover should be stored successfully
|
||||
// And: EventPublisher should emit LeagueCoverUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload cover for new league creation', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin creates league with cover
|
||||
// Given: No league exists
|
||||
// When: UploadLeagueCoverUseCase.execute() is called with new league details and cover
|
||||
// Then: The league should be created
|
||||
// And: The cover should be stored
|
||||
// And: EventPublisher should emit LeagueCreatedEvent and LeagueCoverUploadedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadLeagueCoverUseCase - Validation', () => {
|
||||
it('should reject upload with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A league exists
|
||||
// And: Cover data has invalid format (e.g., .txt, .exe)
|
||||
// When: UploadLeagueCoverUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A league exists
|
||||
// And: Cover data exceeds maximum file size
|
||||
// When: UploadLeagueCoverUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with invalid dimensions', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid image dimensions
|
||||
// Given: A league exists
|
||||
// And: Cover data has invalid dimensions (too small or too large)
|
||||
// When: UploadLeagueCoverUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadLeagueLogoUseCase - Success Path', () => {
|
||||
it('should upload a new league logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads new league logo
|
||||
// Given: A league exists without a logo
|
||||
// And: Valid logo image data is provided
|
||||
// When: UploadLeagueLogoUseCase.execute() is called with league ID and image data
|
||||
// Then: The logo should be stored in the repository
|
||||
// And: The logo should have correct metadata (file size, format, upload date)
|
||||
// And: EventPublisher should emit LeagueLogoUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload logo with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads logo with validation
|
||||
// Given: A league exists
|
||||
// And: Logo data meets validation requirements (correct format, size, dimensions)
|
||||
// When: UploadLeagueLogoUseCase.execute() is called
|
||||
// Then: The logo should be stored successfully
|
||||
// And: EventPublisher should emit LeagueLogoUploadedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadLeagueLogoUseCase - Validation', () => {
|
||||
it('should reject upload with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A league exists
|
||||
// And: Logo data has invalid format
|
||||
// When: UploadLeagueLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A league exists
|
||||
// And: Logo data exceeds maximum file size
|
||||
// When: UploadLeagueLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateLeagueCoverUseCase - Success Path', () => {
|
||||
it('should update existing league cover', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates league cover
|
||||
// Given: A league exists with an existing cover
|
||||
// And: Valid new cover image data is provided
|
||||
// When: UpdateLeagueCoverUseCase.execute() is called with league ID and new image data
|
||||
// Then: The old cover should be replaced with the new one
|
||||
// And: The new cover should have updated metadata
|
||||
// And: EventPublisher should emit LeagueCoverUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update cover with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates cover with validation
|
||||
// Given: A league exists with an existing cover
|
||||
// And: New cover data meets validation requirements
|
||||
// When: UpdateLeagueCoverUseCase.execute() is called
|
||||
// Then: The cover should be updated successfully
|
||||
// And: EventPublisher should emit LeagueCoverUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update cover for league with multiple covers', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League with multiple covers
|
||||
// Given: A league exists with multiple covers
|
||||
// When: UpdateLeagueCoverUseCase.execute() is called
|
||||
// Then: Only the specified cover should be updated
|
||||
// And: Other covers should remain unchanged
|
||||
// And: EventPublisher should emit LeagueCoverUpdatedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateLeagueCoverUseCase - Validation', () => {
|
||||
it('should reject update with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A league exists with an existing cover
|
||||
// And: New cover data has invalid format
|
||||
// When: UpdateLeagueCoverUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject update with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A league exists with an existing cover
|
||||
// And: New cover data exceeds maximum file size
|
||||
// When: UpdateLeagueCoverUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateLeagueLogoUseCase - Success Path', () => {
|
||||
it('should update existing league logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates league logo
|
||||
// Given: A league exists with an existing logo
|
||||
// And: Valid new logo image data is provided
|
||||
// When: UpdateLeagueLogoUseCase.execute() is called with league ID and new image data
|
||||
// Then: The old logo should be replaced with the new one
|
||||
// And: The new logo should have updated metadata
|
||||
// And: EventPublisher should emit LeagueLogoUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update logo with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates logo with validation
|
||||
// Given: A league exists with an existing logo
|
||||
// And: New logo data meets validation requirements
|
||||
// When: UpdateLeagueLogoUseCase.execute() is called
|
||||
// Then: The logo should be updated successfully
|
||||
// And: EventPublisher should emit LeagueLogoUpdatedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateLeagueLogoUseCase - Validation', () => {
|
||||
it('should reject update with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A league exists with an existing logo
|
||||
// And: New logo data has invalid format
|
||||
// When: UpdateLeagueLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject update with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A league exists with an existing logo
|
||||
// And: New logo data exceeds maximum file size
|
||||
// When: UpdateLeagueLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteLeagueCoverUseCase - Success Path', () => {
|
||||
it('should delete league cover', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin deletes league cover
|
||||
// Given: A league exists with an existing cover
|
||||
// When: DeleteLeagueCoverUseCase.execute() is called with league ID
|
||||
// Then: The cover should be removed from the repository
|
||||
// And: The league should show a default cover
|
||||
// And: EventPublisher should emit LeagueCoverDeletedEvent
|
||||
});
|
||||
|
||||
it('should delete specific cover when league has multiple covers', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League with multiple covers
|
||||
// Given: A league exists with multiple covers
|
||||
// When: DeleteLeagueCoverUseCase.execute() is called with specific cover ID
|
||||
// Then: Only that cover should be removed
|
||||
// And: Other covers should remain
|
||||
// And: EventPublisher should emit LeagueCoverDeletedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteLeagueCoverUseCase - Error Handling', () => {
|
||||
it('should handle deletion when league has no cover', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League without cover
|
||||
// Given: A league exists without a cover
|
||||
// When: DeleteLeagueCoverUseCase.execute() is called with league ID
|
||||
// Then: Should complete successfully (no-op)
|
||||
// And: EventPublisher should emit LeagueCoverDeletedEvent
|
||||
});
|
||||
|
||||
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: DeleteLeagueCoverUseCase.execute() is called with non-existent league ID
|
||||
// Then: Should throw LeagueNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteLeagueLogoUseCase - Success Path', () => {
|
||||
it('should delete league logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin deletes league logo
|
||||
// Given: A league exists with an existing logo
|
||||
// When: DeleteLeagueLogoUseCase.execute() is called with league ID
|
||||
// Then: The logo should be removed from the repository
|
||||
// And: The league should show a default logo
|
||||
// And: EventPublisher should emit LeagueLogoDeletedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteLeagueLogoUseCase - Error Handling', () => {
|
||||
it('should handle deletion when league has no logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League without logo
|
||||
// Given: A league exists without a logo
|
||||
// When: DeleteLeagueLogoUseCase.execute() is called with league ID
|
||||
// Then: Should complete successfully (no-op)
|
||||
// And: EventPublisher should emit LeagueLogoDeletedEvent
|
||||
});
|
||||
|
||||
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: DeleteLeagueLogoUseCase.execute() is called with non-existent league ID
|
||||
// Then: Should throw LeagueNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('SetLeagueMediaFeaturedUseCase - Success Path', () => {
|
||||
it('should set league cover as featured', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin sets cover as featured
|
||||
// Given: A league exists with multiple covers
|
||||
// When: SetLeagueMediaFeaturedUseCase.execute() is called with cover ID
|
||||
// Then: The cover should be marked as featured
|
||||
// And: Other covers should not be featured
|
||||
// And: EventPublisher should emit LeagueMediaFeaturedEvent
|
||||
});
|
||||
|
||||
it('should set league logo as featured', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin sets logo as featured
|
||||
// Given: A league exists with multiple logos
|
||||
// When: SetLeagueMediaFeaturedUseCase.execute() is called with logo ID
|
||||
// Then: The logo should be marked as featured
|
||||
// And: Other logos should not be featured
|
||||
// And: EventPublisher should emit LeagueMediaFeaturedEvent
|
||||
});
|
||||
|
||||
it('should update featured media when new one is set', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Update featured media
|
||||
// Given: A league exists with a featured cover
|
||||
// When: SetLeagueMediaFeaturedUseCase.execute() is called with a different cover
|
||||
// Then: The new cover should be featured
|
||||
// And: The old cover should not be featured
|
||||
// And: EventPublisher should emit LeagueMediaFeaturedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('SetLeagueMediaFeaturedUseCase - Error Handling', () => {
|
||||
it('should throw error when media does not exist', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Non-existent media
|
||||
// Given: A league exists
|
||||
// And: No media exists with the given ID
|
||||
// When: SetLeagueMediaFeaturedUseCase.execute() is called with non-existent media ID
|
||||
// Then: Should throw MediaNotFoundError
|
||||
// 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: No league exists with the given ID
|
||||
// When: SetLeagueMediaFeaturedUseCase.execute() is called with non-existent league ID
|
||||
// Then: Should throw LeagueNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('League Media Data Orchestration', () => {
|
||||
it('should correctly format league media metadata', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League media metadata formatting
|
||||
// Given: A league exists with cover and logo
|
||||
// When: GetLeagueMediaUseCase.execute() is called
|
||||
// Then: Media metadata should show:
|
||||
// - File size: Correctly formatted (e.g., "3.2 MB")
|
||||
// - File format: Correct format (e.g., "PNG", "JPEG")
|
||||
// - Upload date: Correctly formatted date
|
||||
// - Featured status: Correctly indicated
|
||||
});
|
||||
|
||||
it('should correctly handle league media caching', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League media caching
|
||||
// Given: A league exists with media
|
||||
// When: GetLeagueMediaUseCase.execute() is called multiple times
|
||||
// Then: Subsequent calls should return cached data
|
||||
// And: EventPublisher should emit LeagueMediaRetrievedEvent for each call
|
||||
});
|
||||
|
||||
it('should correctly handle league media error states', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: League media error handling
|
||||
// Given: A league exists
|
||||
// And: LeagueMediaRepository throws an error during retrieval
|
||||
// When: GetLeagueMediaUseCase.execute() is called
|
||||
// Then: Should propagate the error appropriately
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should correctly handle multiple media files per league', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Multiple media files per league
|
||||
// Given: A league exists with multiple covers and logos
|
||||
// When: GetLeagueMediaUseCase.execute() is called
|
||||
// Then: All media files should be returned
|
||||
// And: Each media file should have correct metadata
|
||||
// And: EventPublisher should emit LeagueMediaRetrievedEvent
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,60 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { MediaTestContext } from '../MediaTestContext';
|
||||
import { InMemoryLeagueRepository } from '@adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
|
||||
import { League } from '@core/racing/domain/entities/League';
|
||||
import { MediaReference } from '@core/domain/media/MediaReference';
|
||||
|
||||
describe('League Media Management', () => {
|
||||
let ctx: MediaTestContext;
|
||||
let leagueRepository: InMemoryLeagueRepository;
|
||||
|
||||
beforeEach(() => {
|
||||
ctx = MediaTestContext.create();
|
||||
ctx.reset();
|
||||
leagueRepository = new InMemoryLeagueRepository(ctx.logger);
|
||||
});
|
||||
|
||||
it('should upload and set a league logo', async () => {
|
||||
// Given: A league exists
|
||||
const league = League.create({
|
||||
id: 'league-1',
|
||||
name: 'Test League',
|
||||
description: 'Test Description',
|
||||
ownerId: 'owner-1',
|
||||
});
|
||||
await leagueRepository.create(league);
|
||||
|
||||
// When: A logo is uploaded
|
||||
const uploadResult = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('logo content'),
|
||||
{ filename: 'logo.png', mimeType: 'image/png' }
|
||||
);
|
||||
expect(uploadResult.success).toBe(true);
|
||||
const mediaId = 'media-1';
|
||||
|
||||
// And: The league is updated with the new logo reference
|
||||
const updatedLeague = league.update({
|
||||
logoRef: MediaReference.createUploaded(mediaId)
|
||||
});
|
||||
await leagueRepository.update(updatedLeague);
|
||||
|
||||
// Then: The league should have the correct logo reference
|
||||
const savedLeague = await leagueRepository.findById('league-1');
|
||||
expect(savedLeague?.logoRef.type).toBe('uploaded');
|
||||
expect(savedLeague?.logoRef.mediaId).toBe(mediaId);
|
||||
});
|
||||
|
||||
it('should retrieve league media (simulated via repository)', async () => {
|
||||
const league = League.create({
|
||||
id: 'league-1',
|
||||
name: 'Test League',
|
||||
description: 'Test Description',
|
||||
ownerId: 'owner-1',
|
||||
});
|
||||
await leagueRepository.create(league);
|
||||
|
||||
const found = await leagueRepository.findById('league-1');
|
||||
expect(found).not.toBeNull();
|
||||
expect(found?.logoRef).toBeDefined();
|
||||
});
|
||||
});
|
||||
@@ -1,380 +0,0 @@
|
||||
/**
|
||||
* Integration Test: Sponsor Logo Management Use Case Orchestration
|
||||
*
|
||||
* Tests the orchestration logic of sponsor logo-related Use Cases:
|
||||
* - GetSponsorLogosUseCase: Retrieves sponsor logos
|
||||
* - UploadSponsorLogoUseCase: Uploads a new sponsor logo
|
||||
* - UpdateSponsorLogoUseCase: Updates an existing sponsor logo
|
||||
* - DeleteSponsorLogoUseCase: Deletes a sponsor logo
|
||||
* - SetSponsorFeaturedUseCase: Sets sponsor as featured
|
||||
* - 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';
|
||||
|
||||
describe('Sponsor Logo Management Use Case Orchestration', () => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// let sponsorLogoRepository: InMemorySponsorLogoRepository;
|
||||
// let sponsorRepository: InMemorySponsorRepository;
|
||||
// let eventPublisher: InMemoryEventPublisher;
|
||||
// let getSponsorLogosUseCase: GetSponsorLogosUseCase;
|
||||
// let uploadSponsorLogoUseCase: UploadSponsorLogoUseCase;
|
||||
// let updateSponsorLogoUseCase: UpdateSponsorLogoUseCase;
|
||||
// let deleteSponsorLogoUseCase: DeleteSponsorLogoUseCase;
|
||||
// let setSponsorFeaturedUseCase: SetSponsorFeaturedUseCase;
|
||||
|
||||
beforeAll(() => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// sponsorLogoRepository = new InMemorySponsorLogoRepository();
|
||||
// sponsorRepository = new InMemorySponsorRepository();
|
||||
// eventPublisher = new InMemoryEventPublisher();
|
||||
// getSponsorLogosUseCase = new GetSponsorLogosUseCase({
|
||||
// sponsorLogoRepository,
|
||||
// sponsorRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// uploadSponsorLogoUseCase = new UploadSponsorLogoUseCase({
|
||||
// sponsorLogoRepository,
|
||||
// sponsorRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// updateSponsorLogoUseCase = new UpdateSponsorLogoUseCase({
|
||||
// sponsorLogoRepository,
|
||||
// sponsorRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// deleteSponsorLogoUseCase = new DeleteSponsorLogoUseCase({
|
||||
// sponsorLogoRepository,
|
||||
// sponsorRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// setSponsorFeaturedUseCase = new SetSponsorFeaturedUseCase({
|
||||
// sponsorLogoRepository,
|
||||
// sponsorRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
// TODO: Clear all In-Memory repositories before each test
|
||||
// sponsorLogoRepository.clear();
|
||||
// sponsorRepository.clear();
|
||||
// eventPublisher.clear();
|
||||
});
|
||||
|
||||
describe('GetSponsorLogosUseCase - Success Path', () => {
|
||||
it('should retrieve all sponsor logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Multiple sponsors with logos
|
||||
// Given: Multiple sponsors exist with logos
|
||||
// When: GetSponsorLogosUseCase.execute() is called
|
||||
// Then: The result should contain all sponsor logos
|
||||
// And: Each logo should have correct metadata
|
||||
// And: EventPublisher should emit SponsorLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve sponsor logos for specific tier', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Filter by sponsor tier
|
||||
// Given: Sponsors exist with different tiers
|
||||
// When: GetSponsorLogosUseCase.execute() is called with tier filter
|
||||
// Then: The result should only contain logos for that tier
|
||||
// And: EventPublisher should emit SponsorLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve sponsor logos with search query', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Search sponsors by name
|
||||
// Given: Sponsors exist with various names
|
||||
// When: GetSponsorLogosUseCase.execute() is called with search query
|
||||
// Then: The result should only contain matching sponsors
|
||||
// And: EventPublisher should emit SponsorLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve featured sponsor logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Filter by featured status
|
||||
// Given: Sponsors exist with featured and non-featured logos
|
||||
// When: GetSponsorLogosUseCase.execute() is called with featured filter
|
||||
// Then: The result should only contain featured logos
|
||||
// And: EventPublisher should emit SponsorLogosRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetSponsorLogosUseCase - Edge Cases', () => {
|
||||
it('should handle empty sponsor list', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: No sponsors exist
|
||||
// Given: No sponsors exist in the system
|
||||
// When: GetSponsorLogosUseCase.execute() is called
|
||||
// Then: The result should be an empty list
|
||||
// And: EventPublisher should emit SponsorLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should handle sponsors without logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Sponsors exist without logos
|
||||
// Given: Sponsors exist without logos
|
||||
// When: GetSponsorLogosUseCase.execute() is called
|
||||
// Then: The result should show sponsors with default logos
|
||||
// And: EventPublisher should emit SponsorLogosRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadSponsorLogoUseCase - Success Path', () => {
|
||||
it('should upload a new sponsor logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads new sponsor logo
|
||||
// Given: A sponsor exists without a logo
|
||||
// And: Valid logo image data is provided
|
||||
// When: UploadSponsorLogoUseCase.execute() is called with sponsor ID and image data
|
||||
// Then: The logo should be stored in the repository
|
||||
// And: The logo should have correct metadata (file size, format, upload date)
|
||||
// And: EventPublisher should emit SponsorLogoUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload logo with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads logo with validation
|
||||
// Given: A sponsor exists
|
||||
// And: Logo data meets validation requirements (correct format, size, dimensions)
|
||||
// When: UploadSponsorLogoUseCase.execute() is called
|
||||
// Then: The logo should be stored successfully
|
||||
// And: EventPublisher should emit SponsorLogoUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload logo for new sponsor creation', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin creates sponsor with logo
|
||||
// Given: No sponsor exists
|
||||
// When: UploadSponsorLogoUseCase.execute() is called with new sponsor details and logo
|
||||
// Then: The sponsor should be created
|
||||
// And: The logo should be stored
|
||||
// And: EventPublisher should emit SponsorCreatedEvent and SponsorLogoUploadedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadSponsorLogoUseCase - Validation', () => {
|
||||
it('should reject upload with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A sponsor exists
|
||||
// And: Logo data has invalid format (e.g., .txt, .exe)
|
||||
// When: UploadSponsorLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A sponsor exists
|
||||
// And: Logo data exceeds maximum file size
|
||||
// When: UploadSponsorLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with invalid dimensions', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid image dimensions
|
||||
// Given: A sponsor exists
|
||||
// And: Logo data has invalid dimensions (too small or too large)
|
||||
// When: UploadSponsorLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateSponsorLogoUseCase - Success Path', () => {
|
||||
it('should update existing sponsor logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates sponsor logo
|
||||
// Given: A sponsor exists with an existing logo
|
||||
// And: Valid new logo image data is provided
|
||||
// When: UpdateSponsorLogoUseCase.execute() is called with sponsor ID and new image data
|
||||
// Then: The old logo should be replaced with the new one
|
||||
// And: The new logo should have updated metadata
|
||||
// And: EventPublisher should emit SponsorLogoUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update logo with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates logo with validation
|
||||
// Given: A sponsor exists with an existing logo
|
||||
// And: New logo data meets validation requirements
|
||||
// When: UpdateSponsorLogoUseCase.execute() is called
|
||||
// Then: The logo should be updated successfully
|
||||
// And: EventPublisher should emit SponsorLogoUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update logo for sponsor with multiple logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Sponsor with multiple logos
|
||||
// Given: A sponsor exists with multiple logos
|
||||
// When: UpdateSponsorLogoUseCase.execute() is called
|
||||
// Then: Only the specified logo should be updated
|
||||
// And: Other logos should remain unchanged
|
||||
// And: EventPublisher should emit SponsorLogoUpdatedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateSponsorLogoUseCase - Validation', () => {
|
||||
it('should reject update with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A sponsor exists with an existing logo
|
||||
// And: New logo data has invalid format
|
||||
// When: UpdateSponsorLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject update with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A sponsor exists with an existing logo
|
||||
// And: New logo data exceeds maximum file size
|
||||
// When: UpdateSponsorLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteSponsorLogoUseCase - Success Path', () => {
|
||||
it('should delete sponsor logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin deletes sponsor logo
|
||||
// Given: A sponsor exists with an existing logo
|
||||
// When: DeleteSponsorLogoUseCase.execute() is called with sponsor ID
|
||||
// Then: The logo should be removed from the repository
|
||||
// And: The sponsor should show a default logo
|
||||
// And: EventPublisher should emit SponsorLogoDeletedEvent
|
||||
});
|
||||
|
||||
it('should delete specific logo when sponsor has multiple logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Sponsor with multiple logos
|
||||
// Given: A sponsor exists with multiple logos
|
||||
// When: DeleteSponsorLogoUseCase.execute() is called with specific logo ID
|
||||
// Then: Only that logo should be removed
|
||||
// And: Other logos should remain
|
||||
// And: EventPublisher should emit SponsorLogoDeletedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteSponsorLogoUseCase - Error Handling', () => {
|
||||
it('should handle deletion when sponsor has no logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Sponsor without logo
|
||||
// Given: A sponsor exists without a logo
|
||||
// When: DeleteSponsorLogoUseCase.execute() is called with sponsor ID
|
||||
// Then: Should complete successfully (no-op)
|
||||
// And: EventPublisher should emit SponsorLogoDeletedEvent
|
||||
});
|
||||
|
||||
it('should throw error when sponsor does not exist', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Non-existent sponsor
|
||||
// Given: No sponsor exists with the given ID
|
||||
// When: DeleteSponsorLogoUseCase.execute() is called with non-existent sponsor ID
|
||||
// Then: Should throw SponsorNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('SetSponsorFeaturedUseCase - Success Path', () => {
|
||||
it('should set sponsor as featured', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin sets sponsor as featured
|
||||
// Given: A sponsor exists
|
||||
// When: SetSponsorFeaturedUseCase.execute() is called with sponsor ID
|
||||
// Then: The sponsor should be marked as featured
|
||||
// And: EventPublisher should emit SponsorFeaturedEvent
|
||||
});
|
||||
|
||||
it('should update featured sponsor when new one is set', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Update featured sponsor
|
||||
// Given: A sponsor exists as featured
|
||||
// When: SetSponsorFeaturedUseCase.execute() is called with a different sponsor
|
||||
// Then: The new sponsor should be featured
|
||||
// And: The old sponsor should not be featured
|
||||
// And: EventPublisher should emit SponsorFeaturedEvent
|
||||
});
|
||||
|
||||
it('should set sponsor as featured with specific tier', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Set sponsor as featured by tier
|
||||
// Given: Sponsors exist with different tiers
|
||||
// When: SetSponsorFeaturedUseCase.execute() is called with tier filter
|
||||
// Then: The sponsor from that tier should be featured
|
||||
// And: EventPublisher should emit SponsorFeaturedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('SetSponsorFeaturedUseCase - Error Handling', () => {
|
||||
it('should throw error when sponsor does not exist', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Non-existent sponsor
|
||||
// Given: No sponsor exists with the given ID
|
||||
// When: SetSponsorFeaturedUseCase.execute() is called with non-existent sponsor ID
|
||||
// Then: Should throw SponsorNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('Sponsor Logo Data Orchestration', () => {
|
||||
it('should correctly format sponsor logo metadata', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Sponsor logo metadata formatting
|
||||
// Given: A sponsor exists with a logo
|
||||
// When: GetSponsorLogosUseCase.execute() is called
|
||||
// Then: Logo metadata should show:
|
||||
// - File size: Correctly formatted (e.g., "1.5 MB")
|
||||
// - File format: Correct format (e.g., "PNG", "SVG")
|
||||
// - Upload date: Correctly formatted date
|
||||
// - Featured status: Correctly indicated
|
||||
});
|
||||
|
||||
it('should correctly handle sponsor logo caching', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Sponsor logo caching
|
||||
// Given: Sponsors exist with logos
|
||||
// When: GetSponsorLogosUseCase.execute() is called multiple times
|
||||
// Then: Subsequent calls should return cached data
|
||||
// And: EventPublisher should emit SponsorLogosRetrievedEvent for each call
|
||||
});
|
||||
|
||||
it('should correctly handle sponsor logo error states', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Sponsor logo error handling
|
||||
// Given: Sponsors exist
|
||||
// And: SponsorLogoRepository throws an error during retrieval
|
||||
// When: GetSponsorLogosUseCase.execute() is called
|
||||
// Then: Should propagate the error appropriately
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should correctly handle sponsor tier filtering', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Sponsor tier filtering
|
||||
// Given: Sponsors exist with different tiers (Gold, Silver, Bronze)
|
||||
// When: GetSponsorLogosUseCase.execute() is called with tier filter
|
||||
// Then: Only sponsors from the specified tier should be returned
|
||||
// And: EventPublisher should emit SponsorLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should correctly handle bulk sponsor logo operations', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Bulk sponsor logo operations
|
||||
// Given: Multiple sponsors exist
|
||||
// When: Bulk upload or export operations are performed
|
||||
// Then: All operations should complete successfully
|
||||
// And: EventPublisher should emit appropriate events for each operation
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,57 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { MediaTestContext } from '../MediaTestContext';
|
||||
import { InMemorySponsorRepository } from '@adapters/racing/persistence/inmemory/InMemorySponsorRepository';
|
||||
import { Sponsor } from '@core/racing/domain/entities/sponsor/Sponsor';
|
||||
|
||||
describe('Sponsor Logo Management', () => {
|
||||
let ctx: MediaTestContext;
|
||||
let sponsorRepository: InMemorySponsorRepository;
|
||||
|
||||
beforeEach(() => {
|
||||
ctx = MediaTestContext.create();
|
||||
ctx.reset();
|
||||
sponsorRepository = new InMemorySponsorRepository(ctx.logger);
|
||||
});
|
||||
|
||||
it('should upload and set a sponsor logo', async () => {
|
||||
// Given: A sponsor exists
|
||||
const sponsor = Sponsor.create({
|
||||
id: 'sponsor-1',
|
||||
name: 'Test Sponsor',
|
||||
contactEmail: 'test@example.com',
|
||||
});
|
||||
await sponsorRepository.create(sponsor);
|
||||
|
||||
// When: A logo is uploaded
|
||||
const uploadResult = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('logo content'),
|
||||
{ filename: 'logo.png', mimeType: 'image/png' }
|
||||
);
|
||||
expect(uploadResult.success).toBe(true);
|
||||
const logoUrl = `https://example.com${uploadResult.url!}`;
|
||||
|
||||
// And: The sponsor is updated with the new logo URL
|
||||
const updatedSponsor = sponsor.update({
|
||||
logoUrl: logoUrl
|
||||
});
|
||||
await sponsorRepository.update(updatedSponsor);
|
||||
|
||||
// Then: The sponsor should have the correct logo URL
|
||||
const savedSponsor = await sponsorRepository.findById('sponsor-1');
|
||||
expect(savedSponsor?.logoUrl?.value).toBe(logoUrl);
|
||||
});
|
||||
|
||||
it('should retrieve sponsor logos (simulated via repository)', async () => {
|
||||
const sponsor = Sponsor.create({
|
||||
id: 'sponsor-1',
|
||||
name: 'Test Sponsor',
|
||||
contactEmail: 'test@example.com',
|
||||
logoUrl: 'https://example.com/logo.png'
|
||||
});
|
||||
await sponsorRepository.create(sponsor);
|
||||
|
||||
const found = await sponsorRepository.findById('sponsor-1');
|
||||
expect(found).not.toBeNull();
|
||||
expect(found?.logoUrl?.value).toBe('https://example.com/logo.png');
|
||||
});
|
||||
});
|
||||
@@ -1,390 +0,0 @@
|
||||
/**
|
||||
* Integration Test: Team Logo Management Use Case Orchestration
|
||||
*
|
||||
* Tests the orchestration logic of team logo-related Use Cases:
|
||||
* - GetTeamLogosUseCase: Retrieves team logos
|
||||
* - UploadTeamLogoUseCase: Uploads a new team logo
|
||||
* - UpdateTeamLogoUseCase: Updates an existing team logo
|
||||
* - DeleteTeamLogoUseCase: Deletes a team logo
|
||||
* - SetTeamFeaturedUseCase: Sets team as featured
|
||||
* - 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';
|
||||
|
||||
describe('Team Logo Management Use Case Orchestration', () => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// let teamLogoRepository: InMemoryTeamLogoRepository;
|
||||
// let teamRepository: InMemoryTeamRepository;
|
||||
// let eventPublisher: InMemoryEventPublisher;
|
||||
// let getTeamLogosUseCase: GetTeamLogosUseCase;
|
||||
// let uploadTeamLogoUseCase: UploadTeamLogoUseCase;
|
||||
// let updateTeamLogoUseCase: UpdateTeamLogoUseCase;
|
||||
// let deleteTeamLogoUseCase: DeleteTeamLogoUseCase;
|
||||
// let setTeamFeaturedUseCase: SetTeamFeaturedUseCase;
|
||||
|
||||
beforeAll(() => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// teamLogoRepository = new InMemoryTeamLogoRepository();
|
||||
// teamRepository = new InMemoryTeamRepository();
|
||||
// eventPublisher = new InMemoryEventPublisher();
|
||||
// getTeamLogosUseCase = new GetTeamLogosUseCase({
|
||||
// teamLogoRepository,
|
||||
// teamRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// uploadTeamLogoUseCase = new UploadTeamLogoUseCase({
|
||||
// teamLogoRepository,
|
||||
// teamRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// updateTeamLogoUseCase = new UpdateTeamLogoUseCase({
|
||||
// teamLogoRepository,
|
||||
// teamRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// deleteTeamLogoUseCase = new DeleteTeamLogoUseCase({
|
||||
// teamLogoRepository,
|
||||
// teamRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// setTeamFeaturedUseCase = new SetTeamFeaturedUseCase({
|
||||
// teamLogoRepository,
|
||||
// teamRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
// TODO: Clear all In-Memory repositories before each test
|
||||
// teamLogoRepository.clear();
|
||||
// teamRepository.clear();
|
||||
// eventPublisher.clear();
|
||||
});
|
||||
|
||||
describe('GetTeamLogosUseCase - Success Path', () => {
|
||||
it('should retrieve all team logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Multiple teams with logos
|
||||
// Given: Multiple teams exist with logos
|
||||
// When: GetTeamLogosUseCase.execute() is called
|
||||
// Then: The result should contain all team logos
|
||||
// And: Each logo should have correct metadata
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve team logos for specific league', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Filter by league
|
||||
// Given: Teams exist in different leagues
|
||||
// When: GetTeamLogosUseCase.execute() is called with league filter
|
||||
// Then: The result should only contain logos for that league
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve team logos with search query', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Search teams by name
|
||||
// Given: Teams exist with various names
|
||||
// When: GetTeamLogosUseCase.execute() is called with search query
|
||||
// Then: The result should only contain matching teams
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve featured team logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Filter by featured status
|
||||
// Given: Teams exist with featured and non-featured logos
|
||||
// When: GetTeamLogosUseCase.execute() is called with featured filter
|
||||
// Then: The result should only contain featured logos
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetTeamLogosUseCase - Edge Cases', () => {
|
||||
it('should handle empty team list', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: No teams exist
|
||||
// Given: No teams exist in the system
|
||||
// When: GetTeamLogosUseCase.execute() is called
|
||||
// Then: The result should be an empty list
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should handle teams without logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Teams exist without logos
|
||||
// Given: Teams exist without logos
|
||||
// When: GetTeamLogosUseCase.execute() is called
|
||||
// Then: The result should show teams with default logos
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadTeamLogoUseCase - Success Path', () => {
|
||||
it('should upload a new team logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads new team logo
|
||||
// Given: A team exists without a logo
|
||||
// And: Valid logo image data is provided
|
||||
// When: UploadTeamLogoUseCase.execute() is called with team ID and image data
|
||||
// Then: The logo should be stored in the repository
|
||||
// And: The logo should have correct metadata (file size, format, upload date)
|
||||
// And: EventPublisher should emit TeamLogoUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload logo with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads logo with validation
|
||||
// Given: A team exists
|
||||
// And: Logo data meets validation requirements (correct format, size, dimensions)
|
||||
// When: UploadTeamLogoUseCase.execute() is called
|
||||
// Then: The logo should be stored successfully
|
||||
// And: EventPublisher should emit TeamLogoUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload logo for new team creation', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin creates team with logo
|
||||
// Given: No team exists
|
||||
// When: UploadTeamLogoUseCase.execute() is called with new team details and logo
|
||||
// Then: The team should be created
|
||||
// And: The logo should be stored
|
||||
// And: EventPublisher should emit TeamCreatedEvent and TeamLogoUploadedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadTeamLogoUseCase - Validation', () => {
|
||||
it('should reject upload with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A team exists
|
||||
// And: Logo data has invalid format (e.g., .txt, .exe)
|
||||
// When: UploadTeamLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A team exists
|
||||
// And: Logo data exceeds maximum file size
|
||||
// When: UploadTeamLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with invalid dimensions', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid image dimensions
|
||||
// Given: A team exists
|
||||
// And: Logo data has invalid dimensions (too small or too large)
|
||||
// When: UploadTeamLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateTeamLogoUseCase - Success Path', () => {
|
||||
it('should update existing team logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates team logo
|
||||
// Given: A team exists with an existing logo
|
||||
// And: Valid new logo image data is provided
|
||||
// When: UpdateTeamLogoUseCase.execute() is called with team ID and new image data
|
||||
// Then: The old logo should be replaced with the new one
|
||||
// And: The new logo should have updated metadata
|
||||
// And: EventPublisher should emit TeamLogoUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update logo with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates logo with validation
|
||||
// Given: A team exists with an existing logo
|
||||
// And: New logo data meets validation requirements
|
||||
// When: UpdateTeamLogoUseCase.execute() is called
|
||||
// Then: The logo should be updated successfully
|
||||
// And: EventPublisher should emit TeamLogoUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update logo for team with multiple logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Team with multiple logos
|
||||
// Given: A team exists with multiple logos
|
||||
// When: UpdateTeamLogoUseCase.execute() is called
|
||||
// Then: Only the specified logo should be updated
|
||||
// And: Other logos should remain unchanged
|
||||
// And: EventPublisher should emit TeamLogoUpdatedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateTeamLogoUseCase - Validation', () => {
|
||||
it('should reject update with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A team exists with an existing logo
|
||||
// And: New logo data has invalid format
|
||||
// When: UpdateTeamLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject update with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A team exists with an existing logo
|
||||
// And: New logo data exceeds maximum file size
|
||||
// When: UpdateTeamLogoUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteTeamLogoUseCase - Success Path', () => {
|
||||
it('should delete team logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin deletes team logo
|
||||
// Given: A team exists with an existing logo
|
||||
// When: DeleteTeamLogoUseCase.execute() is called with team ID
|
||||
// Then: The logo should be removed from the repository
|
||||
// And: The team should show a default logo
|
||||
// And: EventPublisher should emit TeamLogoDeletedEvent
|
||||
});
|
||||
|
||||
it('should delete specific logo when team has multiple logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Team with multiple logos
|
||||
// Given: A team exists with multiple logos
|
||||
// When: DeleteTeamLogoUseCase.execute() is called with specific logo ID
|
||||
// Then: Only that logo should be removed
|
||||
// And: Other logos should remain
|
||||
// And: EventPublisher should emit TeamLogoDeletedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteTeamLogoUseCase - Error Handling', () => {
|
||||
it('should handle deletion when team has no logo', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Team without logo
|
||||
// Given: A team exists without a logo
|
||||
// When: DeleteTeamLogoUseCase.execute() is called with team ID
|
||||
// Then: Should complete successfully (no-op)
|
||||
// And: EventPublisher should emit TeamLogoDeletedEvent
|
||||
});
|
||||
|
||||
it('should throw error when team does not exist', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Non-existent team
|
||||
// Given: No team exists with the given ID
|
||||
// When: DeleteTeamLogoUseCase.execute() is called with non-existent team ID
|
||||
// Then: Should throw TeamNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('SetTeamFeaturedUseCase - Success Path', () => {
|
||||
it('should set team as featured', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin sets team as featured
|
||||
// Given: A team exists
|
||||
// When: SetTeamFeaturedUseCase.execute() is called with team ID
|
||||
// Then: The team should be marked as featured
|
||||
// And: EventPublisher should emit TeamFeaturedEvent
|
||||
});
|
||||
|
||||
it('should update featured team when new one is set', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Update featured team
|
||||
// Given: A team exists as featured
|
||||
// When: SetTeamFeaturedUseCase.execute() is called with a different team
|
||||
// Then: The new team should be featured
|
||||
// And: The old team should not be featured
|
||||
// And: EventPublisher should emit TeamFeaturedEvent
|
||||
});
|
||||
|
||||
it('should set team as featured with specific league', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Set team as featured by league
|
||||
// Given: Teams exist in different leagues
|
||||
// When: SetTeamFeaturedUseCase.execute() is called with league filter
|
||||
// Then: The team from that league should be featured
|
||||
// And: EventPublisher should emit TeamFeaturedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('SetTeamFeaturedUseCase - Error Handling', () => {
|
||||
it('should throw error when team does not exist', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Non-existent team
|
||||
// Given: No team exists with the given ID
|
||||
// When: SetTeamFeaturedUseCase.execute() is called with non-existent team ID
|
||||
// Then: Should throw TeamNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('Team Logo Data Orchestration', () => {
|
||||
it('should correctly format team logo metadata', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Team logo metadata formatting
|
||||
// Given: A team exists with a logo
|
||||
// When: GetTeamLogosUseCase.execute() is called
|
||||
// Then: Logo metadata should show:
|
||||
// - File size: Correctly formatted (e.g., "1.8 MB")
|
||||
// - File format: Correct format (e.g., "PNG", "SVG")
|
||||
// - Upload date: Correctly formatted date
|
||||
// - Featured status: Correctly indicated
|
||||
});
|
||||
|
||||
it('should correctly handle team logo caching', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Team logo caching
|
||||
// Given: Teams exist with logos
|
||||
// When: GetTeamLogosUseCase.execute() is called multiple times
|
||||
// Then: Subsequent calls should return cached data
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent for each call
|
||||
});
|
||||
|
||||
it('should correctly handle team logo error states', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Team logo error handling
|
||||
// Given: Teams exist
|
||||
// And: TeamLogoRepository throws an error during retrieval
|
||||
// When: GetTeamLogosUseCase.execute() is called
|
||||
// Then: Should propagate the error appropriately
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should correctly handle team league filtering', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Team league filtering
|
||||
// Given: Teams exist in different leagues
|
||||
// When: GetTeamLogosUseCase.execute() is called with league filter
|
||||
// Then: Only teams from the specified league should be returned
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should correctly handle team roster with logos', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Team roster with logos
|
||||
// Given: A team exists with members and logo
|
||||
// When: GetTeamLogosUseCase.execute() is called
|
||||
// Then: The result should show team logo
|
||||
// And: Team roster should be accessible
|
||||
// And: EventPublisher should emit TeamLogosRetrievedEvent
|
||||
});
|
||||
|
||||
it('should correctly handle bulk team logo operations', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Bulk team logo operations
|
||||
// Given: Multiple teams exist
|
||||
// When: Bulk upload or export operations are performed
|
||||
// Then: All operations should complete successfully
|
||||
// And: EventPublisher should emit appropriate events for each operation
|
||||
});
|
||||
});
|
||||
});
|
||||
75
tests/integration/media/teams/team-logo-management.test.ts
Normal file
75
tests/integration/media/teams/team-logo-management.test.ts
Normal file
@@ -0,0 +1,75 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { MediaTestContext } from '../MediaTestContext';
|
||||
import { InMemoryTeamRepository } from '@adapters/racing/persistence/inmemory/InMemoryTeamRepository';
|
||||
import { InMemoryTeamMembershipRepository } from '@adapters/racing/persistence/inmemory/InMemoryTeamMembershipRepository';
|
||||
import { Team } from '@core/racing/domain/entities/Team';
|
||||
import { MediaReference } from '@core/domain/media/MediaReference';
|
||||
|
||||
describe('Team Logo Management', () => {
|
||||
let ctx: MediaTestContext;
|
||||
let teamRepository: InMemoryTeamRepository;
|
||||
let membershipRepository: InMemoryTeamMembershipRepository;
|
||||
|
||||
beforeEach(() => {
|
||||
ctx = MediaTestContext.create();
|
||||
ctx.reset();
|
||||
teamRepository = new InMemoryTeamRepository(ctx.logger);
|
||||
membershipRepository = new InMemoryTeamMembershipRepository(ctx.logger);
|
||||
});
|
||||
|
||||
it('should upload and set a team logo', async () => {
|
||||
// Given: A team exists
|
||||
const team = Team.create({
|
||||
id: 'team-1',
|
||||
name: 'Test Team',
|
||||
tag: 'TST',
|
||||
description: 'Test Description',
|
||||
ownerId: 'owner-1',
|
||||
leagues: [],
|
||||
});
|
||||
await teamRepository.create(team);
|
||||
|
||||
// When: A logo is uploaded
|
||||
const uploadResult = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('logo content'),
|
||||
{ filename: 'logo.png', mimeType: 'image/png' }
|
||||
);
|
||||
expect(uploadResult.success).toBe(true);
|
||||
const mediaId = 'media-1'; // In real use case, this comes from repository save
|
||||
|
||||
// And: The team is updated with the new logo reference
|
||||
const updatedTeam = team.update({
|
||||
logoRef: MediaReference.createUploaded(mediaId)
|
||||
});
|
||||
await teamRepository.update(updatedTeam);
|
||||
|
||||
// Then: The team should have the correct logo reference
|
||||
const savedTeam = await teamRepository.findById('team-1');
|
||||
expect(savedTeam?.logoRef.type).toBe('uploaded');
|
||||
expect(savedTeam?.logoRef.mediaId).toBe(mediaId);
|
||||
});
|
||||
|
||||
it('should retrieve team logos (simulated via repository)', async () => {
|
||||
const team1 = Team.create({
|
||||
id: 'team-1',
|
||||
name: 'Team 1',
|
||||
tag: 'T1',
|
||||
description: 'Desc 1',
|
||||
ownerId: 'owner-1',
|
||||
leagues: ['league-1'],
|
||||
});
|
||||
const team2 = Team.create({
|
||||
id: 'team-2',
|
||||
name: 'Team 2',
|
||||
tag: 'T2',
|
||||
description: 'Desc 2',
|
||||
ownerId: 'owner-2',
|
||||
leagues: ['league-1'],
|
||||
});
|
||||
await teamRepository.create(team1);
|
||||
await teamRepository.create(team2);
|
||||
|
||||
const leagueTeams = await teamRepository.findByLeagueId('league-1');
|
||||
expect(leagueTeams).toHaveLength(2);
|
||||
});
|
||||
});
|
||||
@@ -1,390 +0,0 @@
|
||||
/**
|
||||
* Integration Test: Track Image Management Use Case Orchestration
|
||||
*
|
||||
* Tests the orchestration logic of track image-related Use Cases:
|
||||
* - GetTrackImagesUseCase: Retrieves track images
|
||||
* - UploadTrackImageUseCase: Uploads a new track image
|
||||
* - UpdateTrackImageUseCase: Updates an existing track image
|
||||
* - DeleteTrackImageUseCase: Deletes a track image
|
||||
* - SetTrackFeaturedUseCase: Sets track as featured
|
||||
* - 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';
|
||||
|
||||
describe('Track Image Management Use Case Orchestration', () => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// let trackImageRepository: InMemoryTrackImageRepository;
|
||||
// let trackRepository: InMemoryTrackRepository;
|
||||
// let eventPublisher: InMemoryEventPublisher;
|
||||
// let getTrackImagesUseCase: GetTrackImagesUseCase;
|
||||
// let uploadTrackImageUseCase: UploadTrackImageUseCase;
|
||||
// let updateTrackImageUseCase: UpdateTrackImageUseCase;
|
||||
// let deleteTrackImageUseCase: DeleteTrackImageUseCase;
|
||||
// let setTrackFeaturedUseCase: SetTrackFeaturedUseCase;
|
||||
|
||||
beforeAll(() => {
|
||||
// TODO: Initialize In-Memory repositories and event publisher
|
||||
// trackImageRepository = new InMemoryTrackImageRepository();
|
||||
// trackRepository = new InMemoryTrackRepository();
|
||||
// eventPublisher = new InMemoryEventPublisher();
|
||||
// getTrackImagesUseCase = new GetTrackImagesUseCase({
|
||||
// trackImageRepository,
|
||||
// trackRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// uploadTrackImageUseCase = new UploadTrackImageUseCase({
|
||||
// trackImageRepository,
|
||||
// trackRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// updateTrackImageUseCase = new UpdateTrackImageUseCase({
|
||||
// trackImageRepository,
|
||||
// trackRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// deleteTrackImageUseCase = new DeleteTrackImageUseCase({
|
||||
// trackImageRepository,
|
||||
// trackRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
// setTrackFeaturedUseCase = new SetTrackFeaturedUseCase({
|
||||
// trackImageRepository,
|
||||
// trackRepository,
|
||||
// eventPublisher,
|
||||
// });
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
// TODO: Clear all In-Memory repositories before each test
|
||||
// trackImageRepository.clear();
|
||||
// trackRepository.clear();
|
||||
// eventPublisher.clear();
|
||||
});
|
||||
|
||||
describe('GetTrackImagesUseCase - Success Path', () => {
|
||||
it('should retrieve all track images', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Multiple tracks with images
|
||||
// Given: Multiple tracks exist with images
|
||||
// When: GetTrackImagesUseCase.execute() is called
|
||||
// Then: The result should contain all track images
|
||||
// And: Each image should have correct metadata
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve track images for specific location', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Filter by location
|
||||
// Given: Tracks exist in different locations
|
||||
// When: GetTrackImagesUseCase.execute() is called with location filter
|
||||
// Then: The result should only contain images for that location
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve track images with search query', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Search tracks by name
|
||||
// Given: Tracks exist with various names
|
||||
// When: GetTrackImagesUseCase.execute() is called with search query
|
||||
// Then: The result should only contain matching tracks
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent
|
||||
});
|
||||
|
||||
it('should retrieve featured track images', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Filter by featured status
|
||||
// Given: Tracks exist with featured and non-featured images
|
||||
// When: GetTrackImagesUseCase.execute() is called with featured filter
|
||||
// Then: The result should only contain featured images
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('GetTrackImagesUseCase - Edge Cases', () => {
|
||||
it('should handle empty track list', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: No tracks exist
|
||||
// Given: No tracks exist in the system
|
||||
// When: GetTrackImagesUseCase.execute() is called
|
||||
// Then: The result should be an empty list
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent
|
||||
});
|
||||
|
||||
it('should handle tracks without images', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Tracks exist without images
|
||||
// Given: Tracks exist without images
|
||||
// When: GetTrackImagesUseCase.execute() is called
|
||||
// Then: The result should show tracks with default images
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadTrackImageUseCase - Success Path', () => {
|
||||
it('should upload a new track image', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads new track image
|
||||
// Given: A track exists without an image
|
||||
// And: Valid image data is provided
|
||||
// When: UploadTrackImageUseCase.execute() is called with track ID and image data
|
||||
// Then: The image should be stored in the repository
|
||||
// And: The image should have correct metadata (file size, format, upload date)
|
||||
// And: EventPublisher should emit TrackImageUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload image with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin uploads image with validation
|
||||
// Given: A track exists
|
||||
// And: Image data meets validation requirements (correct format, size, dimensions)
|
||||
// When: UploadTrackImageUseCase.execute() is called
|
||||
// Then: The image should be stored successfully
|
||||
// And: EventPublisher should emit TrackImageUploadedEvent
|
||||
});
|
||||
|
||||
it('should upload image for new track creation', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin creates track with image
|
||||
// Given: No track exists
|
||||
// When: UploadTrackImageUseCase.execute() is called with new track details and image
|
||||
// Then: The track should be created
|
||||
// And: The image should be stored
|
||||
// And: EventPublisher should emit TrackCreatedEvent and TrackImageUploadedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UploadTrackImageUseCase - Validation', () => {
|
||||
it('should reject upload with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A track exists
|
||||
// And: Image data has invalid format (e.g., .txt, .exe)
|
||||
// When: UploadTrackImageUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A track exists
|
||||
// And: Image data exceeds maximum file size
|
||||
// When: UploadTrackImageUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject upload with invalid dimensions', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid image dimensions
|
||||
// Given: A track exists
|
||||
// And: Image data has invalid dimensions (too small or too large)
|
||||
// When: UploadTrackImageUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateTrackImageUseCase - Success Path', () => {
|
||||
it('should update existing track image', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates track image
|
||||
// Given: A track exists with an existing image
|
||||
// And: Valid new image data is provided
|
||||
// When: UpdateTrackImageUseCase.execute() is called with track ID and new image data
|
||||
// Then: The old image should be replaced with the new one
|
||||
// And: The new image should have updated metadata
|
||||
// And: EventPublisher should emit TrackImageUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update image with validation requirements', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin updates image with validation
|
||||
// Given: A track exists with an existing image
|
||||
// And: New image data meets validation requirements
|
||||
// When: UpdateTrackImageUseCase.execute() is called
|
||||
// Then: The image should be updated successfully
|
||||
// And: EventPublisher should emit TrackImageUpdatedEvent
|
||||
});
|
||||
|
||||
it('should update image for track with multiple images', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Track with multiple images
|
||||
// Given: A track exists with multiple images
|
||||
// When: UpdateTrackImageUseCase.execute() is called
|
||||
// Then: Only the specified image should be updated
|
||||
// And: Other images should remain unchanged
|
||||
// And: EventPublisher should emit TrackImageUpdatedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('UpdateTrackImageUseCase - Validation', () => {
|
||||
it('should reject update with invalid file format', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Invalid file format
|
||||
// Given: A track exists with an existing image
|
||||
// And: New image data has invalid format
|
||||
// When: UpdateTrackImageUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should reject update with oversized file', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: File exceeds size limit
|
||||
// Given: A track exists with an existing image
|
||||
// And: New image data exceeds maximum file size
|
||||
// When: UpdateTrackImageUseCase.execute() is called
|
||||
// Then: Should throw ValidationError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteTrackImageUseCase - Success Path', () => {
|
||||
it('should delete track image', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin deletes track image
|
||||
// Given: A track exists with an existing image
|
||||
// When: DeleteTrackImageUseCase.execute() is called with track ID
|
||||
// Then: The image should be removed from the repository
|
||||
// And: The track should show a default image
|
||||
// And: EventPublisher should emit TrackImageDeletedEvent
|
||||
});
|
||||
|
||||
it('should delete specific image when track has multiple images', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Track with multiple images
|
||||
// Given: A track exists with multiple images
|
||||
// When: DeleteTrackImageUseCase.execute() is called with specific image ID
|
||||
// Then: Only that image should be removed
|
||||
// And: Other images should remain
|
||||
// And: EventPublisher should emit TrackImageDeletedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('DeleteTrackImageUseCase - Error Handling', () => {
|
||||
it('should handle deletion when track has no image', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Track without image
|
||||
// Given: A track exists without an image
|
||||
// When: DeleteTrackImageUseCase.execute() is called with track ID
|
||||
// Then: Should complete successfully (no-op)
|
||||
// And: EventPublisher should emit TrackImageDeletedEvent
|
||||
});
|
||||
|
||||
it('should throw error when track does not exist', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Non-existent track
|
||||
// Given: No track exists with the given ID
|
||||
// When: DeleteTrackImageUseCase.execute() is called with non-existent track ID
|
||||
// Then: Should throw TrackNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('SetTrackFeaturedUseCase - Success Path', () => {
|
||||
it('should set track as featured', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Admin sets track as featured
|
||||
// Given: A track exists
|
||||
// When: SetTrackFeaturedUseCase.execute() is called with track ID
|
||||
// Then: The track should be marked as featured
|
||||
// And: EventPublisher should emit TrackFeaturedEvent
|
||||
});
|
||||
|
||||
it('should update featured track when new one is set', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Update featured track
|
||||
// Given: A track exists as featured
|
||||
// When: SetTrackFeaturedUseCase.execute() is called with a different track
|
||||
// Then: The new track should be featured
|
||||
// And: The old track should not be featured
|
||||
// And: EventPublisher should emit TrackFeaturedEvent
|
||||
});
|
||||
|
||||
it('should set track as featured with specific location', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Set track as featured by location
|
||||
// Given: Tracks exist in different locations
|
||||
// When: SetTrackFeaturedUseCase.execute() is called with location filter
|
||||
// Then: The track from that location should be featured
|
||||
// And: EventPublisher should emit TrackFeaturedEvent
|
||||
});
|
||||
});
|
||||
|
||||
describe('SetTrackFeaturedUseCase - Error Handling', () => {
|
||||
it('should throw error when track does not exist', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Non-existent track
|
||||
// Given: No track exists with the given ID
|
||||
// When: SetTrackFeaturedUseCase.execute() is called with non-existent track ID
|
||||
// Then: Should throw TrackNotFoundError
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
});
|
||||
|
||||
describe('Track Image Data Orchestration', () => {
|
||||
it('should correctly format track image metadata', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Track image metadata formatting
|
||||
// Given: A track exists with an image
|
||||
// When: GetTrackImagesUseCase.execute() is called
|
||||
// Then: Image metadata should show:
|
||||
// - File size: Correctly formatted (e.g., "2.1 MB")
|
||||
// - File format: Correct format (e.g., "PNG", "JPEG")
|
||||
// - Upload date: Correctly formatted date
|
||||
// - Featured status: Correctly indicated
|
||||
});
|
||||
|
||||
it('should correctly handle track image caching', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Track image caching
|
||||
// Given: Tracks exist with images
|
||||
// When: GetTrackImagesUseCase.execute() is called multiple times
|
||||
// Then: Subsequent calls should return cached data
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent for each call
|
||||
});
|
||||
|
||||
it('should correctly handle track image error states', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Track image error handling
|
||||
// Given: Tracks exist
|
||||
// And: TrackImageRepository throws an error during retrieval
|
||||
// When: GetTrackImagesUseCase.execute() is called
|
||||
// Then: Should propagate the error appropriately
|
||||
// And: EventPublisher should NOT emit any events
|
||||
});
|
||||
|
||||
it('should correctly handle track location filtering', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Track location filtering
|
||||
// Given: Tracks exist in different locations
|
||||
// When: GetTrackImagesUseCase.execute() is called with location filter
|
||||
// Then: Only tracks from the specified location should be returned
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent
|
||||
});
|
||||
|
||||
it('should correctly handle track layout with images', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Track layout with images
|
||||
// Given: A track exists with layout information and image
|
||||
// When: GetTrackImagesUseCase.execute() is called
|
||||
// Then: The result should show track image
|
||||
// And: Track layout should be accessible
|
||||
// And: EventPublisher should emit TrackImagesRetrievedEvent
|
||||
});
|
||||
|
||||
it('should correctly handle bulk track image operations', async () => {
|
||||
// TODO: Implement test
|
||||
// Scenario: Bulk track image operations
|
||||
// Given: Multiple tracks exist
|
||||
// When: Bulk upload or export operations are performed
|
||||
// Then: All operations should complete successfully
|
||||
// And: EventPublisher should emit appropriate events for each operation
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,65 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { MediaTestContext } from '../MediaTestContext';
|
||||
import { InMemoryTrackRepository } from '@adapters/racing/persistence/inmemory/InMemoryTrackRepository';
|
||||
import { Track } from '@core/racing/domain/entities/Track';
|
||||
|
||||
describe('Track Image Management', () => {
|
||||
let ctx: MediaTestContext;
|
||||
let trackRepository: InMemoryTrackRepository;
|
||||
|
||||
beforeEach(() => {
|
||||
ctx = MediaTestContext.create();
|
||||
ctx.reset();
|
||||
trackRepository = new InMemoryTrackRepository(ctx.logger);
|
||||
});
|
||||
|
||||
it('should upload and set a track image', async () => {
|
||||
// Given: A track exists
|
||||
const track = Track.create({
|
||||
id: 'track-1',
|
||||
name: 'Test Track',
|
||||
shortName: 'TST',
|
||||
location: 'Test Location',
|
||||
country: 'Test Country',
|
||||
gameId: 'game-1',
|
||||
category: 'road',
|
||||
});
|
||||
await trackRepository.create(track);
|
||||
|
||||
// When: An image is uploaded
|
||||
const uploadResult = await ctx.mediaStorage.uploadMedia(
|
||||
Buffer.from('image content'),
|
||||
{ filename: 'track.png', mimeType: 'image/png' }
|
||||
);
|
||||
expect(uploadResult.success).toBe(true);
|
||||
const imageUrl = uploadResult.url!;
|
||||
|
||||
// And: The track is updated with the new image URL
|
||||
const updatedTrack = track.update({
|
||||
imageUrl: imageUrl
|
||||
});
|
||||
await trackRepository.update(updatedTrack);
|
||||
|
||||
// Then: The track should have the correct image URL
|
||||
const savedTrack = await trackRepository.findById('track-1');
|
||||
expect(savedTrack?.imageUrl?.value).toBe(imageUrl);
|
||||
});
|
||||
|
||||
it('should retrieve track images (simulated via repository)', async () => {
|
||||
const track = Track.create({
|
||||
id: 'track-1',
|
||||
name: 'Test Track',
|
||||
shortName: 'TST',
|
||||
location: 'Test Location',
|
||||
country: 'Test Country',
|
||||
gameId: 'game-1',
|
||||
category: 'road',
|
||||
imageUrl: 'https://example.com/track.png'
|
||||
});
|
||||
await trackRepository.create(track);
|
||||
|
||||
const found = await trackRepository.findById('track-1');
|
||||
expect(found).not.toBeNull();
|
||||
expect(found?.imageUrl?.value).toBe('https://example.com/track.png');
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user