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

integration tests
Some checks failed
Contract Testing / contract-tests (pull_request) Failing after 4m46s
Details
Contract Testing / contract-snapshot (pull_request) Has been skipped
Details

Browse Source
This commit is contained in:
Marc Mintel
2026-01-22 19:16:43 +01:00
parent 597bb48248
commit 2fba80da57
25 changed files with 5143 additions and 7496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

853
tests/integration/sponsor/sponsor-billing-use-cases.integration.test.ts
View File

@@ -1,359 +1,568 @@
/**
* Integration Test: Sponsor Billing Use Case Orchestration
*
*
* Tests the orchestration logic of sponsor billing-related Use Cases:
* - GetBillingStatisticsUseCase: Retrieves billing statistics
* - GetPaymentMethodsUseCase: Retrieves payment methods
* - SetDefaultPaymentMethodUseCase: Sets default payment method
* - GetInvoicesUseCase: Retrieves invoices
* - DownloadInvoiceUseCase: Downloads invoice
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - GetSponsorBillingUseCase: Retrieves sponsor billing information
* - Validates that Use Cases correctly interact with their Ports (Repositories)
* - Uses In-Memory adapters for fast, deterministic testing
*
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/sponsors/persistence/inmemory/InMemorySponsorRepository';
import { InMemoryBillingRepository } from '../../../adapters/billing/persistence/inmemory/InMemoryBillingRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetBillingStatisticsUseCase } from '../../../core/sponsors/use-cases/GetBillingStatisticsUseCase';
import { GetPaymentMethodsUseCase } from '../../../core/sponsors/use-cases/GetPaymentMethodsUseCase';
import { SetDefaultPaymentMethodUseCase } from '../../../core/sponsors/use-cases/SetDefaultPaymentMethodUseCase';
import { GetInvoicesUseCase } from '../../../core/sponsors/use-cases/GetInvoicesUseCase';
import { DownloadInvoiceUseCase } from '../../../core/sponsors/use-cases/DownloadInvoiceUseCase';
import { GetBillingStatisticsQuery } from '../../../core/sponsors/ports/GetBillingStatisticsQuery';
import { GetPaymentMethodsQuery } from '../../../core/sponsors/ports/GetPaymentMethodsQuery';
import { SetDefaultPaymentMethodCommand } from '../../../core/sponsors/ports/SetDefaultPaymentMethodCommand';
import { GetInvoicesQuery } from '../../../core/sponsors/ports/GetInvoicesQuery';
import { DownloadInvoiceCommand } from '../../../core/sponsors/ports/DownloadInvoiceCommand';
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorRepository';
import { InMemorySeasonSponsorshipRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySeasonSponsorshipRepository';
import { InMemoryPaymentRepository } from '../../../adapters/payments/persistence/inmemory/InMemoryPaymentRepository';
import { GetSponsorBillingUseCase } from '../../../core/payments/application/use-cases/GetSponsorBillingUseCase';
import { Sponsor } from '../../../core/racing/domain/entities/sponsor/Sponsor';
import { SeasonSponsorship } from '../../../core/racing/domain/entities/season/SeasonSponsorship';
import { Payment, PaymentType, PaymentStatus } from '../../../core/payments/domain/entities/Payment';
import { Money } from '../../../core/racing/domain/value-objects/Money';
import { Logger } from '../../../core/shared/domain/Logger';
describe('Sponsor Billing Use Case Orchestration', () => {
let sponsorRepository: InMemorySponsorRepository;
let billingRepository: InMemoryBillingRepository;
let eventPublisher: InMemoryEventPublisher;
let getBillingStatisticsUseCase: GetBillingStatisticsUseCase;
let getPaymentMethodsUseCase: GetPaymentMethodsUseCase;
let setDefaultPaymentMethodUseCase: SetDefaultPaymentMethodUseCase;
let getInvoicesUseCase: GetInvoicesUseCase;
let downloadInvoiceUseCase: DownloadInvoiceUseCase;
let seasonSponsorshipRepository: InMemorySeasonSponsorshipRepository;
let paymentRepository: InMemoryPaymentRepository;
let getSponsorBillingUseCase: GetSponsorBillingUseCase;
let mockLogger: Logger;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// sponsorRepository = new InMemorySponsorRepository();
// billingRepository = new InMemoryBillingRepository();
// eventPublisher = new InMemoryEventPublisher();
// getBillingStatisticsUseCase = new GetBillingStatisticsUseCase({
// sponsorRepository,
// billingRepository,
// eventPublisher,
// });
// getPaymentMethodsUseCase = new GetPaymentMethodsUseCase({
// sponsorRepository,
// billingRepository,
// eventPublisher,
// });
// setDefaultPaymentMethodUseCase = new SetDefaultPaymentMethodUseCase({
// sponsorRepository,
// billingRepository,
// eventPublisher,
// });
// getInvoicesUseCase = new GetInvoicesUseCase({
// sponsorRepository,
// billingRepository,
// eventPublisher,
// });
// downloadInvoiceUseCase = new DownloadInvoiceUseCase({
// sponsorRepository,
// billingRepository,
// eventPublisher,
// });
mockLogger = {
info: () => {},
debug: () => {},
warn: () => {},
error: () => {},
} as unknown as Logger;
sponsorRepository = new InMemorySponsorRepository(mockLogger);
seasonSponsorshipRepository = new InMemorySeasonSponsorshipRepository(mockLogger);
paymentRepository = new InMemoryPaymentRepository(mockLogger);
getSponsorBillingUseCase = new GetSponsorBillingUseCase(
paymentRepository,
seasonSponsorshipRepository,
);
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// sponsorRepository.clear();
// billingRepository.clear();
// eventPublisher.clear();
sponsorRepository.clear();
seasonSponsorshipRepository.clear();
paymentRepository.clear();
});
describe('GetBillingStatisticsUseCase - Success Path', () => {
it('should retrieve billing statistics for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with billing data
describe('GetSponsorBillingUseCase - Success Path', () => {
it('should retrieve billing statistics for a sponsor with paid invoices', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has total spent: $5000
// And: The sponsor has pending payments: $1000
// And: The sponsor has next payment date: "2024-02-01"
// And: The sponsor has monthly average spend: $1250
// When: GetBillingStatisticsUseCase.execute() is called with sponsor ID
// Then: The result should show total spent: $5000
// And: The result should show pending payments: $1000
// And: The result should show next payment date: "2024-02-01"
// And: The result should show monthly average spend: $1250
// And: EventPublisher should emit BillingStatisticsAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 2 active sponsorships
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-2',
tier: 'secondary',
pricing: Money.create(500, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship2);
// And: The sponsor has 3 paid invoices
const payment1: Payment = {
id: 'payment-1',
type: PaymentType.SPONSORSHIP,
amount: 1000,
platformFee: 100,
netAmount: 900,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-1',
seasonId: 'season-1',
status: PaymentStatus.COMPLETED,
createdAt: new Date('2025-01-15'),
completedAt: new Date('2025-01-15'),
};
await paymentRepository.create(payment1);
const payment2: Payment = {
id: 'payment-2',
type: PaymentType.SPONSORSHIP,
amount: 2000,
platformFee: 200,
netAmount: 1800,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-2',
seasonId: 'season-2',
status: PaymentStatus.COMPLETED,
createdAt: new Date('2025-02-15'),
completedAt: new Date('2025-02-15'),
};
await paymentRepository.create(payment2);
const payment3: Payment = {
id: 'payment-3',
type: PaymentType.SPONSORSHIP,
amount: 3000,
platformFee: 300,
netAmount: 2700,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-3',
seasonId: 'season-3',
status: PaymentStatus.COMPLETED,
createdAt: new Date('2025-03-15'),
completedAt: new Date('2025-03-15'),
};
await paymentRepository.create(payment3);
// When: GetSponsorBillingUseCase.execute() is called with sponsor ID
const result = await getSponsorBillingUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain billing data
expect(result.isOk()).toBe(true);
const billing = result.unwrap();
// And: The invoices should contain all 3 paid invoices
expect(billing.invoices).toHaveLength(3);
expect(billing.invoices[0].status).toBe('paid');
expect(billing.invoices[1].status).toBe('paid');
expect(billing.invoices[2].status).toBe('paid');
// And: The stats should show correct total spent
// Total spent = 1000 + 2000 + 3000 = 6000
expect(billing.stats.totalSpent).toBe(6000);
// And: The stats should show no pending payments
expect(billing.stats.pendingAmount).toBe(0);
// And: The stats should show no next payment date
expect(billing.stats.nextPaymentDate).toBeNull();
expect(billing.stats.nextPaymentAmount).toBeNull();
// And: The stats should show correct active sponsorships
expect(billing.stats.activeSponsorships).toBe(2);
// And: The stats should show correct average monthly spend
// Average monthly spend = total / months = 6000 / 3 = 2000
expect(billing.stats.averageMonthlySpend).toBe(2000);
});
it('should retrieve statistics with zero values', async () => {
// TODO: Implement test
// Scenario: Sponsor with no billing data
it('should retrieve billing statistics with pending invoices', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no billing history
// When: GetBillingStatisticsUseCase.execute() is called with sponsor ID
// Then: The result should show total spent: $0
// And: The result should show pending payments: $0
// And: The result should show next payment date: null
// And: The result should show monthly average spend: $0
// And: EventPublisher should emit BillingStatisticsAccessedEvent
});
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
describe('GetBillingStatisticsUseCase - 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: GetBillingStatisticsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
// And: The sponsor has 1 active sponsorship
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
// And: The sponsor has 1 paid invoice and 1 pending invoice
const payment1: Payment = {
id: 'payment-1',
type: PaymentType.SPONSORSHIP,
amount: 1000,
platformFee: 100,
netAmount: 900,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-1',
seasonId: 'season-1',
status: PaymentStatus.COMPLETED,
createdAt: new Date('2025-01-15'),
completedAt: new Date('2025-01-15'),
};
await paymentRepository.create(payment1);
const payment2: Payment = {
id: 'payment-2',
type: PaymentType.SPONSORSHIP,
amount: 500,
platformFee: 50,
netAmount: 450,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-2',
seasonId: 'season-2',
status: PaymentStatus.PENDING,
createdAt: new Date('2025-02-15'),
};
await paymentRepository.create(payment2);
// When: GetSponsorBillingUseCase.execute() is called with sponsor ID
const result = await getSponsorBillingUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain billing data
expect(result.isOk()).toBe(true);
const billing = result.unwrap();
// And: The invoices should contain both invoices
expect(billing.invoices).toHaveLength(2);
// And: The stats should show correct total spent (only paid invoices)
expect(billing.stats.totalSpent).toBe(1000);
// And: The stats should show correct pending amount
expect(billing.stats.pendingAmount).toBe(550); // 500 + 50
// And: The stats should show next payment date
expect(billing.stats.nextPaymentDate).toBeDefined();
expect(billing.stats.nextPaymentAmount).toBe(550);
// And: The stats should show correct active sponsorships
expect(billing.stats.activeSponsorships).toBe(1);
});
it('should throw error when sponsor ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid sponsor ID
// Given: An invalid sponsor ID (e.g., empty string, null, undefined)
// When: GetBillingStatisticsUseCase.execute() is called with invalid sponsor ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('GetPaymentMethodsUseCase - Success Path', () => {
it('should retrieve payment methods for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with multiple payment methods
it('should retrieve billing statistics with zero values when no invoices exist', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 3 payment methods (1 default, 2 non-default)
// When: GetPaymentMethodsUseCase.execute() is called with sponsor ID
// Then: The result should contain all 3 payment methods
// And: Each payment method should display its details
// And: The default payment method should be marked
// And: EventPublisher should emit PaymentMethodsAccessedEvent
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
it('should retrieve payment methods with minimal data', async () => {
// TODO: Implement test
// Scenario: Sponsor with single payment method
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 1 payment method (default)
// When: GetPaymentMethodsUseCase.execute() is called with sponsor ID
// Then: The result should contain the single payment method
// And: EventPublisher should emit PaymentMethodsAccessedEvent
});
// And: The sponsor has 1 active sponsorship
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
it('should retrieve payment methods with empty result', async () => {
// TODO: Implement test
// Scenario: Sponsor with no payment methods
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no payment methods
// When: GetPaymentMethodsUseCase.execute() is called with sponsor ID
// Then: The result should be empty
// And: EventPublisher should emit PaymentMethodsAccessedEvent
});
});
describe('GetPaymentMethodsUseCase - 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: GetPaymentMethodsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
});
describe('SetDefaultPaymentMethodUseCase - Success Path', () => {
it('should set default payment method for a sponsor', async () => {
// TODO: Implement test
// Scenario: Set default payment method
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 3 payment methods (1 default, 2 non-default)
// When: SetDefaultPaymentMethodUseCase.execute() is called with payment method ID
// Then: The payment method should become default
// And: The previous default should no longer be default
// And: EventPublisher should emit PaymentMethodUpdatedEvent
});
it('should set default payment method when no default exists', async () => {
// TODO: Implement test
// Scenario: Set default when none exists
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 2 payment methods (no default)
// When: SetDefaultPaymentMethodUseCase.execute() is called with payment method ID
// Then: The payment method should become default
// And: EventPublisher should emit PaymentMethodUpdatedEvent
});
});
describe('SetDefaultPaymentMethodUseCase - 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: SetDefaultPaymentMethodUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when payment method does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent payment method
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 2 payment methods
// When: SetDefaultPaymentMethodUseCase.execute() is called with non-existent payment method ID
// Then: Should throw PaymentMethodNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when payment method does not belong to sponsor', async () => {
// TODO: Implement test
// Scenario: Payment method belongs to different sponsor
// Given: Sponsor A exists with ID "sponsor-123"
// And: Sponsor B exists with ID "sponsor-456"
// And: Sponsor B has a payment method with ID "pm-789"
// When: SetDefaultPaymentMethodUseCase.execute() is called with sponsor ID "sponsor-123" and payment method ID "pm-789"
// Then: Should throw PaymentMethodNotFoundError
// And: EventPublisher should NOT emit any events
});
});
describe('GetInvoicesUseCase - Success Path', () => {
it('should retrieve invoices for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with multiple invoices
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 invoices (2 pending, 2 paid, 1 overdue)
// When: GetInvoicesUseCase.execute() is called with sponsor ID
// Then: The result should contain all 5 invoices
// And: Each invoice should display its details
// And: EventPublisher should emit InvoicesAccessedEvent
});
it('should retrieve invoices with minimal data', async () => {
// TODO: Implement test
// Scenario: Sponsor with single invoice
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 1 invoice
// When: GetInvoicesUseCase.execute() is called with sponsor ID
// Then: The result should contain the single invoice
// And: EventPublisher should emit InvoicesAccessedEvent
});
it('should retrieve invoices with empty result', async () => {
// TODO: Implement test
// Scenario: Sponsor with no invoices
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no invoices
// When: GetInvoicesUseCase.execute() is called with sponsor ID
// Then: The result should be empty
// And: EventPublisher should emit InvoicesAccessedEvent
});
});
// When: GetSponsorBillingUseCase.execute() is called with sponsor ID
const result = await getSponsorBillingUseCase.execute({ sponsorId: 'sponsor-123' });
describe('GetInvoicesUseCase - 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: GetInvoicesUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
});
// Then: The result should contain billing data
expect(result.isOk()).toBe(true);
const billing = result.unwrap();
describe('DownloadInvoiceUseCase - Success Path', () => {
it('should download invoice for a sponsor', async () => {
// TODO: Implement test
// Scenario: Download invoice
// And: The invoices should be empty
expect(billing.invoices).toHaveLength(0);
// And: The stats should show zero values
expect(billing.stats.totalSpent).toBe(0);
expect(billing.stats.pendingAmount).toBe(0);
expect(billing.stats.nextPaymentDate).toBeNull();
expect(billing.stats.nextPaymentAmount).toBeNull();
expect(billing.stats.activeSponsorships).toBe(1);
expect(billing.stats.averageMonthlySpend).toBe(0);
});
it('should retrieve billing statistics with mixed invoice statuses', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has an invoice with ID "inv-456"
// When: DownloadInvoiceUseCase.execute() is called with invoice ID
// Then: The invoice should be downloaded
// And: The invoice should be in PDF format
// And: EventPublisher should emit InvoiceDownloadedEvent
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
it('should download invoice with correct content', async () => {
// TODO: Implement test
// Scenario: Download invoice with correct content
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has an invoice with ID "inv-456"
// When: DownloadInvoiceUseCase.execute() is called with invoice ID
// Then: The downloaded invoice should contain correct invoice number
// And: The downloaded invoice should contain correct date
// And: The downloaded invoice should contain correct amount
// And: EventPublisher should emit InvoiceDownloadedEvent
});
});
// And: The sponsor has 1 active sponsorship
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
describe('DownloadInvoiceUseCase - Error Handling', () => {
it('should throw error when invoice does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent invoice
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no invoice with ID "inv-999"
// When: DownloadInvoiceUseCase.execute() is called with non-existent invoice ID
// Then: Should throw InvoiceNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when invoice does not belong to sponsor', async () => {
// TODO: Implement test
// Scenario: Invoice belongs to different sponsor
// Given: Sponsor A exists with ID "sponsor-123"
// And: Sponsor B exists with ID "sponsor-456"
// And: Sponsor B has an invoice with ID "inv-789"
// When: DownloadInvoiceUseCase.execute() is called with invoice ID "inv-789"
// Then: Should throw InvoiceNotFoundError
// And: EventPublisher should NOT emit any events
});
});
describe('Billing Data Orchestration', () => {
it('should correctly aggregate billing statistics', async () => {
// TODO: Implement test
// Scenario: Billing statistics aggregation
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 3 invoices with amounts: $1000, $2000, $3000
// And: The sponsor has 1 pending invoice with amount: $500
// When: GetBillingStatisticsUseCase.execute() is called
// Then: Total spent should be $6000
// And: Pending payments should be $500
// And: EventPublisher should emit BillingStatisticsAccessedEvent
});
it('should correctly set default payment method', async () => {
// TODO: Implement test
// Scenario: Set default payment method
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 3 payment methods
// When: SetDefaultPaymentMethodUseCase.execute() is called
// Then: Only one payment method should be default
// And: The default payment method should be marked correctly
// And: EventPublisher should emit PaymentMethodUpdatedEvent
});
it('should correctly retrieve invoices with status', async () => {
// TODO: Implement test
// Scenario: Invoice status retrieval
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has invoices with different statuses
// When: GetInvoicesUseCase.execute() is called
// Then: Each invoice should have correct status
// And: Pending invoices should be highlighted
// And: Overdue invoices should show warning
// And: EventPublisher should emit InvoicesAccessedEvent
const payment1: Payment = {
id: 'payment-1',
type: PaymentType.SPONSORSHIP,
amount: 1000,
platformFee: 100,
netAmount: 900,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-1',
seasonId: 'season-1',
status: PaymentStatus.COMPLETED,
createdAt: new Date('2025-01-15'),
completedAt: new Date('2025-01-15'),
};
await paymentRepository.create(payment1);
const payment2: Payment = {
id: 'payment-2',
type: PaymentType.SPONSORSHIP,
amount: 500,
platformFee: 50,
netAmount: 450,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-2',
seasonId: 'season-2',
status: PaymentStatus.PENDING,
createdAt: new Date('2025-02-15'),
};
await paymentRepository.create(payment2);
const payment3: Payment = {
id: 'payment-3',
type: PaymentType.SPONSORSHIP,
amount: 300,
platformFee: 30,
netAmount: 270,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-3',
seasonId: 'season-3',
status: PaymentStatus.FAILED,
createdAt: new Date('2025-03-15'),
};
await paymentRepository.create(payment3);
// When: GetSponsorBillingUseCase.execute() is called with sponsor ID
const result = await getSponsorBillingUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain billing data
expect(result.isOk()).toBe(true);
const billing = result.unwrap();
// And: The invoices should contain all 3 invoices
expect(billing.invoices).toHaveLength(3);
// And: The stats should show correct total spent (only paid invoices)
expect(billing.stats.totalSpent).toBe(1000);
// And: The stats should show correct pending amount (pending + failed)
expect(billing.stats.pendingAmount).toBe(550); // 500 + 50
// And: The stats should show correct active sponsorships
expect(billing.stats.activeSponsorships).toBe(1);
});
});
describe('GetSponsorBillingUseCase - Error Handling', () => {
it('should return error when sponsor does not exist', async () => {
// Given: No sponsor exists with the given ID
// When: GetSponsorBillingUseCase.execute() is called with non-existent sponsor ID
const result = await getSponsorBillingUseCase.execute({ sponsorId: 'non-existent-sponsor' });
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('SPONSOR_NOT_FOUND');
});
});
describe('Sponsor Billing Data Orchestration', () => {
it('should correctly aggregate billing statistics across multiple invoices', async () => {
// Given: A sponsor exists with ID "sponsor-123"
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 1 active sponsorship
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
// And: The sponsor has 5 invoices with different amounts and statuses
const invoices = [
{ id: 'payment-1', amount: 1000, status: PaymentStatus.COMPLETED, date: new Date('2025-01-15') },
{ id: 'payment-2', amount: 2000, status: PaymentStatus.COMPLETED, date: new Date('2025-02-15') },
{ id: 'payment-3', amount: 1500, status: PaymentStatus.PENDING, date: new Date('2025-03-15') },
{ id: 'payment-4', amount: 3000, status: PaymentStatus.COMPLETED, date: new Date('2025-04-15') },
{ id: 'payment-5', amount: 500, status: PaymentStatus.FAILED, date: new Date('2025-05-15') },
];
for (const invoice of invoices) {
const payment: Payment = {
id: invoice.id,
type: PaymentType.SPONSORSHIP,
amount: invoice.amount,
platformFee: invoice.amount * 0.1,
netAmount: invoice.amount * 0.9,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-1',
seasonId: 'season-1',
status: invoice.status,
createdAt: invoice.date,
completedAt: invoice.status === PaymentStatus.COMPLETED ? invoice.date : undefined,
};
await paymentRepository.create(payment);
}
// When: GetSponsorBillingUseCase.execute() is called
const result = await getSponsorBillingUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The billing statistics should be correctly aggregated
expect(result.isOk()).toBe(true);
const billing = result.unwrap();
// Total spent = 1000 + 2000 + 3000 = 6000
expect(billing.stats.totalSpent).toBe(6000);
// Pending amount = 1500 + 500 = 2000
expect(billing.stats.pendingAmount).toBe(2000);
// Average monthly spend = 6000 / 5 = 1200
expect(billing.stats.averageMonthlySpend).toBe(1200);
// Active sponsorships = 1
expect(billing.stats.activeSponsorships).toBe(1);
});
it('should correctly calculate average monthly spend over time', async () => {
// Given: A sponsor exists with ID "sponsor-123"
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 1 active sponsorship
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
// And: The sponsor has invoices spanning 6 months
const invoices = [
{ id: 'payment-1', amount: 1000, date: new Date('2025-01-15') },
{ id: 'payment-2', amount: 1500, date: new Date('2025-02-15') },
{ id: 'payment-3', amount: 2000, date: new Date('2025-03-15') },
{ id: 'payment-4', amount: 2500, date: new Date('2025-04-15') },
{ id: 'payment-5', amount: 3000, date: new Date('2025-05-15') },
{ id: 'payment-6', amount: 3500, date: new Date('2025-06-15') },
];
for (const invoice of invoices) {
const payment: Payment = {
id: invoice.id,
type: PaymentType.SPONSORSHIP,
amount: invoice.amount,
platformFee: invoice.amount * 0.1,
netAmount: invoice.amount * 0.9,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-1',
seasonId: 'season-1',
status: PaymentStatus.COMPLETED,
createdAt: invoice.date,
completedAt: invoice.date,
};
await paymentRepository.create(payment);
}
// When: GetSponsorBillingUseCase.execute() is called
const result = await getSponsorBillingUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The average monthly spend should be calculated correctly
expect(result.isOk()).toBe(true);
const billing = result.unwrap();
// Total = 1000 + 1500 + 2000 + 2500 + 3000 + 3500 = 13500
// Months = 6 (Jan to Jun)
// Average = 13500 / 6 = 2250
expect(billing.stats.averageMonthlySpend).toBe(2250);
});
it('should correctly identify next payment date from pending invoices', async () => {
// Given: A sponsor exists with ID "sponsor-123"
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 1 active sponsorship
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
// And: The sponsor has multiple pending invoices with different due dates
const invoices = [
{ id: 'payment-1', amount: 500, date: new Date('2025-03-15') },
{ id: 'payment-2', amount: 1000, date: new Date('2025-02-15') },
{ id: 'payment-3', amount: 750, date: new Date('2025-01-15') },
];
for (const invoice of invoices) {
const payment: Payment = {
id: invoice.id,
type: PaymentType.SPONSORSHIP,
amount: invoice.amount,
platformFee: invoice.amount * 0.1,
netAmount: invoice.amount * 0.9,
payerId: 'sponsor-123',
payerType: 'sponsor',
leagueId: 'league-1',
seasonId: 'season-1',
status: PaymentStatus.PENDING,
createdAt: invoice.date,
};
await paymentRepository.create(payment);
}
// When: GetSponsorBillingUseCase.execute() is called
const result = await getSponsorBillingUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The next payment should be the earliest pending invoice
expect(result.isOk()).toBe(true);
const billing = result.unwrap();
// Next payment should be from payment-3 (earliest date)
expect(billing.stats.nextPaymentDate).toBe('2025-01-15T00:00:00.000Z');
expect(billing.stats.nextPaymentAmount).toBe(825); // 750 + 75
});
});
});

906
tests/integration/sponsor/sponsor-campaigns-use-cases.integration.test.ts
View File

@@ -1,346 +1,658 @@
/**
* Integration Test: Sponsor Campaigns Use Case Orchestration
*
*
* Tests the orchestration logic of sponsor campaigns-related Use Cases:
* - GetSponsorCampaignsUseCase: Retrieves sponsor's campaigns
* - GetCampaignStatisticsUseCase: Retrieves campaign statistics
* - FilterCampaignsUseCase: Filters campaigns by status
* - SearchCampaignsUseCase: Searches campaigns by query
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - GetSponsorSponsorshipsUseCase: Retrieves sponsor's sponsorships/campaigns
* - Validates that Use Cases correctly interact with their Ports (Repositories)
* - Uses In-Memory adapters for fast, deterministic testing
*
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/sponsors/persistence/inmemory/InMemorySponsorRepository';
import { InMemoryCampaignRepository } from '../../../adapters/sponsors/persistence/inmemory/InMemoryCampaignRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetSponsorCampaignsUseCase } from '../../../core/sponsors/use-cases/GetSponsorCampaignsUseCase';
import { GetCampaignStatisticsUseCase } from '../../../core/sponsors/use-cases/GetCampaignStatisticsUseCase';
import { FilterCampaignsUseCase } from '../../../core/sponsors/use-cases/FilterCampaignsUseCase';
import { SearchCampaignsUseCase } from '../../../core/sponsors/use-cases/SearchCampaignsUseCase';
import { GetSponsorCampaignsQuery } from '../../../core/sponsors/ports/GetSponsorCampaignsQuery';
import { GetCampaignStatisticsQuery } from '../../../core/sponsors/ports/GetCampaignStatisticsQuery';
import { FilterCampaignsCommand } from '../../../core/sponsors/ports/FilterCampaignsCommand';
import { SearchCampaignsCommand } from '../../../core/sponsors/ports/SearchCampaignsCommand';
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorRepository';
import { InMemorySeasonSponsorshipRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySeasonSponsorshipRepository';
import { InMemorySeasonRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySeasonRepository';
import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
import { InMemoryLeagueMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
import { GetSponsorSponsorshipsUseCase } from '../../../core/racing/application/use-cases/GetSponsorSponsorshipsUseCase';
import { Sponsor } from '../../../core/racing/domain/entities/sponsor/Sponsor';
import { SeasonSponsorship } from '../../../core/racing/domain/entities/season/SeasonSponsorship';
import { Season } from '../../../core/racing/domain/entities/season/Season';
import { League } from '../../../core/racing/domain/entities/League';
import { LeagueMembership } from '../../../core/racing/domain/entities/LeagueMembership';
import { Race } from '../../../core/racing/domain/entities/Race';
import { Money } from '../../../core/racing/domain/value-objects/Money';
import { Logger } from '../../../core/shared/domain/Logger';
describe('Sponsor Campaigns Use Case Orchestration', () => {
let sponsorRepository: InMemorySponsorRepository;
let campaignRepository: InMemoryCampaignRepository;
let eventPublisher: InMemoryEventPublisher;
let getSponsorCampaignsUseCase: GetSponsorCampaignsUseCase;
let getCampaignStatisticsUseCase: GetCampaignStatisticsUseCase;
let filterCampaignsUseCase: FilterCampaignsUseCase;
let searchCampaignsUseCase: SearchCampaignsUseCase;
let seasonSponsorshipRepository: InMemorySeasonSponsorshipRepository;
let seasonRepository: InMemorySeasonRepository;
let leagueRepository: InMemoryLeagueRepository;
let leagueMembershipRepository: InMemoryLeagueMembershipRepository;
let raceRepository: InMemoryRaceRepository;
let getSponsorSponsorshipsUseCase: GetSponsorSponsorshipsUseCase;
let mockLogger: Logger;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// sponsorRepository = new InMemorySponsorRepository();
// campaignRepository = new InMemoryCampaignRepository();
// eventPublisher = new InMemoryEventPublisher();
// getSponsorCampaignsUseCase = new GetSponsorCampaignsUseCase({
// sponsorRepository,
// campaignRepository,
// eventPublisher,
// });
// getCampaignStatisticsUseCase = new GetCampaignStatisticsUseCase({
// sponsorRepository,
// campaignRepository,
// eventPublisher,
// });
// filterCampaignsUseCase = new FilterCampaignsUseCase({
// sponsorRepository,
// campaignRepository,
// eventPublisher,
// });
// searchCampaignsUseCase = new SearchCampaignsUseCase({
// sponsorRepository,
// campaignRepository,
// eventPublisher,
// });
mockLogger = {
info: () => {},
debug: () => {},
warn: () => {},
error: () => {},
} as unknown as Logger;
sponsorRepository = new InMemorySponsorRepository(mockLogger);
seasonSponsorshipRepository = new InMemorySeasonSponsorshipRepository(mockLogger);
seasonRepository = new InMemorySeasonRepository(mockLogger);
leagueRepository = new InMemoryLeagueRepository(mockLogger);
leagueMembershipRepository = new InMemoryLeagueMembershipRepository(mockLogger);
raceRepository = new InMemoryRaceRepository(mockLogger);
getSponsorSponsorshipsUseCase = new GetSponsorSponsorshipsUseCase(
sponsorRepository,
seasonSponsorshipRepository,
seasonRepository,
leagueRepository,
leagueMembershipRepository,
raceRepository,
);
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// sponsorRepository.clear();
// campaignRepository.clear();
// eventPublisher.clear();
sponsorRepository.clear();
seasonSponsorshipRepository.clear();
seasonRepository.clear();
leagueRepository.clear();
leagueMembershipRepository.clear();
raceRepository.clear();
});
describe('GetSponsorCampaignsUseCase - Success Path', () => {
it('should retrieve all campaigns for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with multiple campaigns
describe('GetSponsorSponsorshipsUseCase - Success Path', () => {
it('should retrieve all sponsorships for a sponsor', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 campaigns (2 active, 2 pending, 1 rejected)
// When: GetSponsorCampaignsUseCase.execute() is called with sponsor ID
// Then: The result should contain all 5 campaigns
// And: Each campaign should display its details
// And: EventPublisher should emit SponsorCampaignsAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 3 sponsorships with different statuses
const league1 = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league1);
const league2 = League.create({
id: 'league-2',
name: 'League 2',
description: 'Description 2',
ownerId: 'owner-2',
});
await leagueRepository.create(league2);
const league3 = League.create({
id: 'league-3',
name: 'League 3',
description: 'Description 3',
ownerId: 'owner-3',
});
await leagueRepository.create(league3);
const season1 = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season1);
const season2 = Season.create({
id: 'season-2',
leagueId: 'league-2',
name: 'Season 2',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season2);
const season3 = Season.create({
id: 'season-3',
leagueId: 'league-3',
name: 'Season 3',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season3);
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-2',
tier: 'secondary',
pricing: Money.create(500, 'USD'),
status: 'pending',
});
await seasonSponsorshipRepository.create(sponsorship2);
const sponsorship3 = SeasonSponsorship.create({
id: 'sponsorship-3',
sponsorId: 'sponsor-123',
seasonId: 'season-3',
tier: 'secondary',
pricing: Money.create(300, 'USD'),
status: 'completed',
});
await seasonSponsorshipRepository.create(sponsorship3);
// And: The sponsor has different numbers of drivers and races in each league
for (let i = 1; i <= 10; i++) {
const membership = LeagueMembership.create({
id: `membership-1-${i}`,
leagueId: 'league-1',
driverId: `driver-1-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const membership = LeagueMembership.create({
id: `membership-2-${i}`,
leagueId: 'league-2',
driverId: `driver-2-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 8; i++) {
const membership = LeagueMembership.create({
id: `membership-3-${i}`,
leagueId: 'league-3',
driverId: `driver-3-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const race = Race.create({
id: `race-1-${i}`,
leagueId: 'league-1',
track: 'Track 1',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 3; i++) {
const race = Race.create({
id: `race-2-${i}`,
leagueId: 'league-2',
track: 'Track 2',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 4; i++) {
const race = Race.create({
id: `race-3-${i}`,
leagueId: 'league-3',
track: 'Track 3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorSponsorshipsUseCase.execute() is called with sponsor ID
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain sponsor sponsorships
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
// And: The sponsor name should be correct
expect(sponsorships.sponsor.name.toString()).toBe('Test Company');
// And: The sponsorships should contain all 3 sponsorships
expect(sponsorships.sponsorships).toHaveLength(3);
// And: The summary should show correct values
expect(sponsorships.summary.totalSponsorships).toBe(3);
expect(sponsorships.summary.activeSponsorships).toBe(1);
expect(sponsorships.summary.totalInvestment.amount).toBe(1800); // 1000 + 500 + 300
expect(sponsorships.summary.totalPlatformFees.amount).toBe(180); // 100 + 50 + 30
// And: Each sponsorship should have correct metrics
const sponsorship1Summary = sponsorships.sponsorships.find(s => s.sponsorship.id === 'sponsorship-1');
expect(sponsorship1Summary).toBeDefined();
expect(sponsorship1Summary?.metrics.drivers).toBe(10);
expect(sponsorship1Summary?.metrics.races).toBe(5);
expect(sponsorship1Summary?.metrics.completedRaces).toBe(5);
expect(sponsorship1Summary?.metrics.impressions).toBe(5000); // 5 * 10 * 100
});
it('should retrieve campaigns with minimal data', async () => {
// TODO: Implement test
// Scenario: Sponsor with minimal campaigns
it('should retrieve sponsorships with minimal data', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 1 campaign
// When: GetSponsorCampaignsUseCase.execute() is called with sponsor ID
// Then: The result should contain the single campaign
// And: EventPublisher should emit SponsorCampaignsAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 1 sponsorship
const league = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league);
const season = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season);
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
// When: GetSponsorSponsorshipsUseCase.execute() is called with sponsor ID
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain sponsor sponsorships
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
// And: The sponsorships should contain 1 sponsorship
expect(sponsorships.sponsorships).toHaveLength(1);
// And: The summary should show correct values
expect(sponsorships.summary.totalSponsorships).toBe(1);
expect(sponsorships.summary.activeSponsorships).toBe(1);
expect(sponsorships.summary.totalInvestment.amount).toBe(1000);
expect(sponsorships.summary.totalPlatformFees.amount).toBe(100);
});
it('should retrieve campaigns with empty result', async () => {
// TODO: Implement test
// Scenario: Sponsor with no campaigns
it('should retrieve sponsorships with empty result when no sponsorships exist', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no campaigns
// When: GetSponsorCampaignsUseCase.execute() is called with sponsor ID
// Then: The result should be empty
// And: EventPublisher should emit SponsorCampaignsAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has no sponsorships
// When: GetSponsorSponsorshipsUseCase.execute() is called with sponsor ID
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain sponsor sponsorships
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
// And: The sponsorships should be empty
expect(sponsorships.sponsorships).toHaveLength(0);
// And: The summary should show zero values
expect(sponsorships.summary.totalSponsorships).toBe(0);
expect(sponsorships.summary.activeSponsorships).toBe(0);
expect(sponsorships.summary.totalInvestment.amount).toBe(0);
expect(sponsorships.summary.totalPlatformFees.amount).toBe(0);
});
});
describe('GetSponsorCampaignsUseCase - Error Handling', () => {
it('should throw error when sponsor does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent sponsor
describe('GetSponsorSponsorshipsUseCase - Error Handling', () => {
it('should return error when sponsor does not exist', async () => {
// Given: No sponsor exists with the given ID
// When: GetSponsorCampaignsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
// When: GetSponsorSponsorshipsUseCase.execute() is called with non-existent sponsor ID
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'non-existent-sponsor' });
it('should throw error when sponsor ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid sponsor ID
// Given: An invalid sponsor ID (e.g., empty string, null, undefined)
// When: GetSponsorCampaignsUseCase.execute() is called with invalid sponsor ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('SPONSOR_NOT_FOUND');
});
});
describe('GetCampaignStatisticsUseCase - Success Path', () => {
it('should retrieve campaign statistics for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with multiple campaigns
describe('Sponsor Campaigns Data Orchestration', () => {
it('should correctly aggregate sponsorship metrics across multiple sponsorships', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 campaigns (2 active, 2 pending, 1 rejected)
// And: The sponsor has total investment of $5000
// And: The sponsor has total impressions of 100000
// When: GetCampaignStatisticsUseCase.execute() is called with sponsor ID
// Then: The result should show total sponsorships count: 5
// And: The result should show active sponsorships count: 2
// And: The result should show pending sponsorships count: 2
// And: The result should show approved sponsorships count: 2
// And: The result should show rejected sponsorships count: 1
// And: The result should show total investment: $5000
// And: The result should show total impressions: 100000
// And: EventPublisher should emit CampaignStatisticsAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 3 sponsorships with different investments
const league1 = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league1);
const league2 = League.create({
id: 'league-2',
name: 'League 2',
description: 'Description 2',
ownerId: 'owner-2',
});
await leagueRepository.create(league2);
const league3 = League.create({
id: 'league-3',
name: 'League 3',
description: 'Description 3',
ownerId: 'owner-3',
});
await leagueRepository.create(league3);
const season1 = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season1);
const season2 = Season.create({
id: 'season-2',
leagueId: 'league-2',
name: 'Season 2',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season2);
const season3 = Season.create({
id: 'season-3',
leagueId: 'league-3',
name: 'Season 3',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season3);
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-2',
tier: 'secondary',
pricing: Money.create(2000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship2);
const sponsorship3 = SeasonSponsorship.create({
id: 'sponsorship-3',
sponsorId: 'sponsor-123',
seasonId: 'season-3',
tier: 'secondary',
pricing: Money.create(3000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship3);
// And: The sponsor has different numbers of drivers and races in each league
for (let i = 1; i <= 10; i++) {
const membership = LeagueMembership.create({
id: `membership-1-${i}`,
leagueId: 'league-1',
driverId: `driver-1-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const membership = LeagueMembership.create({
id: `membership-2-${i}`,
leagueId: 'league-2',
driverId: `driver-2-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 8; i++) {
const membership = LeagueMembership.create({
id: `membership-3-${i}`,
leagueId: 'league-3',
driverId: `driver-3-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const race = Race.create({
id: `race-1-${i}`,
leagueId: 'league-1',
track: 'Track 1',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 3; i++) {
const race = Race.create({
id: `race-2-${i}`,
leagueId: 'league-2',
track: 'Track 2',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 4; i++) {
const race = Race.create({
id: `race-3-${i}`,
leagueId: 'league-3',
track: 'Track 3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorSponsorshipsUseCase.execute() is called
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The metrics should be correctly aggregated
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
// Total drivers: 10 + 5 + 8 = 23
expect(sponsorships.sponsorships[0].metrics.drivers).toBe(10);
expect(sponsorships.sponsorships[1].metrics.drivers).toBe(5);
expect(sponsorships.sponsorships[2].metrics.drivers).toBe(8);
// Total races: 5 + 3 + 4 = 12
expect(sponsorships.sponsorships[0].metrics.races).toBe(5);
expect(sponsorships.sponsorships[1].metrics.races).toBe(3);
expect(sponsorships.sponsorships[2].metrics.races).toBe(4);
// Total investment: 1000 + 2000 + 3000 = 6000
expect(sponsorships.summary.totalInvestment.amount).toBe(6000);
// Total platform fees: 100 + 200 + 300 = 600
expect(sponsorships.summary.totalPlatformFees.amount).toBe(600);
});
it('should retrieve statistics with zero values', async () => {
// TODO: Implement test
// Scenario: Sponsor with no campaigns
it('should correctly calculate impressions based on completed races and drivers', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no campaigns
// When: GetCampaignStatisticsUseCase.execute() is called with sponsor ID
// Then: The result should show all counts as 0
// And: The result should show total investment as 0
// And: The result should show total impressions as 0
// And: EventPublisher should emit CampaignStatisticsAccessedEvent
});
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
describe('GetCampaignStatisticsUseCase - 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: GetCampaignStatisticsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
});
// And: The sponsor has 1 league with 10 drivers and 5 completed races
const league = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league);
describe('FilterCampaignsUseCase - Success Path', () => {
it('should filter campaigns by "All" status', async () => {
// TODO: Implement test
// Scenario: Filter by All
const season = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season);
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
for (let i = 1; i <= 10; i++) {
const membership = LeagueMembership.create({
id: `membership-${i}`,
leagueId: 'league-1',
driverId: `driver-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const race = Race.create({
id: `race-${i}`,
leagueId: 'league-1',
track: 'Track 1',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorSponsorshipsUseCase.execute() is called
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: Impressions should be calculated correctly
// Impressions = completed races * drivers * 100 = 5 * 10 * 100 = 5000
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
expect(sponsorships.sponsorships[0].metrics.impressions).toBe(5000);
});
it('should correctly calculate platform fees and net amounts', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 campaigns (2 active, 2 pending, 1 rejected)
// When: FilterCampaignsUseCase.execute() is called with status "All"
// Then: The result should contain all 5 campaigns
// And: EventPublisher should emit CampaignsFilteredEvent
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
it('should filter campaigns by "Active" status', async () => {
// TODO: Implement test
// Scenario: Filter by Active
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 campaigns (2 active, 2 pending, 1 rejected)
// When: FilterCampaignsUseCase.execute() is called with status "Active"
// Then: The result should contain only 2 active campaigns
// And: EventPublisher should emit CampaignsFilteredEvent
});
// And: The sponsor has 1 sponsorship
const league = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league);
it('should filter campaigns by "Pending" status', async () => {
// TODO: Implement test
// Scenario: Filter by Pending
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 campaigns (2 active, 2 pending, 1 rejected)
// When: FilterCampaignsUseCase.execute() is called with status "Pending"
// Then: The result should contain only 2 pending campaigns
// And: EventPublisher should emit CampaignsFilteredEvent
});
const season = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season);
it('should filter campaigns by "Approved" status', async () => {
// TODO: Implement test
// Scenario: Filter by Approved
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 campaigns (2 active, 2 pending, 1 rejected)
// When: FilterCampaignsUseCase.execute() is called with status "Approved"
// Then: The result should contain only 2 approved campaigns
// And: EventPublisher should emit CampaignsFilteredEvent
});
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
it('should filter campaigns by "Rejected" status', async () => {
// TODO: Implement test
// Scenario: Filter by Rejected
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 campaigns (2 active, 2 pending, 1 rejected)
// When: FilterCampaignsUseCase.execute() is called with status "Rejected"
// Then: The result should contain only 1 rejected campaign
// And: EventPublisher should emit CampaignsFilteredEvent
});
// When: GetSponsorSponsorshipsUseCase.execute() is called
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
it('should return empty result when no campaigns match filter', async () => {
// TODO: Implement test
// Scenario: Filter with no matches
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 2 active campaigns
// When: FilterCampaignsUseCase.execute() is called with status "Pending"
// Then: The result should be empty
// And: EventPublisher should emit CampaignsFilteredEvent
});
});
// Then: Platform fees and net amounts should be calculated correctly
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
describe('FilterCampaignsUseCase - 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: FilterCampaignsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
// Platform fee = 10% of pricing = 100
expect(sponsorships.sponsorships[0].financials.platformFee.amount).toBe(100);
it('should throw error with invalid status', async () => {
// TODO: Implement test
// Scenario: Invalid status
// Given: A sponsor exists with ID "sponsor-123"
// When: FilterCampaignsUseCase.execute() is called with invalid status
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('SearchCampaignsUseCase - Success Path', () => {
it('should search campaigns by league name', async () => {
// TODO: Implement test
// Scenario: Search by league name
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has campaigns for leagues: "League A", "League B", "League C"
// When: SearchCampaignsUseCase.execute() is called with query "League A"
// Then: The result should contain only campaigns for "League A"
// And: EventPublisher should emit CampaignsSearchedEvent
});
it('should search campaigns by partial match', async () => {
// TODO: Implement test
// Scenario: Search by partial match
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has campaigns for leagues: "Premier League", "League A", "League B"
// When: SearchCampaignsUseCase.execute() is called with query "League"
// Then: The result should contain campaigns for "Premier League", "League A", "League B"
// And: EventPublisher should emit CampaignsSearchedEvent
});
it('should return empty result when no campaigns match search', async () => {
// TODO: Implement test
// Scenario: Search with no matches
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has campaigns for leagues: "League A", "League B"
// When: SearchCampaignsUseCase.execute() is called with query "NonExistent"
// Then: The result should be empty
// And: EventPublisher should emit CampaignsSearchedEvent
});
it('should return all campaigns when search query is empty', async () => {
// TODO: Implement test
// Scenario: Search with empty query
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 3 campaigns
// When: SearchCampaignsUseCase.execute() is called with empty query
// Then: The result should contain all 3 campaigns
// And: EventPublisher should emit CampaignsSearchedEvent
});
});
describe('SearchCampaignsUseCase - 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: SearchCampaignsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error with invalid query', async () => {
// TODO: Implement test
// Scenario: Invalid query
// Given: A sponsor exists with ID "sponsor-123"
// When: SearchCampaignsUseCase.execute() is called with invalid query (e.g., null, undefined)
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('Campaign Data Orchestration', () => {
it('should correctly aggregate campaign statistics', async () => {
// TODO: Implement test
// Scenario: Campaign statistics aggregation
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 3 campaigns with investments: $1000, $2000, $3000
// And: The sponsor has 3 campaigns with impressions: 50000, 30000, 20000
// When: GetCampaignStatisticsUseCase.execute() is called
// Then: Total investment should be $6000
// And: Total impressions should be 100000
// And: EventPublisher should emit CampaignStatisticsAccessedEvent
});
it('should correctly filter campaigns by status', async () => {
// TODO: Implement test
// Scenario: Campaign status filtering
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has campaigns with different statuses
// When: FilterCampaignsUseCase.execute() is called with "Active"
// Then: Only active campaigns should be returned
// And: Each campaign should have correct status
// And: EventPublisher should emit CampaignsFilteredEvent
});
it('should correctly search campaigns by league name', async () => {
// TODO: Implement test
// Scenario: Campaign league name search
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has campaigns for different leagues
// When: SearchCampaignsUseCase.execute() is called with league name
// Then: Only campaigns for matching leagues should be returned
// And: Each campaign should have correct league name
// And: EventPublisher should emit CampaignsSearchedEvent
// Net amount = pricing - platform fee = 1000 - 100 = 900
expect(sponsorships.sponsorships[0].financials.netAmount.amount).toBe(900);
});
});
});

892
tests/integration/sponsor/sponsor-dashboard-use-cases.integration.test.ts
View File

@@ -1,273 +1,709 @@
/**
* Integration Test: Sponsor Dashboard Use Case Orchestration
*
*
* Tests the orchestration logic of sponsor dashboard-related Use Cases:
* - GetDashboardOverviewUseCase: Retrieves dashboard overview
* - GetDashboardMetricsUseCase: Retrieves dashboard metrics
* - GetRecentActivityUseCase: Retrieves recent activity
* - GetPendingActionsUseCase: Retrieves pending actions
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - GetSponsorDashboardUseCase: Retrieves sponsor dashboard metrics
* - Validates that Use Cases correctly interact with their Ports (Repositories)
* - Uses In-Memory adapters for fast, deterministic testing
*
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/sponsors/persistence/inmemory/InMemorySponsorRepository';
import { InMemoryCampaignRepository } from '../../../adapters/sponsors/persistence/inmemory/InMemoryCampaignRepository';
import { InMemoryBillingRepository } from '../../../adapters/billing/persistence/inmemory/InMemoryBillingRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetDashboardOverviewUseCase } from '../../../core/sponsors/use-cases/GetDashboardOverviewUseCase';
import { GetDashboardMetricsUseCase } from '../../../core/sponsors/use-cases/GetDashboardMetricsUseCase';
import { GetRecentActivityUseCase } from '../../../core/sponsors/use-cases/GetRecentActivityUseCase';
import { GetPendingActionsUseCase } from '../../../core/sponsors/use-cases/GetPendingActionsUseCase';
import { GetDashboardOverviewQuery } from '../../../core/sponsors/ports/GetDashboardOverviewQuery';
import { GetDashboardMetricsQuery } from '../../../core/sponsors/ports/GetDashboardMetricsQuery';
import { GetRecentActivityQuery } from '../../../core/sponsors/ports/GetRecentActivityQuery';
import { GetPendingActionsQuery } from '../../../core/sponsors/ports/GetPendingActionsQuery';
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorRepository';
import { InMemorySeasonSponsorshipRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySeasonSponsorshipRepository';
import { InMemorySeasonRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySeasonRepository';
import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
import { InMemoryLeagueMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
import { GetSponsorDashboardUseCase } from '../../../core/racing/application/use-cases/GetSponsorDashboardUseCase';
import { Sponsor } from '../../../core/racing/domain/entities/sponsor/Sponsor';
import { SeasonSponsorship } from '../../../core/racing/domain/entities/season/SeasonSponsorship';
import { Season } from '../../../core/racing/domain/entities/season/Season';
import { League } from '../../../core/racing/domain/entities/League';
import { LeagueMembership } from '../../../core/racing/domain/entities/LeagueMembership';
import { Race } from '../../../core/racing/domain/entities/Race';
import { Money } from '../../../core/racing/domain/value-objects/Money';
import { Logger } from '../../../core/shared/domain/Logger';
describe('Sponsor Dashboard Use Case Orchestration', () => {
let sponsorRepository: InMemorySponsorRepository;
let campaignRepository: InMemoryCampaignRepository;
let billingRepository: InMemoryBillingRepository;
let eventPublisher: InMemoryEventPublisher;
let getDashboardOverviewUseCase: GetDashboardOverviewUseCase;
let getDashboardMetricsUseCase: GetDashboardMetricsUseCase;
let getRecentActivityUseCase: GetRecentActivityUseCase;
let getPendingActionsUseCase: GetPendingActionsUseCase;
let seasonSponsorshipRepository: InMemorySeasonSponsorshipRepository;
let seasonRepository: InMemorySeasonRepository;
let leagueRepository: InMemoryLeagueRepository;
let leagueMembershipRepository: InMemoryLeagueMembershipRepository;
let raceRepository: InMemoryRaceRepository;
let getSponsorDashboardUseCase: GetSponsorDashboardUseCase;
let mockLogger: Logger;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// sponsorRepository = new InMemorySponsorRepository();
// campaignRepository = new InMemoryCampaignRepository();
// billingRepository = new InMemoryBillingRepository();
// eventPublisher = new InMemoryEventPublisher();
// getDashboardOverviewUseCase = new GetDashboardOverviewUseCase({
// sponsorRepository,
// campaignRepository,
// billingRepository,
// eventPublisher,
// });
// getDashboardMetricsUseCase = new GetDashboardMetricsUseCase({
// sponsorRepository,
// campaignRepository,
// billingRepository,
// eventPublisher,
// });
// getRecentActivityUseCase = new GetRecentActivityUseCase({
// sponsorRepository,
// campaignRepository,
// billingRepository,
// eventPublisher,
// });
// getPendingActionsUseCase = new GetPendingActionsUseCase({
// sponsorRepository,
// campaignRepository,
// billingRepository,
// eventPublisher,
// });
mockLogger = {
info: () => {},
debug: () => {},
warn: () => {},
error: () => {},
} as unknown as Logger;
sponsorRepository = new InMemorySponsorRepository(mockLogger);
seasonSponsorshipRepository = new InMemorySeasonSponsorshipRepository(mockLogger);
seasonRepository = new InMemorySeasonRepository(mockLogger);
leagueRepository = new InMemoryLeagueRepository(mockLogger);
leagueMembershipRepository = new InMemoryLeagueMembershipRepository(mockLogger);
raceRepository = new InMemoryRaceRepository(mockLogger);
getSponsorDashboardUseCase = new GetSponsorDashboardUseCase(
sponsorRepository,
seasonSponsorshipRepository,
seasonRepository,
leagueRepository,
leagueMembershipRepository,
raceRepository,
);
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// sponsorRepository.clear();
// campaignRepository.clear();
// billingRepository.clear();
// eventPublisher.clear();
sponsorRepository.clear();
seasonSponsorshipRepository.clear();
seasonRepository.clear();
leagueRepository.clear();
leagueMembershipRepository.clear();
raceRepository.clear();
});
describe('GetDashboardOverviewUseCase - Success Path', () => {
it('should retrieve dashboard overview for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with complete dashboard data
describe('GetSponsorDashboardUseCase - Success Path', () => {
it('should retrieve dashboard metrics for a sponsor with active sponsorships', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has company name "Test Company"
// And: The sponsor has 5 campaigns
// And: The sponsor has billing data
// When: GetDashboardOverviewUseCase.execute() is called with sponsor ID
// Then: The result should show company name
// And: The result should show welcome message
// And: The result should show quick action buttons
// And: EventPublisher should emit DashboardOverviewAccessedEvent
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
it('should retrieve overview with minimal data', async () => {
// TODO: Implement test
// Scenario: Sponsor with minimal data
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has company name "Test Company"
// And: The sponsor has no campaigns
// And: The sponsor has no billing data
// When: GetDashboardOverviewUseCase.execute() is called with sponsor ID
// Then: The result should show company name
// And: The result should show welcome message
// And: EventPublisher should emit DashboardOverviewAccessedEvent
});
});
describe('GetDashboardOverviewUseCase - 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: GetDashboardOverviewUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
});
describe('GetDashboardMetricsUseCase - Success Path', () => {
it('should retrieve dashboard metrics for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with complete metrics
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 5 total sponsorships
// And: The sponsor has 2 active sponsorships
// And: The sponsor has total investment of $5000
// And: The sponsor has total impressions of 100000
// When: GetDashboardMetricsUseCase.execute() is called with sponsor ID
// Then: The result should show total sponsorships: 5
// And: The result should show active sponsorships: 2
// And: The result should show total investment: $5000
// And: The result should show total impressions: 100000
// And: EventPublisher should emit DashboardMetricsAccessedEvent
const league1 = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league1);
const league2 = League.create({
id: 'league-2',
name: 'League 2',
description: 'Description 2',
ownerId: 'owner-2',
});
await leagueRepository.create(league2);
const season1 = Season.create({
id: 'season-1',
leagueId: 'league-1',
gameId: 'game-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season1);
const season2 = Season.create({
id: 'season-2',
leagueId: 'league-2',
gameId: 'game-1',
name: 'Season 2',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season2);
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-2',
tier: 'secondary',
pricing: Money.create(500, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship2);
// And: The sponsor has 5 drivers in league 1 and 3 drivers in league 2
for (let i = 1; i <= 5; i++) {
const membership = LeagueMembership.create({
id: `membership-1-${i}`,
leagueId: 'league-1',
driverId: `driver-1-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 3; i++) {
const membership = LeagueMembership.create({
id: `membership-2-${i}`,
leagueId: 'league-2',
driverId: `driver-2-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
// And: The sponsor has 3 completed races in league 1 and 2 completed races in league 2
for (let i = 1; i <= 3; i++) {
const race = Race.create({
id: `race-1-${i}`,
leagueId: 'league-1',
track: 'Track 1',
car: 'GT3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 2; i++) {
const race = Race.create({
id: `race-2-${i}`,
leagueId: 'league-2',
track: 'Track 2',
car: 'GT3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorDashboardUseCase.execute() is called with sponsor ID
const result = await getSponsorDashboardUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain dashboard metrics
expect(result.isOk()).toBe(true);
const dashboard = result.unwrap();
// And: The sponsor name should be correct
expect(dashboard.sponsorName).toBe('Test Company');
// And: The metrics should show correct values
expect(dashboard.metrics.impressions).toBeGreaterThan(0);
expect(dashboard.metrics.races).toBe(5); // 3 + 2
expect(dashboard.metrics.drivers).toBe(8); // 5 + 3
expect(dashboard.metrics.exposure).toBeGreaterThan(0);
// And: The sponsored leagues should contain both leagues
expect(dashboard.sponsoredLeagues).toHaveLength(2);
expect(dashboard.sponsoredLeagues[0].leagueName).toBe('League 1');
expect(dashboard.sponsoredLeagues[1].leagueName).toBe('League 2');
// And: The investment summary should show correct values
expect(dashboard.investment.activeSponsorships).toBe(2);
expect(dashboard.investment.totalInvestment.amount).toBe(1500); // 1000 + 500
expect(dashboard.investment.costPerThousandViews).toBeGreaterThan(0);
});
it('should retrieve metrics with zero values', async () => {
// TODO: Implement test
// Scenario: Sponsor with no metrics
it('should retrieve dashboard with zero values when sponsor has no sponsorships', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no campaigns
// When: GetDashboardMetricsUseCase.execute() is called with sponsor ID
// Then: The result should show total sponsorships: 0
// And: The result should show active sponsorships: 0
// And: The result should show total investment: $0
// And: The result should show total impressions: 0
// And: EventPublisher should emit DashboardMetricsAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has no sponsorships
// When: GetSponsorDashboardUseCase.execute() is called with sponsor ID
const result = await getSponsorDashboardUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain dashboard metrics with zero values
expect(result.isOk()).toBe(true);
const dashboard = result.unwrap();
// And: The sponsor name should be correct
expect(dashboard.sponsorName).toBe('Test Company');
// And: The metrics should show zero values
expect(dashboard.metrics.impressions).toBe(0);
expect(dashboard.metrics.races).toBe(0);
expect(dashboard.metrics.drivers).toBe(0);
expect(dashboard.metrics.exposure).toBe(0);
// And: The sponsored leagues should be empty
expect(dashboard.sponsoredLeagues).toHaveLength(0);
// And: The investment summary should show zero values
expect(dashboard.investment.activeSponsorships).toBe(0);
expect(dashboard.investment.totalInvestment.amount).toBe(0);
expect(dashboard.investment.costPerThousandViews).toBe(0);
});
it('should retrieve dashboard with mixed sponsorship statuses', async () => {
// Given: A sponsor exists with ID "sponsor-123"
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 1 active, 1 pending, and 1 completed sponsorship
const league1 = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league1);
const season1 = Season.create({
id: 'season-1',
leagueId: 'league-1',
gameId: 'game-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season1);
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'secondary',
pricing: Money.create(500, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship2);
const sponsorship3 = SeasonSponsorship.create({
id: 'sponsorship-3',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'secondary',
pricing: Money.create(300, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship3);
// When: GetSponsorDashboardUseCase.execute() is called with sponsor ID
const result = await getSponsorDashboardUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain dashboard metrics
expect(result.isOk()).toBe(true);
const dashboard = result.unwrap();
// And: The investment summary should show only active sponsorships
expect(dashboard.investment.activeSponsorships).toBe(3);
expect(dashboard.investment.totalInvestment.amount).toBe(1800); // 1000 + 500 + 300
});
});
describe('GetDashboardMetricsUseCase - Error Handling', () => {
it('should throw error when sponsor does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent sponsor
describe('GetSponsorDashboardUseCase - Error Handling', () => {
it('should return error when sponsor does not exist', async () => {
// Given: No sponsor exists with the given ID
// When: GetDashboardMetricsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
// When: GetSponsorDashboardUseCase.execute() is called with non-existent sponsor ID
const result = await getSponsorDashboardUseCase.execute({ sponsorId: 'non-existent-sponsor' });
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('SPONSOR_NOT_FOUND');
});
});
describe('GetRecentActivityUseCase - Success Path', () => {
it('should retrieve recent activity for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with recent activity
describe('Sponsor Dashboard Data Orchestration', () => {
it('should correctly aggregate dashboard metrics across multiple sponsorships', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has recent sponsorship updates
// And: The sponsor has recent billing activity
// And: The sponsor has recent campaign changes
// When: GetRecentActivityUseCase.execute() is called with sponsor ID
// Then: The result should contain recent sponsorship updates
// And: The result should contain recent billing activity
// And: The result should contain recent campaign changes
// And: EventPublisher should emit RecentActivityAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 3 sponsorships with different investments
const league1 = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league1);
const league2 = League.create({
id: 'league-2',
name: 'League 2',
description: 'Description 2',
ownerId: 'owner-2',
});
await leagueRepository.create(league2);
const league3 = League.create({
id: 'league-3',
name: 'League 3',
description: 'Description 3',
ownerId: 'owner-3',
});
await leagueRepository.create(league3);
const season1 = Season.create({
id: 'season-1',
leagueId: 'league-1',
gameId: 'game-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season1);
const season2 = Season.create({
id: 'season-2',
leagueId: 'league-2',
gameId: 'game-1',
name: 'Season 2',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season2);
const season3 = Season.create({
id: 'season-3',
leagueId: 'league-3',
gameId: 'game-1',
name: 'Season 3',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season3);
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-2',
tier: 'secondary',
pricing: Money.create(2000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship2);
const sponsorship3 = SeasonSponsorship.create({
id: 'sponsorship-3',
sponsorId: 'sponsor-123',
seasonId: 'season-3',
tier: 'secondary',
pricing: Money.create(3000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship3);
// And: The sponsor has different numbers of drivers and races in each league
for (let i = 1; i <= 10; i++) {
const membership = LeagueMembership.create({
id: `membership-1-${i}`,
leagueId: 'league-1',
driverId: `driver-1-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const membership = LeagueMembership.create({
id: `membership-2-${i}`,
leagueId: 'league-2',
driverId: `driver-2-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 8; i++) {
const membership = LeagueMembership.create({
id: `membership-3-${i}`,
leagueId: 'league-3',
driverId: `driver-3-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const race = Race.create({
id: `race-1-${i}`,
leagueId: 'league-1',
track: 'Track 1',
car: 'GT3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 3; i++) {
const race = Race.create({
id: `race-2-${i}`,
leagueId: 'league-2',
track: 'Track 2',
car: 'GT3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 4; i++) {
const race = Race.create({
id: `race-3-${i}`,
leagueId: 'league-3',
track: 'Track 3',
car: 'GT3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorDashboardUseCase.execute() is called
const result = await getSponsorDashboardUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The metrics should be correctly aggregated
expect(result.isOk()).toBe(true);
const dashboard = result.unwrap();
// Total drivers: 10 + 5 + 8 = 23
expect(dashboard.metrics.drivers).toBe(23);
// Total races: 5 + 3 + 4 = 12
expect(dashboard.metrics.races).toBe(12);
// Total investment: 1000 + 2000 + 3000 = 6000
expect(dashboard.investment.totalInvestment.amount).toBe(6000);
// Total sponsorships: 3
expect(dashboard.investment.activeSponsorships).toBe(3);
// Cost per thousand views should be calculated correctly
expect(dashboard.investment.costPerThousandViews).toBeGreaterThan(0);
});
it('should retrieve activity with empty result', async () => {
// TODO: Implement test
// Scenario: Sponsor with no recent activity
it('should correctly calculate impressions based on completed races and drivers', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no recent activity
// When: GetRecentActivityUseCase.execute() is called with sponsor ID
// Then: The result should be empty
// And: EventPublisher should emit RecentActivityAccessedEvent
});
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
describe('GetRecentActivityUseCase - 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: GetRecentActivityUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
});
// And: The sponsor has 1 league with 10 drivers and 5 completed races
const league = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league);
describe('GetPendingActionsUseCase - Success Path', () => {
it('should retrieve pending actions for a sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor with pending actions
const season = Season.create({
id: 'season-1',
leagueId: 'league-1',
gameId: 'game-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season);
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
for (let i = 1; i <= 10; i++) {
const membership = LeagueMembership.create({
id: `membership-${i}`,
leagueId: 'league-1',
driverId: `driver-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const race = Race.create({
id: `race-${i}`,
leagueId: 'league-1',
track: 'Track 1',
car: 'GT3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorDashboardUseCase.execute() is called
const result = await getSponsorDashboardUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: Impressions should be calculated correctly
// Impressions = completed races * drivers * 100 = 5 * 10 * 100 = 5000
expect(result.isOk()).toBe(true);
const dashboard = result.unwrap();
expect(dashboard.metrics.impressions).toBe(5000);
});
it('should correctly determine sponsorship status based on season dates', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has sponsorships awaiting approval
// And: The sponsor has pending payments
// And: The sponsor has action items
// When: GetPendingActionsUseCase.execute() is called with sponsor ID
// Then: The result should show sponsorships awaiting approval
// And: The result should show pending payments
// And: The result should show action items
// And: EventPublisher should emit PendingActionsAccessedEvent
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
it('should retrieve pending actions with empty result', async () => {
// TODO: Implement test
// Scenario: Sponsor with no pending actions
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has no pending actions
// When: GetPendingActionsUseCase.execute() is called with sponsor ID
// Then: The result should be empty
// And: EventPublisher should emit PendingActionsAccessedEvent
});
});
// And: The sponsor has sponsorships with different season dates
const league1 = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league1);
describe('GetPendingActionsUseCase - 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: GetPendingActionsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
});
const league2 = League.create({
id: 'league-2',
name: 'League 2',
description: 'Description 2',
ownerId: 'owner-2',
});
await leagueRepository.create(league2);
describe('Dashboard Data Orchestration', () => {
it('should correctly aggregate dashboard metrics', async () => {
// TODO: Implement test
// Scenario: Dashboard metrics aggregation
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has 3 campaigns with investments: $1000, $2000, $3000
// And: The sponsor has 3 campaigns with impressions: 50000, 30000, 20000
// When: GetDashboardMetricsUseCase.execute() is called
// Then: Total sponsorships should be 3
// And: Active sponsorships should be calculated correctly
// And: Total investment should be $6000
// And: Total impressions should be 100000
// And: EventPublisher should emit DashboardMetricsAccessedEvent
});
const league3 = League.create({
id: 'league-3',
name: 'League 3',
description: 'Description 3',
ownerId: 'owner-3',
});
await leagueRepository.create(league3);
it('should correctly format recent activity', async () => {
// TODO: Implement test
// Scenario: Recent activity formatting
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has recent activity from different sources
// When: GetRecentActivityUseCase.execute() is called
// Then: Activity should be sorted by date (newest first)
// And: Each activity should have correct type and details
// And: EventPublisher should emit RecentActivityAccessedEvent
});
// Active season (current date is between start and end)
const season1 = Season.create({
id: 'season-1',
leagueId: 'league-1',
gameId: 'game-1',
name: 'Season 1',
startDate: new Date(Date.now() - 86400000),
endDate: new Date(Date.now() + 86400000),
});
await seasonRepository.create(season1);
it('should correctly identify pending actions', async () => {
// TODO: Implement test
// Scenario: Pending actions identification
// Given: A sponsor exists with ID "sponsor-123"
// And: The sponsor has sponsorships awaiting approval
// And: The sponsor has pending payments
// When: GetPendingActionsUseCase.execute() is called
// Then: All pending actions should be identified
// And: Each action should have correct priority
// And: EventPublisher should emit PendingActionsAccessedEvent
// Upcoming season (start date is in the future)
const season2 = Season.create({
id: 'season-2',
leagueId: 'league-2',
gameId: 'game-1',
name: 'Season 2',
startDate: new Date(Date.now() + 86400000),
endDate: new Date(Date.now() + 172800000),
});
await seasonRepository.create(season2);
// Completed season (end date is in the past)
const season3 = Season.create({
id: 'season-3',
leagueId: 'league-3',
gameId: 'game-1',
name: 'Season 3',
startDate: new Date(Date.now() - 172800000),
endDate: new Date(Date.now() - 86400000),
});
await seasonRepository.create(season3);
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-2',
tier: 'secondary',
pricing: Money.create(500, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship2);
const sponsorship3 = SeasonSponsorship.create({
id: 'sponsorship-3',
sponsorId: 'sponsor-123',
seasonId: 'season-3',
tier: 'secondary',
pricing: Money.create(300, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship3);
// When: GetSponsorDashboardUseCase.execute() is called
const result = await getSponsorDashboardUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The sponsored leagues should have correct status
expect(result.isOk()).toBe(true);
const dashboard = result.unwrap();
expect(dashboard.sponsoredLeagues).toHaveLength(3);
// League 1 should be active (current date is between start and end)
expect(dashboard.sponsoredLeagues[0].status).toBe('active');
// League 2 should be upcoming (start date is in the future)
expect(dashboard.sponsoredLeagues[1].status).toBe('upcoming');
// League 3 should be completed (end date is in the past)
expect(dashboard.sponsoredLeagues[2].status).toBe('completed');
});
});
});

614
tests/integration/sponsor/sponsor-league-detail-use-cases.integration.test.ts
View File

@@ -1,345 +1,339 @@
/**
* Integration Test: Sponsor League Detail Use Case Orchestration
*
*
* Tests the orchestration logic of sponsor league detail-related Use Cases:
* - GetLeagueDetailUseCase: Retrieves detailed league information
* - GetLeagueStatisticsUseCase: Retrieves league statistics
* - GetSponsorshipSlotsUseCase: Retrieves sponsorship slots information
* - GetLeagueScheduleUseCase: Retrieves league schedule
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - GetEntitySponsorshipPricingUseCase: Retrieves sponsorship pricing for leagues
* - Validates that Use Cases correctly interact with their Ports (Repositories)
* - Uses In-Memory adapters for fast, deterministic testing
*
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/sponsors/persistence/inmemory/InMemorySponsorRepository';
import { InMemoryLeagueRepository } from '../../../adapters/leagues/persistence/inmemory/InMemoryLeagueRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetLeagueDetailUseCase } from '../../../core/sponsors/use-cases/GetLeagueDetailUseCase';
import { GetLeagueStatisticsUseCase } from '../../../core/sponsors/use-cases/GetLeagueStatisticsUseCase';
import { GetSponsorshipSlotsUseCase } from '../../../core/sponsors/use-cases/GetSponsorshipSlotsUseCase';
import { GetLeagueScheduleUseCase } from '../../../core/sponsors/use-cases/GetLeagueScheduleUseCase';
import { GetLeagueDetailQuery } from '../../../core/sponsors/ports/GetLeagueDetailQuery';
import { GetLeagueStatisticsQuery } from '../../../core/sponsors/ports/GetLeagueStatisticsQuery';
import { GetSponsorshipSlotsQuery } from '../../../core/sponsors/ports/GetSponsorshipSlotsQuery';
import { GetLeagueScheduleQuery } from '../../../core/sponsors/ports/GetLeagueScheduleQuery';
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { InMemorySponsorshipPricingRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorshipPricingRepository';
import { GetEntitySponsorshipPricingUseCase } from '../../../core/racing/application/use-cases/GetEntitySponsorshipPricingUseCase';
import { Logger } from '../../../core/shared/domain/Logger';
describe('Sponsor League Detail Use Case Orchestration', () => {
let sponsorRepository: InMemorySponsorRepository;
let leagueRepository: InMemoryLeagueRepository;
let eventPublisher: InMemoryEventPublisher;
let getLeagueDetailUseCase: GetLeagueDetailUseCase;
let getLeagueStatisticsUseCase: GetLeagueStatisticsUseCase;
let getSponsorshipSlotsUseCase: GetSponsorshipSlotsUseCase;
let getLeagueScheduleUseCase: GetLeagueScheduleUseCase;
let sponsorshipPricingRepository: InMemorySponsorshipPricingRepository;
let getEntitySponsorshipPricingUseCase: GetEntitySponsorshipPricingUseCase;
let mockLogger: Logger;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// sponsorRepository = new InMemorySponsorRepository();
// leagueRepository = new InMemoryLeagueRepository();
// eventPublisher = new InMemoryEventPublisher();
// getLeagueDetailUseCase = new GetLeagueDetailUseCase({
// sponsorRepository,
// leagueRepository,
// eventPublisher,
// });
// getLeagueStatisticsUseCase = new GetLeagueStatisticsUseCase({
// sponsorRepository,
// leagueRepository,
// eventPublisher,
// });
// getSponsorshipSlotsUseCase = new GetSponsorshipSlotsUseCase({
// sponsorRepository,
// leagueRepository,
// eventPublisher,
// });
// getLeagueScheduleUseCase = new GetLeagueScheduleUseCase({
// sponsorRepository,
// leagueRepository,
// eventPublisher,
// });
mockLogger = {
info: () => {},
debug: () => {},
warn: () => {},
error: () => {},
} as unknown as Logger;
sponsorshipPricingRepository = new InMemorySponsorshipPricingRepository(mockLogger);
getEntitySponsorshipPricingUseCase = new GetEntitySponsorshipPricingUseCase(
sponsorshipPricingRepository,
mockLogger,
);
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// sponsorRepository.clear();
// leagueRepository.clear();
// eventPublisher.clear();
sponsorshipPricingRepository.clear();
});
describe('GetLeagueDetailUseCase - Success Path', () => {
it('should retrieve detailed league information', async () => {
// TODO: Implement test
// Scenario: Sponsor views league detail
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has name "Premier League"
// And: The league has description "Top tier racing league"
// And: The league has logo URL
// And: The league has category "Professional"
// When: GetLeagueDetailUseCase.execute() is called with sponsor ID and league ID
// Then: The result should show league name
// And: The result should show league description
// And: The result should show league logo
// And: The result should show league category
// And: EventPublisher should emit LeagueDetailAccessedEvent
describe('GetEntitySponsorshipPricingUseCase - Success Path', () => {
it('should retrieve sponsorship pricing for a league', async () => {
// Given: A league exists with ID "league-123"
const leagueId = 'league-123';
// And: The league has sponsorship pricing configured
const pricing = {
entityType: 'league' as const,
entityId: leagueId,
acceptingApplications: true,
mainSlot: {
price: { amount: 10000, currency: 'USD' },
benefits: ['Primary logo placement', 'League page header banner'],
},
secondarySlots: {
price: { amount: 2000, currency: 'USD' },
benefits: ['Secondary logo on liveries', 'League page sidebar placement'],
},
};
await sponsorshipPricingRepository.create(pricing);
// When: GetEntitySponsorshipPricingUseCase.execute() is called
const result = await getEntitySponsorshipPricingUseCase.execute({
entityType: 'league',
entityId: leagueId,
});
// Then: The result should contain sponsorship pricing
expect(result.isOk()).toBe(true);
const pricingResult = result.unwrap();
// And: The entity type should be correct
expect(pricingResult.entityType).toBe('league');
// And: The entity ID should be correct
expect(pricingResult.entityId).toBe(leagueId);
// And: The league should be accepting applications
expect(pricingResult.acceptingApplications).toBe(true);
// And: The tiers should contain main slot
expect(pricingResult.tiers).toHaveLength(2);
expect(pricingResult.tiers[0].name).toBe('main');
expect(pricingResult.tiers[0].price.amount).toBe(10000);
expect(pricingResult.tiers[0].price.currency).toBe('USD');
expect(pricingResult.tiers[0].benefits).toContain('Primary logo placement');
// And: The tiers should contain secondary slot
expect(pricingResult.tiers[1].name).toBe('secondary');
expect(pricingResult.tiers[1].price.amount).toBe(2000);
expect(pricingResult.tiers[1].price.currency).toBe('USD');
expect(pricingResult.tiers[1].benefits).toContain('Secondary logo on liveries');
});
it('should retrieve league detail with minimal data', async () => {
// TODO: Implement test
// Scenario: League with minimal data
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has name "Test League"
// When: GetLeagueDetailUseCase.execute() is called with sponsor ID and league ID
// Then: The result should show league name
// And: EventPublisher should emit LeagueDetailAccessedEvent
it('should retrieve sponsorship pricing with only main slot', async () => {
// Given: A league exists with ID "league-123"
const leagueId = 'league-123';
// And: The league has sponsorship pricing configured with only main slot
const pricing = {
entityType: 'league' as const,
entityId: leagueId,
acceptingApplications: true,
mainSlot: {
price: { amount: 10000, currency: 'USD' },
benefits: ['Primary logo placement', 'League page header banner'],
},
};
await sponsorshipPricingRepository.create(pricing);
// When: GetEntitySponsorshipPricingUseCase.execute() is called
const result = await getEntitySponsorshipPricingUseCase.execute({
entityType: 'league',
entityId: leagueId,
});
// Then: The result should contain sponsorship pricing
expect(result.isOk()).toBe(true);
const pricingResult = result.unwrap();
// And: The tiers should contain only main slot
expect(pricingResult.tiers).toHaveLength(1);
expect(pricingResult.tiers[0].name).toBe('main');
expect(pricingResult.tiers[0].price.amount).toBe(10000);
});
it('should retrieve sponsorship pricing with custom requirements', async () => {
// Given: A league exists with ID "league-123"
const leagueId = 'league-123';
// And: The league has sponsorship pricing configured with custom requirements
const pricing = {
entityType: 'league' as const,
entityId: leagueId,
acceptingApplications: true,
customRequirements: 'Must have racing experience',
mainSlot: {
price: { amount: 10000, currency: 'USD' },
benefits: ['Primary logo placement'],
},
};
await sponsorshipPricingRepository.create(pricing);
// When: GetEntitySponsorshipPricingUseCase.execute() is called
const result = await getEntitySponsorshipPricingUseCase.execute({
entityType: 'league',
entityId: leagueId,
});
// Then: The result should contain sponsorship pricing
expect(result.isOk()).toBe(true);
const pricingResult = result.unwrap();
// And: The custom requirements should be included
expect(pricingResult.customRequirements).toBe('Must have racing experience');
});
it('should retrieve sponsorship pricing with not accepting applications', async () => {
// Given: A league exists with ID "league-123"
const leagueId = 'league-123';
// And: The league has sponsorship pricing configured but not accepting applications
const pricing = {
entityType: 'league' as const,
entityId: leagueId,
acceptingApplications: false,
mainSlot: {
price: { amount: 10000, currency: 'USD' },
benefits: ['Primary logo placement'],
},
};
await sponsorshipPricingRepository.create(pricing);
// When: GetEntitySponsorshipPricingUseCase.execute() is called
const result = await getEntitySponsorshipPricingUseCase.execute({
entityType: 'league',
entityId: leagueId,
});
// Then: The result should contain sponsorship pricing
expect(result.isOk()).toBe(true);
const pricingResult = result.unwrap();
// And: The league should not be accepting applications
expect(pricingResult.acceptingApplications).toBe(false);
});
});
describe('GetLeagueDetailUseCase - 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
// And: A league exists with ID "league-456"
// When: GetLeagueDetailUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
describe('GetEntitySponsorshipPricingUseCase - Error Handling', () => {
it('should return error when pricing is not configured', async () => {
// Given: A league exists with ID "league-123"
const leagueId = 'league-123';
// And: The league has no sponsorship pricing configured
// When: GetEntitySponsorshipPricingUseCase.execute() is called
const result = await getEntitySponsorshipPricingUseCase.execute({
entityType: 'league',
entityId: leagueId,
});
it('should throw error when league does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent league
// Given: A sponsor exists with ID "sponsor-123"
// And: No league exists with the given ID
// When: GetLeagueDetailUseCase.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: A sponsor exists with ID "sponsor-123"
// And: An invalid league ID (e.g., empty string, null, undefined)
// When: GetLeagueDetailUseCase.execute() is called with invalid league ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('PRICING_NOT_CONFIGURED');
});
});
describe('GetLeagueStatisticsUseCase - Success Path', () => {
it('should retrieve league statistics', async () => {
// TODO: Implement test
// Scenario: League with statistics
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has 500 total drivers
// And: The league has 300 active drivers
// And: The league has 100 total races
// And: The league has average race duration of 45 minutes
// And: The league has popularity score of 85
// When: GetLeagueStatisticsUseCase.execute() is called with sponsor ID and league ID
// Then: The result should show total drivers: 500
// And: The result should show active drivers: 300
// And: The result should show total races: 100
// And: The result should show average race duration: 45 minutes
// And: The result should show popularity score: 85
// And: EventPublisher should emit LeagueStatisticsAccessedEvent
describe('Sponsor League Detail Data Orchestration', () => {
it('should correctly retrieve sponsorship pricing with all tiers', async () => {
// Given: A league exists with ID "league-123"
const leagueId = 'league-123';
// And: The league has sponsorship pricing configured with both main and secondary slots
const pricing = {
entityType: 'league' as const,
entityId: leagueId,
acceptingApplications: true,
customRequirements: 'Must have racing experience',
mainSlot: {
price: { amount: 10000, currency: 'USD' },
benefits: [
'Primary logo placement on all liveries',
'League page header banner',
'Race results page branding',
'Social media feature posts',
'Newsletter sponsor spot',
],
},
secondarySlots: {
price: { amount: 2000, currency: 'USD' },
benefits: [
'Secondary logo on liveries',
'League page sidebar placement',
'Race results mention',
'Social media mentions',
],
},
};
await sponsorshipPricingRepository.create(pricing);
// When: GetEntitySponsorshipPricingUseCase.execute() is called
const result = await getEntitySponsorshipPricingUseCase.execute({
entityType: 'league',
entityId: leagueId,
});
// Then: The sponsorship pricing should be correctly retrieved
expect(result.isOk()).toBe(true);
const pricingResult = result.unwrap();
// And: The entity type should be correct
expect(pricingResult.entityType).toBe('league');
// And: The entity ID should be correct
expect(pricingResult.entityId).toBe(leagueId);
// And: The league should be accepting applications
expect(pricingResult.acceptingApplications).toBe(true);
// And: The custom requirements should be included
expect(pricingResult.customRequirements).toBe('Must have racing experience');
// And: The tiers should contain both main and secondary slots
expect(pricingResult.tiers).toHaveLength(2);
// And: The main slot should have correct price and benefits
expect(pricingResult.tiers[0].name).toBe('main');
expect(pricingResult.tiers[0].price.amount).toBe(10000);
expect(pricingResult.tiers[0].price.currency).toBe('USD');
expect(pricingResult.tiers[0].benefits).toHaveLength(5);
expect(pricingResult.tiers[0].benefits).toContain('Primary logo placement on all liveries');
// And: The secondary slot should have correct price and benefits
expect(pricingResult.tiers[1].name).toBe('secondary');
expect(pricingResult.tiers[1].price.amount).toBe(2000);
expect(pricingResult.tiers[1].price.currency).toBe('USD');
expect(pricingResult.tiers[1].benefits).toHaveLength(4);
expect(pricingResult.tiers[1].benefits).toContain('Secondary logo on liveries');
});
it('should retrieve statistics with zero values', async () => {
// TODO: Implement test
// Scenario: League with no statistics
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has no drivers
// And: The league has no races
// When: GetLeagueStatisticsUseCase.execute() is called with sponsor ID and league ID
// Then: The result should show total drivers: 0
// And: The result should show active drivers: 0
// And: The result should show total races: 0
// And: The result should show average race duration: 0
// And: The result should show popularity score: 0
// And: EventPublisher should emit LeagueStatisticsAccessedEvent
});
});
it('should correctly retrieve sponsorship pricing for different entity types', async () => {
// Given: A league exists with ID "league-123"
const leagueId = 'league-123';
// And: The league has sponsorship pricing configured
const leaguePricing = {
entityType: 'league' as const,
entityId: leagueId,
acceptingApplications: true,
mainSlot: {
price: { amount: 10000, currency: 'USD' },
benefits: ['Primary logo placement'],
},
};
await sponsorshipPricingRepository.create(leaguePricing);
describe('GetLeagueStatisticsUseCase - 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
// And: A league exists with ID "league-456"
// When: GetLeagueStatisticsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
// And: A team exists with ID "team-456"
const teamId = 'team-456';
// And: The team has sponsorship pricing configured
const teamPricing = {
entityType: 'team' as const,
entityId: teamId,
acceptingApplications: true,
mainSlot: {
price: { amount: 5000, currency: 'USD' },
benefits: ['Team logo placement'],
},
};
await sponsorshipPricingRepository.create(teamPricing);
it('should throw error when league does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent league
// Given: A sponsor exists with ID "sponsor-123"
// And: No league exists with the given ID
// When: GetLeagueStatisticsUseCase.execute() is called with non-existent league ID
// Then: Should throw LeagueNotFoundError
// And: EventPublisher should NOT emit any events
});
});
// When: GetEntitySponsorshipPricingUseCase.execute() is called for league
const leagueResult = await getEntitySponsorshipPricingUseCase.execute({
entityType: 'league',
entityId: leagueId,
});
describe('GetSponsorshipSlotsUseCase - Success Path', () => {
it('should retrieve sponsorship slots information', async () => {
// TODO: Implement test
// Scenario: League with sponsorship slots
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has main sponsor slot available
// And: The league has 5 secondary sponsor slots available
// And: The main slot has pricing of $10000
// And: The secondary slots have pricing of $2000 each
// When: GetSponsorshipSlotsUseCase.execute() is called with sponsor ID and league ID
// Then: The result should show main sponsor slot details
// And: The result should show secondary sponsor slots details
// And: The result should show available slots count
// And: EventPublisher should emit SponsorshipSlotsAccessedEvent
});
// Then: The league pricing should be retrieved
expect(leagueResult.isOk()).toBe(true);
const leaguePricingResult = leagueResult.unwrap();
expect(leaguePricingResult.entityType).toBe('league');
expect(leaguePricingResult.entityId).toBe(leagueId);
expect(leaguePricingResult.tiers[0].price.amount).toBe(10000);
it('should retrieve slots with no available slots', async () => {
// TODO: Implement test
// Scenario: League with no available slots
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has no available sponsorship slots
// When: GetSponsorshipSlotsUseCase.execute() is called with sponsor ID and league ID
// Then: The result should show no available slots
// And: EventPublisher should emit SponsorshipSlotsAccessedEvent
});
});
// When: GetEntitySponsorshipPricingUseCase.execute() is called for team
const teamResult = await getEntitySponsorshipPricingUseCase.execute({
entityType: 'team',
entityId: teamId,
});
describe('GetSponsorshipSlotsUseCase - 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
// And: A league exists with ID "league-456"
// When: GetSponsorshipSlotsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when league does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent league
// Given: A sponsor exists with ID "sponsor-123"
// And: No league exists with the given ID
// When: GetSponsorshipSlotsUseCase.execute() is called with non-existent league ID
// Then: Should throw LeagueNotFoundError
// And: EventPublisher should NOT emit any events
});
});
describe('GetLeagueScheduleUseCase - Success Path', () => {
it('should retrieve league schedule', async () => {
// TODO: Implement test
// Scenario: League with schedule
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has 5 upcoming races
// When: GetLeagueScheduleUseCase.execute() is called with sponsor ID and league ID
// Then: The result should show upcoming races
// And: Each race should show race date
// And: Each race should show race location
// And: Each race should show race type
// And: EventPublisher should emit LeagueScheduleAccessedEvent
});
it('should retrieve schedule with no upcoming races', async () => {
// TODO: Implement test
// Scenario: League with no upcoming races
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has no upcoming races
// When: GetLeagueScheduleUseCase.execute() is called with sponsor ID and league ID
// Then: The result should be empty
// And: EventPublisher should emit LeagueScheduleAccessedEvent
});
});
describe('GetLeagueScheduleUseCase - 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
// And: A league exists with ID "league-456"
// When: GetLeagueScheduleUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error when league does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent league
// Given: A sponsor exists with ID "sponsor-123"
// And: No league exists with the given ID
// When: GetLeagueScheduleUseCase.execute() is called with non-existent league ID
// Then: Should throw LeagueNotFoundError
// And: EventPublisher should NOT emit any events
});
});
describe('League Detail Data Orchestration', () => {
it('should correctly retrieve league detail with all information', async () => {
// TODO: Implement test
// Scenario: League detail orchestration
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has complete information
// When: GetLeagueDetailUseCase.execute() is called
// Then: The result should contain all league information
// And: Each field should be populated correctly
// And: EventPublisher should emit LeagueDetailAccessedEvent
});
it('should correctly aggregate league statistics', async () => {
// TODO: Implement test
// Scenario: League statistics aggregation
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has 500 total drivers
// And: The league has 300 active drivers
// And: The league has 100 total races
// When: GetLeagueStatisticsUseCase.execute() is called
// Then: Total drivers should be 500
// And: Active drivers should be 300
// And: Total races should be 100
// And: EventPublisher should emit LeagueStatisticsAccessedEvent
});
it('should correctly retrieve sponsorship slots', async () => {
// TODO: Implement test
// Scenario: Sponsorship slots retrieval
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has main sponsor slot available
// And: The league has 5 secondary sponsor slots available
// When: GetSponsorshipSlotsUseCase.execute() is called
// Then: Main sponsor slot should be available
// And: Secondary sponsor slots count should be 5
// And: EventPublisher should emit SponsorshipSlotsAccessedEvent
});
it('should correctly retrieve league schedule', async () => {
// TODO: Implement test
// Scenario: League schedule retrieval
// Given: A sponsor exists with ID "sponsor-123"
// And: A league exists with ID "league-456"
// And: The league has 5 upcoming races
// When: GetLeagueScheduleUseCase.execute() is called
// Then: All 5 races should be returned
// And: Each race should have correct details
// And: EventPublisher should emit LeagueScheduleAccessedEvent
// Then: The team pricing should be retrieved
expect(teamResult.isOk()).toBe(true);
const teamPricingResult = teamResult.unwrap();
expect(teamPricingResult.entityType).toBe('team');
expect(teamPricingResult.entityId).toBe(teamId);
expect(teamPricingResult.tiers[0].price.amount).toBe(5000);
});
});
});

889
tests/integration/sponsor/sponsor-leagues-use-cases.integration.test.ts
View File

@@ -1,331 +1,658 @@
/**
* Integration Test: Sponsor Leagues Use Case Orchestration
*
*
* Tests the orchestration logic of sponsor leagues-related Use Cases:
* - GetAvailableLeaguesUseCase: Retrieves available leagues for sponsorship
* - GetLeagueStatisticsUseCase: Retrieves league statistics
* - FilterLeaguesUseCase: Filters leagues by availability
* - SearchLeaguesUseCase: Searches leagues by query
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - GetSponsorSponsorshipsUseCase: Retrieves sponsor's sponsorships/campaigns
* - Validates that Use Cases correctly interact with their Ports (Repositories)
* - Uses In-Memory adapters for fast, deterministic testing
*
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/sponsors/persistence/inmemory/InMemorySponsorRepository';
import { InMemoryLeagueRepository } from '../../../adapters/leagues/persistence/inmemory/InMemoryLeagueRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { GetAvailableLeaguesUseCase } from '../../../core/sponsors/use-cases/GetAvailableLeaguesUseCase';
import { GetLeagueStatisticsUseCase } from '../../../core/sponsors/use-cases/GetLeagueStatisticsUseCase';
import { FilterLeaguesUseCase } from '../../../core/sponsors/use-cases/FilterLeaguesUseCase';
import { SearchLeaguesUseCase } from '../../../core/sponsors/use-cases/SearchLeaguesUseCase';
import { GetAvailableLeaguesQuery } from '../../../core/sponsors/ports/GetAvailableLeaguesQuery';
import { GetLeagueStatisticsQuery } from '../../../core/sponsors/ports/GetLeagueStatisticsQuery';
import { FilterLeaguesCommand } from '../../../core/sponsors/ports/FilterLeaguesCommand';
import { SearchLeaguesCommand } from '../../../core/sponsors/ports/SearchLeaguesCommand';
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorRepository';
import { InMemorySeasonSponsorshipRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySeasonSponsorshipRepository';
import { InMemorySeasonRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySeasonRepository';
import { InMemoryLeagueRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
import { InMemoryLeagueMembershipRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
import { InMemoryRaceRepository } from '../../../adapters/racing/persistence/inmemory/InMemoryRaceRepository';
import { GetSponsorSponsorshipsUseCase } from '../../../core/racing/application/use-cases/GetSponsorSponsorshipsUseCase';
import { Sponsor } from '../../../core/racing/domain/entities/sponsor/Sponsor';
import { SeasonSponsorship } from '../../../core/racing/domain/entities/season/SeasonSponsorship';
import { Season } from '../../../core/racing/domain/entities/season/Season';
import { League } from '../../../core/racing/domain/entities/League';
import { LeagueMembership } from '../../../core/racing/domain/entities/LeagueMembership';
import { Race } from '../../../core/racing/domain/entities/Race';
import { Money } from '../../../core/racing/domain/value-objects/Money';
import { Logger } from '../../../core/shared/domain/Logger';
describe('Sponsor Leagues Use Case Orchestration', () => {
let sponsorRepository: InMemorySponsorRepository;
let seasonSponsorshipRepository: InMemorySeasonSponsorshipRepository;
let seasonRepository: InMemorySeasonRepository;
let leagueRepository: InMemoryLeagueRepository;
let eventPublisher: InMemoryEventPublisher;
let getAvailableLeaguesUseCase: GetAvailableLeaguesUseCase;
let getLeagueStatisticsUseCase: GetLeagueStatisticsUseCase;
let filterLeaguesUseCase: FilterLeaguesUseCase;
let searchLeaguesUseCase: SearchLeaguesUseCase;
let leagueMembershipRepository: InMemoryLeagueMembershipRepository;
let raceRepository: InMemoryRaceRepository;
let getSponsorSponsorshipsUseCase: GetSponsorSponsorshipsUseCase;
let mockLogger: Logger;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// sponsorRepository = new InMemorySponsorRepository();
// leagueRepository = new InMemoryLeagueRepository();
// eventPublisher = new InMemoryEventPublisher();
// getAvailableLeaguesUseCase = new GetAvailableLeaguesUseCase({
// sponsorRepository,
// leagueRepository,
// eventPublisher,
// });
// getLeagueStatisticsUseCase = new GetLeagueStatisticsUseCase({
// sponsorRepository,
// leagueRepository,
// eventPublisher,
// });
// filterLeaguesUseCase = new FilterLeaguesUseCase({
// sponsorRepository,
// leagueRepository,
// eventPublisher,
// });
// searchLeaguesUseCase = new SearchLeaguesUseCase({
// sponsorRepository,
// leagueRepository,
// eventPublisher,
// });
mockLogger = {
info: () => {},
debug: () => {},
warn: () => {},
error: () => {},
} as unknown as Logger;
sponsorRepository = new InMemorySponsorRepository(mockLogger);
seasonSponsorshipRepository = new InMemorySeasonSponsorshipRepository(mockLogger);
seasonRepository = new InMemorySeasonRepository(mockLogger);
leagueRepository = new InMemoryLeagueRepository(mockLogger);
leagueMembershipRepository = new InMemoryLeagueMembershipRepository(mockLogger);
raceRepository = new InMemoryRaceRepository(mockLogger);
getSponsorSponsorshipsUseCase = new GetSponsorSponsorshipsUseCase(
sponsorRepository,
seasonSponsorshipRepository,
seasonRepository,
leagueRepository,
leagueMembershipRepository,
raceRepository,
);
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// sponsorRepository.clear();
// leagueRepository.clear();
// eventPublisher.clear();
sponsorRepository.clear();
seasonSponsorshipRepository.clear();
seasonRepository.clear();
leagueRepository.clear();
leagueMembershipRepository.clear();
raceRepository.clear();
});
describe('GetAvailableLeaguesUseCase - Success Path', () => {
it('should retrieve available leagues for sponsorship', async () => {
// TODO: Implement test
// Scenario: Sponsor with available leagues
describe('GetSponsorSponsorshipsUseCase - Success Path', () => {
it('should retrieve all sponsorships for a sponsor', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: There are 5 leagues available for sponsorship
// When: GetAvailableLeaguesUseCase.execute() is called with sponsor ID
// Then: The result should contain all 5 leagues
// And: Each league should display its details
// And: EventPublisher should emit AvailableLeaguesAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 3 sponsorships with different statuses
const league1 = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league1);
const league2 = League.create({
id: 'league-2',
name: 'League 2',
description: 'Description 2',
ownerId: 'owner-2',
});
await leagueRepository.create(league2);
const league3 = League.create({
id: 'league-3',
name: 'League 3',
description: 'Description 3',
ownerId: 'owner-3',
});
await leagueRepository.create(league3);
const season1 = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season1);
const season2 = Season.create({
id: 'season-2',
leagueId: 'league-2',
name: 'Season 2',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season2);
const season3 = Season.create({
id: 'season-3',
leagueId: 'league-3',
name: 'Season 3',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season3);
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-2',
tier: 'secondary',
pricing: Money.create(500, 'USD'),
status: 'pending',
});
await seasonSponsorshipRepository.create(sponsorship2);
const sponsorship3 = SeasonSponsorship.create({
id: 'sponsorship-3',
sponsorId: 'sponsor-123',
seasonId: 'season-3',
tier: 'secondary',
pricing: Money.create(300, 'USD'),
status: 'completed',
});
await seasonSponsorshipRepository.create(sponsorship3);
// And: The sponsor has different numbers of drivers and races in each league
for (let i = 1; i <= 10; i++) {
const membership = LeagueMembership.create({
id: `membership-1-${i}`,
leagueId: 'league-1',
driverId: `driver-1-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const membership = LeagueMembership.create({
id: `membership-2-${i}`,
leagueId: 'league-2',
driverId: `driver-2-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 8; i++) {
const membership = LeagueMembership.create({
id: `membership-3-${i}`,
leagueId: 'league-3',
driverId: `driver-3-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const race = Race.create({
id: `race-1-${i}`,
leagueId: 'league-1',
track: 'Track 1',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 3; i++) {
const race = Race.create({
id: `race-2-${i}`,
leagueId: 'league-2',
track: 'Track 2',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 4; i++) {
const race = Race.create({
id: `race-3-${i}`,
leagueId: 'league-3',
track: 'Track 3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorSponsorshipsUseCase.execute() is called with sponsor ID
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain sponsor sponsorships
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
// And: The sponsor name should be correct
expect(sponsorships.sponsor.name.toString()).toBe('Test Company');
// And: The sponsorships should contain all 3 sponsorships
expect(sponsorships.sponsorships).toHaveLength(3);
// And: The summary should show correct values
expect(sponsorships.summary.totalSponsorships).toBe(3);
expect(sponsorships.summary.activeSponsorships).toBe(1);
expect(sponsorships.summary.totalInvestment.amount).toBe(1800); // 1000 + 500 + 300
expect(sponsorships.summary.totalPlatformFees.amount).toBe(180); // 100 + 50 + 30
// And: Each sponsorship should have correct metrics
const sponsorship1Summary = sponsorships.sponsorships.find(s => s.sponsorship.id === 'sponsorship-1');
expect(sponsorship1Summary).toBeDefined();
expect(sponsorship1Summary?.metrics.drivers).toBe(10);
expect(sponsorship1Summary?.metrics.races).toBe(5);
expect(sponsorship1Summary?.metrics.completedRaces).toBe(5);
expect(sponsorship1Summary?.metrics.impressions).toBe(5000); // 5 * 10 * 100
});
it('should retrieve leagues with minimal data', async () => {
// TODO: Implement test
// Scenario: Sponsor with minimal leagues
it('should retrieve sponsorships with minimal data', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: There is 1 league available for sponsorship
// When: GetAvailableLeaguesUseCase.execute() is called with sponsor ID
// Then: The result should contain the single league
// And: EventPublisher should emit AvailableLeaguesAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 1 sponsorship
const league = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league);
const season = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season);
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
// When: GetSponsorSponsorshipsUseCase.execute() is called with sponsor ID
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain sponsor sponsorships
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
// And: The sponsorships should contain 1 sponsorship
expect(sponsorships.sponsorships).toHaveLength(1);
// And: The summary should show correct values
expect(sponsorships.summary.totalSponsorships).toBe(1);
expect(sponsorships.summary.activeSponsorships).toBe(1);
expect(sponsorships.summary.totalInvestment.amount).toBe(1000);
expect(sponsorships.summary.totalPlatformFees.amount).toBe(100);
});
it('should retrieve leagues with empty result', async () => {
// TODO: Implement test
// Scenario: Sponsor with no available leagues
it('should retrieve sponsorships with empty result when no sponsorships exist', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: There are no leagues available for sponsorship
// When: GetAvailableLeaguesUseCase.execute() is called with sponsor ID
// Then: The result should be empty
// And: EventPublisher should emit AvailableLeaguesAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has no sponsorships
// When: GetSponsorSponsorshipsUseCase.execute() is called with sponsor ID
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The result should contain sponsor sponsorships
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
// And: The sponsorships should be empty
expect(sponsorships.sponsorships).toHaveLength(0);
// And: The summary should show zero values
expect(sponsorships.summary.totalSponsorships).toBe(0);
expect(sponsorships.summary.activeSponsorships).toBe(0);
expect(sponsorships.summary.totalInvestment.amount).toBe(0);
expect(sponsorships.summary.totalPlatformFees.amount).toBe(0);
});
});
describe('GetAvailableLeaguesUseCase - Error Handling', () => {
it('should throw error when sponsor does not exist', async () => {
// TODO: Implement test
// Scenario: Non-existent sponsor
describe('GetSponsorSponsorshipsUseCase - Error Handling', () => {
it('should return error when sponsor does not exist', async () => {
// Given: No sponsor exists with the given ID
// When: GetAvailableLeaguesUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
// When: GetSponsorSponsorshipsUseCase.execute() is called with non-existent sponsor ID
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'non-existent-sponsor' });
it('should throw error when sponsor ID is invalid', async () => {
// TODO: Implement test
// Scenario: Invalid sponsor ID
// Given: An invalid sponsor ID (e.g., empty string, null, undefined)
// When: GetAvailableLeaguesUseCase.execute() is called with invalid sponsor ID
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('SPONSOR_NOT_FOUND');
});
});
describe('GetLeagueStatisticsUseCase - Success Path', () => {
it('should retrieve league statistics', async () => {
// TODO: Implement test
// Scenario: Sponsor with league statistics
describe('Sponsor Leagues Data Orchestration', () => {
it('should correctly aggregate sponsorship metrics across multiple sponsorships', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: There are 10 leagues available
// And: There are 3 main sponsor slots available
// And: There are 15 secondary sponsor slots available
// And: There are 500 total drivers
// And: Average CPM is $50
// When: GetLeagueStatisticsUseCase.execute() is called with sponsor ID
// Then: The result should show total leagues count: 10
// And: The result should show main sponsor slots available: 3
// And: The result should show secondary sponsor slots available: 15
// And: The result should show total drivers count: 500
// And: The result should show average CPM: $50
// And: EventPublisher should emit LeagueStatisticsAccessedEvent
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
// And: The sponsor has 3 sponsorships with different investments
const league1 = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league1);
const league2 = League.create({
id: 'league-2',
name: 'League 2',
description: 'Description 2',
ownerId: 'owner-2',
});
await leagueRepository.create(league2);
const league3 = League.create({
id: 'league-3',
name: 'League 3',
description: 'Description 3',
ownerId: 'owner-3',
});
await leagueRepository.create(league3);
const season1 = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season1);
const season2 = Season.create({
id: 'season-2',
leagueId: 'league-2',
name: 'Season 2',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season2);
const season3 = Season.create({
id: 'season-3',
leagueId: 'league-3',
name: 'Season 3',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season3);
const sponsorship1 = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship1);
const sponsorship2 = SeasonSponsorship.create({
id: 'sponsorship-2',
sponsorId: 'sponsor-123',
seasonId: 'season-2',
tier: 'secondary',
pricing: Money.create(2000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship2);
const sponsorship3 = SeasonSponsorship.create({
id: 'sponsorship-3',
sponsorId: 'sponsor-123',
seasonId: 'season-3',
tier: 'secondary',
pricing: Money.create(3000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship3);
// And: The sponsor has different numbers of drivers and races in each league
for (let i = 1; i <= 10; i++) {
const membership = LeagueMembership.create({
id: `membership-1-${i}`,
leagueId: 'league-1',
driverId: `driver-1-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const membership = LeagueMembership.create({
id: `membership-2-${i}`,
leagueId: 'league-2',
driverId: `driver-2-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 8; i++) {
const membership = LeagueMembership.create({
id: `membership-3-${i}`,
leagueId: 'league-3',
driverId: `driver-3-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const race = Race.create({
id: `race-1-${i}`,
leagueId: 'league-1',
track: 'Track 1',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 3; i++) {
const race = Race.create({
id: `race-2-${i}`,
leagueId: 'league-2',
track: 'Track 2',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
for (let i = 1; i <= 4; i++) {
const race = Race.create({
id: `race-3-${i}`,
leagueId: 'league-3',
track: 'Track 3',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorSponsorshipsUseCase.execute() is called
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: The metrics should be correctly aggregated
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
// Total drivers: 10 + 5 + 8 = 23
expect(sponsorships.sponsorships[0].metrics.drivers).toBe(10);
expect(sponsorships.sponsorships[1].metrics.drivers).toBe(5);
expect(sponsorships.sponsorships[2].metrics.drivers).toBe(8);
// Total races: 5 + 3 + 4 = 12
expect(sponsorships.sponsorships[0].metrics.races).toBe(5);
expect(sponsorships.sponsorships[1].metrics.races).toBe(3);
expect(sponsorships.sponsorships[2].metrics.races).toBe(4);
// Total investment: 1000 + 2000 + 3000 = 6000
expect(sponsorships.summary.totalInvestment.amount).toBe(6000);
// Total platform fees: 100 + 200 + 300 = 600
expect(sponsorships.summary.totalPlatformFees.amount).toBe(600);
});
it('should retrieve statistics with zero values', async () => {
// TODO: Implement test
// Scenario: Sponsor with no leagues
it('should correctly calculate impressions based on completed races and drivers', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: There are no leagues available
// When: GetLeagueStatisticsUseCase.execute() is called with sponsor ID
// Then: The result should show all counts as 0
// And: The result should show average CPM as 0
// And: EventPublisher should emit LeagueStatisticsAccessedEvent
});
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
describe('GetLeagueStatisticsUseCase - 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: GetLeagueStatisticsUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
});
// And: The sponsor has 1 league with 10 drivers and 5 completed races
const league = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league);
describe('FilterLeaguesUseCase - Success Path', () => {
it('should filter leagues by "All" availability', async () => {
// TODO: Implement test
// Scenario: Filter by All
const season = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season);
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
for (let i = 1; i <= 10; i++) {
const membership = LeagueMembership.create({
id: `membership-${i}`,
leagueId: 'league-1',
driverId: `driver-${i}`,
role: 'member',
status: 'active',
});
await leagueMembershipRepository.saveMembership(membership);
}
for (let i = 1; i <= 5; i++) {
const race = Race.create({
id: `race-${i}`,
leagueId: 'league-1',
track: 'Track 1',
scheduledAt: new Date(`2025-0${i}-01`),
status: 'completed',
});
await raceRepository.create(race);
}
// When: GetSponsorSponsorshipsUseCase.execute() is called
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
// Then: Impressions should be calculated correctly
// Impressions = completed races * drivers * 100 = 5 * 10 * 100 = 5000
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
expect(sponsorships.sponsorships[0].metrics.impressions).toBe(5000);
});
it('should correctly calculate platform fees and net amounts', async () => {
// Given: A sponsor exists with ID "sponsor-123"
// And: There are 5 leagues (3 with main slot available, 2 with secondary slots available)
// When: FilterLeaguesUseCase.execute() is called with availability "All"
// Then: The result should contain all 5 leagues
// And: EventPublisher should emit LeaguesFilteredEvent
});
const sponsor = Sponsor.create({
id: 'sponsor-123',
name: 'Test Company',
contactEmail: 'test@example.com',
});
await sponsorRepository.create(sponsor);
it('should filter leagues by "Main Slot Available" availability', async () => {
// TODO: Implement test
// Scenario: Filter by Main Slot Available
// Given: A sponsor exists with ID "sponsor-123"
// And: There are 5 leagues (3 with main slot available, 2 with secondary slots available)
// When: FilterLeaguesUseCase.execute() is called with availability "Main Slot Available"
// Then: The result should contain only 3 leagues with main slot available
// And: EventPublisher should emit LeaguesFilteredEvent
});
// And: The sponsor has 1 sponsorship
const league = League.create({
id: 'league-1',
name: 'League 1',
description: 'Description 1',
ownerId: 'owner-1',
});
await leagueRepository.create(league);
it('should filter leagues by "Secondary Slot Available" availability', async () => {
// TODO: Implement test
// Scenario: Filter by Secondary Slot Available
// Given: A sponsor exists with ID "sponsor-123"
// And: There are 5 leagues (3 with main slot available, 2 with secondary slots available)
// When: FilterLeaguesUseCase.execute() is called with availability "Secondary Slot Available"
// Then: The result should contain only 2 leagues with secondary slots available
// And: EventPublisher should emit LeaguesFilteredEvent
});
const season = Season.create({
id: 'season-1',
leagueId: 'league-1',
name: 'Season 1',
startDate: new Date('2025-01-01'),
endDate: new Date('2025-12-31'),
});
await seasonRepository.create(season);
it('should return empty result when no leagues match filter', async () => {
// TODO: Implement test
// Scenario: Filter with no matches
// Given: A sponsor exists with ID "sponsor-123"
// And: There are 2 leagues with main slot available
// When: FilterLeaguesUseCase.execute() is called with availability "Secondary Slot Available"
// Then: The result should be empty
// And: EventPublisher should emit LeaguesFilteredEvent
});
});
const sponsorship = SeasonSponsorship.create({
id: 'sponsorship-1',
sponsorId: 'sponsor-123',
seasonId: 'season-1',
tier: 'main',
pricing: Money.create(1000, 'USD'),
status: 'active',
});
await seasonSponsorshipRepository.create(sponsorship);
describe('FilterLeaguesUseCase - 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: FilterLeaguesUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
// When: GetSponsorSponsorshipsUseCase.execute() is called
const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });
it('should throw error with invalid availability', async () => {
// TODO: Implement test
// Scenario: Invalid availability
// Given: A sponsor exists with ID "sponsor-123"
// When: FilterLeaguesUseCase.execute() is called with invalid availability
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
// Then: Platform fees and net amounts should be calculated correctly
expect(result.isOk()).toBe(true);
const sponsorships = result.unwrap();
describe('SearchLeaguesUseCase - Success Path', () => {
it('should search leagues by league name', async () => {
// TODO: Implement test
// Scenario: Search by league name
// Given: A sponsor exists with ID "sponsor-123"
// And: There are leagues named: "Premier League", "League A", "League B"
// When: SearchLeaguesUseCase.execute() is called with query "Premier League"
// Then: The result should contain only "Premier League"
// And: EventPublisher should emit LeaguesSearchedEvent
});
// Platform fee = 10% of pricing = 100
expect(sponsorships.sponsorships[0].financials.platformFee.amount).toBe(100);
it('should search leagues by partial match', async () => {
// TODO: Implement test
// Scenario: Search by partial match
// Given: A sponsor exists with ID "sponsor-123"
// And: There are leagues named: "Premier League", "League A", "League B"
// When: SearchLeaguesUseCase.execute() is called with query "League"
// Then: The result should contain all three leagues
// And: EventPublisher should emit LeaguesSearchedEvent
});
it('should return empty result when no leagues match search', async () => {
// TODO: Implement test
// Scenario: Search with no matches
// Given: A sponsor exists with ID "sponsor-123"
// And: There are leagues named: "League A", "League B"
// When: SearchLeaguesUseCase.execute() is called with query "NonExistent"
// Then: The result should be empty
// And: EventPublisher should emit LeaguesSearchedEvent
});
it('should return all leagues when search query is empty', async () => {
// TODO: Implement test
// Scenario: Search with empty query
// Given: A sponsor exists with ID "sponsor-123"
// And: There are 3 leagues available
// When: SearchLeaguesUseCase.execute() is called with empty query
// Then: The result should contain all 3 leagues
// And: EventPublisher should emit LeaguesSearchedEvent
});
});
describe('SearchLeaguesUseCase - 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: SearchLeaguesUseCase.execute() is called with non-existent sponsor ID
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should throw error with invalid query', async () => {
// TODO: Implement test
// Scenario: Invalid query
// Given: A sponsor exists with ID "sponsor-123"
// When: SearchLeaguesUseCase.execute() is called with invalid query (e.g., null, undefined)
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('League Data Orchestration', () => {
it('should correctly aggregate league statistics', async () => {
// TODO: Implement test
// Scenario: League statistics aggregation
// Given: A sponsor exists with ID "sponsor-123"
// And: There are 5 leagues with different slot availability
// And: There are 3 main sponsor slots available
// And: There are 15 secondary sponsor slots available
// And: There are 500 total drivers
// And: Average CPM is $50
// When: GetLeagueStatisticsUseCase.execute() is called
// Then: Total leagues should be 5
// And: Main sponsor slots available should be 3
// And: Secondary sponsor slots available should be 15
// And: Total drivers count should be 500
// And: Average CPM should be $50
// And: EventPublisher should emit LeagueStatisticsAccessedEvent
});
it('should correctly filter leagues by availability', async () => {
// TODO: Implement test
// Scenario: League availability filtering
// Given: A sponsor exists with ID "sponsor-123"
// And: There are leagues with different slot availability
// When: FilterLeaguesUseCase.execute() is called with "Main Slot Available"
// Then: Only leagues with main slot available should be returned
// And: Each league should have correct availability
// And: EventPublisher should emit LeaguesFilteredEvent
});
it('should correctly search leagues by name', async () => {
// TODO: Implement test
// Scenario: League name search
// Given: A sponsor exists with ID "sponsor-123"
// And: There are leagues with different names
// When: SearchLeaguesUseCase.execute() is called with league name
// Then: Only leagues with matching names should be returned
// And: Each league should have correct name
// And: EventPublisher should emit LeaguesSearchedEvent
// Net amount = pricing - platform fee = 1000 - 100 = 900
expect(sponsorships.sponsorships[0].financials.netAmount.amount).toBe(900);
});
});
});

379
tests/integration/sponsor/sponsor-signup-use-cases.integration.test.ts
View File

@@ -1,241 +1,282 @@
/**
* Integration Test: Sponsor Signup Use Case Orchestration
*
*
* Tests the orchestration logic of sponsor signup-related Use Cases:
* - CreateSponsorUseCase: Creates a new sponsor account
* - SponsorLoginUseCase: Authenticates a sponsor
* - SponsorLogoutUseCase: Logs out a sponsor
* - Validates that Use Cases correctly interact with their Ports (Repositories, Event Publishers)
* - Validates that Use Cases correctly interact with their Ports (Repositories)
* - Uses In-Memory adapters for fast, deterministic testing
*
*
* Focus: Business logic orchestration, NOT UI rendering
*/
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/sponsors/persistence/inmemory/InMemorySponsorRepository';
import { InMemoryEventPublisher } from '../../../adapters/events/InMemoryEventPublisher';
import { CreateSponsorUseCase } from '../../../core/sponsors/use-cases/CreateSponsorUseCase';
import { SponsorLoginUseCase } from '../../../core/sponsors/use-cases/SponsorLoginUseCase';
import { SponsorLogoutUseCase } from '../../../core/sponsors/use-cases/SponsorLogoutUseCase';
import { CreateSponsorCommand } from '../../../core/sponsors/ports/CreateSponsorCommand';
import { SponsorLoginCommand } from '../../../core/sponsors/ports/SponsorLoginCommand';
import { SponsorLogoutCommand } from '../../../core/sponsors/ports/SponsorLogoutCommand';
import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
import { InMemorySponsorRepository } from '../../../adapters/racing/persistence/inmemory/InMemorySponsorRepository';
import { CreateSponsorUseCase } from '../../../core/racing/application/use-cases/CreateSponsorUseCase';
import { Sponsor } from '../../../core/racing/domain/entities/sponsor/Sponsor';
import { Logger } from '../../../core/shared/domain/Logger';
describe('Sponsor Signup Use Case Orchestration', () => {
let sponsorRepository: InMemorySponsorRepository;
let eventPublisher: InMemoryEventPublisher;
let createSponsorUseCase: CreateSponsorUseCase;
let sponsorLoginUseCase: SponsorLoginUseCase;
let sponsorLogoutUseCase: SponsorLogoutUseCase;
let mockLogger: Logger;
beforeAll(() => {
// TODO: Initialize In-Memory repositories and event publisher
// sponsorRepository = new InMemorySponsorRepository();
// eventPublisher = new InMemoryEventPublisher();
// createSponsorUseCase = new CreateSponsorUseCase({
// sponsorRepository,
// eventPublisher,
// });
// sponsorLoginUseCase = new SponsorLoginUseCase({
// sponsorRepository,
// eventPublisher,
// });
// sponsorLogoutUseCase = new SponsorLogoutUseCase({
// sponsorRepository,
// eventPublisher,
// });
mockLogger = {
info: () => {},
debug: () => {},
warn: () => {},
error: () => {},
} as unknown as Logger;
sponsorRepository = new InMemorySponsorRepository(mockLogger);
createSponsorUseCase = new CreateSponsorUseCase(sponsorRepository, mockLogger);
});
beforeEach(() => {
// TODO: Clear all In-Memory repositories before each test
// sponsorRepository.clear();
// eventPublisher.clear();
sponsorRepository.clear();
});
describe('CreateSponsorUseCase - Success Path', () => {
it('should create a new sponsor account with valid information', async () => {
// TODO: Implement test
// Scenario: Sponsor creates account
// Given: No sponsor exists with the given email
const sponsorId = 'sponsor-123';
const sponsorData = {
name: 'Test Company',
contactEmail: 'test@example.com',
websiteUrl: 'https://testcompany.com',
logoUrl: 'https://testcompany.com/logo.png',
};
// When: CreateSponsorUseCase.execute() is called with valid sponsor data
// Then: The sponsor should be created in the repository
const result = await createSponsorUseCase.execute(sponsorData);
// Then: The sponsor should be created successfully
expect(result.isOk()).toBe(true);
const createdSponsor = result.unwrap().sponsor;
// And: The sponsor should have a unique ID
expect(createdSponsor.id.toString()).toBeDefined();
// And: The sponsor should have the provided company name
expect(createdSponsor.name.toString()).toBe('Test Company');
// And: The sponsor should have the provided contact email
expect(createdSponsor.contactEmail.toString()).toBe('test@example.com');
// And: The sponsor should have the provided website URL
// And: The sponsor should have the provided sponsorship interests
expect(createdSponsor.websiteUrl?.toString()).toBe('https://testcompany.com');
// And: The sponsor should have the provided logo URL
expect(createdSponsor.logoUrl?.toString()).toBe('https://testcompany.com/logo.png');
// And: The sponsor should have a created timestamp
// And: EventPublisher should emit SponsorCreatedEvent
expect(createdSponsor.createdAt).toBeDefined();
// And: The sponsor should be retrievable from the repository
const retrievedSponsor = await sponsorRepository.findById(createdSponsor.id.toString());
expect(retrievedSponsor).toBeDefined();
expect(retrievedSponsor?.name.toString()).toBe('Test Company');
});
it('should create a sponsor with multiple sponsorship interests', async () => {
// TODO: Implement test
// Scenario: Sponsor creates account with multiple interests
// Given: No sponsor exists with the given email
// When: CreateSponsorUseCase.execute() is called with multiple sponsorship interests
// Then: The sponsor should be created with all selected interests
// And: Each interest should be stored correctly
// And: EventPublisher should emit SponsorCreatedEvent
it('should create a sponsor with minimal data', async () => {
// Given: No sponsor exists
const sponsorData = {
name: 'Minimal Company',
contactEmail: 'minimal@example.com',
};
// When: CreateSponsorUseCase.execute() is called with minimal data
const result = await createSponsorUseCase.execute(sponsorData);
// Then: The sponsor should be created successfully
expect(result.isOk()).toBe(true);
const createdSponsor = result.unwrap().sponsor;
// And: The sponsor should have the provided company name
expect(createdSponsor.name.toString()).toBe('Minimal Company');
// And: The sponsor should have the provided contact email
expect(createdSponsor.contactEmail.toString()).toBe('minimal@example.com');
// And: Optional fields should be undefined
expect(createdSponsor.websiteUrl).toBeUndefined();
expect(createdSponsor.logoUrl).toBeUndefined();
});
it('should create a sponsor with optional company logo', async () => {
// TODO: Implement test
// Scenario: Sponsor creates account with logo
// Given: No sponsor exists with the given email
// When: CreateSponsorUseCase.execute() is called with a company logo
// Then: The sponsor should be created with the logo reference
// And: The logo should be stored in the media repository
// And: EventPublisher should emit SponsorCreatedEvent
});
it('should create a sponsor with optional fields only', async () => {
// Given: No sponsor exists
const sponsorData = {
name: 'Optional Fields Company',
contactEmail: 'optional@example.com',
websiteUrl: 'https://optional.com',
};
it('should create a sponsor with default settings', async () => {
// TODO: Implement test
// Scenario: Sponsor creates account with default settings
// Given: No sponsor exists with the given email
// When: CreateSponsorUseCase.execute() is called
// Then: The sponsor should be created with default notification preferences
// And: The sponsor should be created with default privacy settings
// And: EventPublisher should emit SponsorCreatedEvent
// When: CreateSponsorUseCase.execute() is called with optional fields
const result = await createSponsorUseCase.execute(sponsorData);
// Then: The sponsor should be created successfully
expect(result.isOk()).toBe(true);
const createdSponsor = result.unwrap().sponsor;
// And: The sponsor should have the provided website URL
expect(createdSponsor.websiteUrl?.toString()).toBe('https://optional.com');
// And: Logo URL should be undefined
expect(createdSponsor.logoUrl).toBeUndefined();
});
});
describe('CreateSponsorUseCase - Validation', () => {
it('should reject sponsor creation with duplicate email', async () => {
// TODO: Implement test
// Scenario: Duplicate email
// Given: A sponsor exists with email "sponsor@example.com"
const existingSponsor = Sponsor.create({
id: 'existing-sponsor',
name: 'Existing Company',
contactEmail: 'sponsor@example.com',
});
await sponsorRepository.create(existingSponsor);
// When: CreateSponsorUseCase.execute() is called with the same email
// Then: Should throw DuplicateEmailError
// And: EventPublisher should NOT emit any events
const result = await createSponsorUseCase.execute({
name: 'New Company',
contactEmail: 'sponsor@example.com',
});
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('REPOSITORY_ERROR');
});
it('should reject sponsor creation with invalid email format', async () => {
// TODO: Implement test
// Scenario: Invalid email format
// Given: No sponsor exists
// When: CreateSponsorUseCase.execute() is called with invalid email
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
const result = await createSponsorUseCase.execute({
name: 'Test Company',
contactEmail: 'invalid-email',
});
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('VALIDATION_ERROR');
expect(error.details.message).toContain('Invalid sponsor contact email format');
});
it('should reject sponsor creation with missing required fields', async () => {
// TODO: Implement test
// Scenario: Missing required fields
// Given: No sponsor exists
// When: CreateSponsorUseCase.execute() is called without company name
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
const result = await createSponsorUseCase.execute({
name: '',
contactEmail: 'test@example.com',
});
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('VALIDATION_ERROR');
expect(error.details.message).toContain('Sponsor name is required');
});
it('should reject sponsor creation with invalid website URL', async () => {
// TODO: Implement test
// Scenario: Invalid website URL
// Given: No sponsor exists
// When: CreateSponsorUseCase.execute() is called with invalid URL
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
const result = await createSponsorUseCase.execute({
name: 'Test Company',
contactEmail: 'test@example.com',
websiteUrl: 'not-a-valid-url',
});
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('VALIDATION_ERROR');
expect(error.details.message).toContain('Invalid sponsor website URL');
});
it('should reject sponsor creation with invalid password', async () => {
// TODO: Implement test
// Scenario: Invalid password
it('should reject sponsor creation with missing email', async () => {
// Given: No sponsor exists
// When: CreateSponsorUseCase.execute() is called with weak password
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
// When: CreateSponsorUseCase.execute() is called without email
const result = await createSponsorUseCase.execute({
name: 'Test Company',
contactEmail: '',
});
describe('SponsorLoginUseCase - Success Path', () => {
it('should authenticate sponsor with valid credentials', async () => {
// TODO: Implement test
// Scenario: Sponsor logs in
// Given: A sponsor exists with email "sponsor@example.com" and password "password123"
// When: SponsorLoginUseCase.execute() is called with valid credentials
// Then: The sponsor should be authenticated
// And: The sponsor should receive an authentication token
// And: EventPublisher should emit SponsorLoggedInEvent
});
it('should authenticate sponsor with correct email and password', async () => {
// TODO: Implement test
// Scenario: Sponsor logs in with correct credentials
// Given: A sponsor exists with specific credentials
// When: SponsorLoginUseCase.execute() is called with matching credentials
// Then: The sponsor should be authenticated
// And: EventPublisher should emit SponsorLoggedInEvent
});
});
describe('SponsorLoginUseCase - Error Handling', () => {
it('should reject login with non-existent email', async () => {
// TODO: Implement test
// Scenario: Non-existent sponsor
// Given: No sponsor exists with the given email
// When: SponsorLoginUseCase.execute() is called
// Then: Should throw SponsorNotFoundError
// And: EventPublisher should NOT emit any events
});
it('should reject login with incorrect password', async () => {
// TODO: Implement test
// Scenario: Incorrect password
// Given: A sponsor exists with email "sponsor@example.com"
// When: SponsorLoginUseCase.execute() is called with wrong password
// Then: Should throw InvalidCredentialsError
// And: EventPublisher should NOT emit any events
});
it('should reject login with invalid email format', async () => {
// TODO: Implement test
// Scenario: Invalid email format
// Given: No sponsor exists
// When: SponsorLoginUseCase.execute() is called with invalid email
// Then: Should throw ValidationError
// And: EventPublisher should NOT emit any events
});
});
describe('SponsorLogoutUseCase - Success Path', () => {
it('should log out authenticated sponsor', async () => {
// TODO: Implement test
// Scenario: Sponsor logs out
// Given: A sponsor is authenticated
// When: SponsorLogoutUseCase.execute() is called
// Then: The sponsor should be logged out
// And: EventPublisher should emit SponsorLoggedOutEvent
// Then: Should return an error
expect(result.isErr()).toBe(true);
const error = result.unwrapErr();
expect(error.code).toBe('VALIDATION_ERROR');
expect(error.details.message).toContain('Sponsor contact email is required');
});
});
describe('Sponsor Data Orchestration', () => {
it('should correctly create sponsor with sponsorship interests', async () => {
// TODO: Implement test
// Scenario: Sponsor with multiple interests
it('should correctly create sponsor with all optional fields', async () => {
// Given: No sponsor exists
// When: CreateSponsorUseCase.execute() is called with interests: ["League", "Team", "Driver"]
// Then: The sponsor should have all three interests stored
// And: Each interest should be retrievable
// And: EventPublisher should emit SponsorCreatedEvent
const sponsorData = {
name: 'Full Featured Company',
contactEmail: 'full@example.com',
websiteUrl: 'https://fullfeatured.com',
logoUrl: 'https://fullfeatured.com/logo.png',
};
// When: CreateSponsorUseCase.execute() is called with all fields
const result = await createSponsorUseCase.execute(sponsorData);
// Then: The sponsor should be created with all fields
expect(result.isOk()).toBe(true);
const createdSponsor = result.unwrap().sponsor;
expect(createdSponsor.name.toString()).toBe('Full Featured Company');
expect(createdSponsor.contactEmail.toString()).toBe('full@example.com');
expect(createdSponsor.websiteUrl?.toString()).toBe('https://fullfeatured.com');
expect(createdSponsor.logoUrl?.toString()).toBe('https://fullfeatured.com/logo.png');
expect(createdSponsor.createdAt).toBeDefined();
});
it('should correctly create sponsor with default notification preferences', async () => {
// TODO: Implement test
// Scenario: Sponsor with default notifications
// Given: No sponsor exists
// When: CreateSponsorUseCase.execute() is called
// Then: The sponsor should have default notification preferences
// And: All notification types should be enabled by default
// And: EventPublisher should emit SponsorCreatedEvent
it('should generate unique IDs for each sponsor', async () => {
// Given: No sponsors exist
const sponsorData1 = {
name: 'Company 1',
contactEmail: 'company1@example.com',
};
const sponsorData2 = {
name: 'Company 2',
contactEmail: 'company2@example.com',
};
// When: Creating two sponsors
const result1 = await createSponsorUseCase.execute(sponsorData1);
const result2 = await createSponsorUseCase.execute(sponsorData2);
// Then: Both should succeed and have unique IDs
expect(result1.isOk()).toBe(true);
expect(result2.isOk()).toBe(true);
const sponsor1 = result1.unwrap().sponsor;
const sponsor2 = result2.unwrap().sponsor;
expect(sponsor1.id.toString()).not.toBe(sponsor2.id.toString());
});
it('should correctly create sponsor with default privacy settings', async () => {
// TODO: Implement test
// Scenario: Sponsor with default privacy
it('should persist sponsor in repository after creation', async () => {
// Given: No sponsor exists
// When: CreateSponsorUseCase.execute() is called
// Then: The sponsor should have default privacy settings
// And: Public profile should be enabled by default
// And: EventPublisher should emit SponsorCreatedEvent
const sponsorData = {
name: 'Persistent Company',
contactEmail: 'persistent@example.com',
};
// When: Creating a sponsor
const result = await createSponsorUseCase.execute(sponsorData);
// Then: The sponsor should be retrievable from the repository
expect(result.isOk()).toBe(true);
const createdSponsor = result.unwrap().sponsor;
const retrievedSponsor = await sponsorRepository.findById(createdSponsor.id.toString());
expect(retrievedSponsor).toBeDefined();
expect(retrievedSponsor?.name.toString()).toBe('Persistent Company');
expect(retrievedSponsor?.contactEmail.toString()).toBe('persistent@example.com');
});
});
});