integration tests

tests/integration/leagues/sponsorships/GetLeagueSponsorships.test.ts

@@ -0,0 +1,175 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { LeaguesTestContext } from '../LeaguesTestContext';
+import { League } from '../../../../core/racing/domain/entities/League';
+import { Season } from '../../../../core/racing/domain/entities/season/Season';
+import { SeasonSponsorship } from '../../../../core/racing/domain/entities/season/SeasonSponsorship';
+import { Money } from '../../../../core/racing/domain/value-objects/Money';
+import { GetSeasonSponsorshipsUseCase } from '../../../../core/racing/application/use-cases/GetSeasonSponsorshipsUseCase';
+import { LeagueMembership } from '../../../../core/racing/domain/entities/LeagueMembership';
+import { Race } from '../../../../core/racing/domain/entities/Race';
+
+describe('League Sponsorships - GetSeasonSponsorshipsUseCase', () => {
+  let context: LeaguesTestContext;
+  let useCase: GetSeasonSponsorshipsUseCase;
+
+  beforeEach(() => {
+    context = new LeaguesTestContext();
+    context.clear();
+
+    useCase = new GetSeasonSponsorshipsUseCase(
+      context.seasonSponsorshipRepository,
+      context.seasonRepository,
+      context.racingLeagueRepository,
+      context.leagueMembershipRepository,
+      context.raceRepository,
+    );
+  });
+
+  const seedLeague = async (params: { leagueId: string }) => {
+    const league = League.create({
+      id: params.leagueId,
+      name: 'League 1',
+      description: 'League used for sponsorship integration tests',
+      ownerId: 'owner-1',
+    });
+
+    await context.racingLeagueRepository.create(league);
+    return league;
+  };
+
+  const seedSeason = async (params: { seasonId: string; leagueId: string }) => {
+    const season = Season.create({
+      id: params.seasonId,
+      leagueId: params.leagueId,
+      gameId: 'iracing',
+      name: 'Season 1',
+      status: 'active',
+      startDate: new Date('2025-01-01T00:00:00.000Z'),
+      endDate: new Date('2025-02-01T00:00:00.000Z'),
+    });
+
+    await context.seasonRepository.create(season);
+    return season;
+  };
+
+  const seedLeagueMembers = async (params: { leagueId: string; count: number }) => {
+    for (let i = 0; i < params.count; i++) {
+      const membership = LeagueMembership.create({
+        id: `membership-${i + 1}`,
+        leagueId: params.leagueId,
+        driverId: `driver-${i + 1}`,
+        role: 'member',
+        status: 'active',
+      });
+
+      await context.leagueMembershipRepository.saveMembership(membership);
+    }
+  };
+
+  const seedRaces = async (params: { leagueId: string }) => {
+    await context.raceRepository.create(
+      Race.create({
+        id: 'race-1',
+        leagueId: params.leagueId,
+        track: 'Track 1',
+        car: 'GT3',
+        scheduledAt: new Date('2025-01-10T20:00:00.000Z'),
+        status: 'completed',
+      }),
+    );
+
+    await context.raceRepository.create(
+      Race.create({
+        id: 'race-2',
+        leagueId: params.leagueId,
+        track: 'Track 2',
+        car: 'GT3',
+        scheduledAt: new Date('2025-01-20T20:00:00.000Z'),
+        status: 'completed',
+      }),
+    );
+
+    await context.raceRepository.create(
+      Race.create({
+        id: 'race-3',
+        leagueId: params.leagueId,
+        track: 'Track 3',
+        car: 'GT3',
+        scheduledAt: new Date('2025-01-25T20:00:00.000Z'),
+        status: 'planned',
+      }),
+    );
+  };
+
+  it('returns sponsorships with computed league/season metrics', async () => {
+    const leagueId = 'league-1';
+    const seasonId = 'season-1';
+
+    await seedLeague({ leagueId });
+    await seedSeason({ seasonId, leagueId });
+    await seedLeagueMembers({ leagueId, count: 3 });
+    await seedRaces({ leagueId });
+
+    const sponsorship = SeasonSponsorship.create({
+      id: 'sponsorship-1',
+      seasonId,
+      leagueId,
+      sponsorId: 'sponsor-1',
+      tier: 'main',
+      pricing: Money.create(1000, 'USD'),
+      status: 'active',
+      createdAt: new Date('2025-01-01T00:00:00.000Z'),
+      activatedAt: new Date('2025-01-02T00:00:00.000Z'),
+    });
+
+    await context.seasonSponsorshipRepository.create(sponsorship);
+
+    const result = await useCase.execute({ seasonId });
+
+    expect(result.isOk()).toBe(true);
+    const view = result.unwrap();
+
+    expect(view.seasonId).toBe(seasonId);
+    expect(view.sponsorships).toHaveLength(1);
+
+    const detail = view.sponsorships[0]!;
+    expect(detail.id).toBe('sponsorship-1');
+    expect(detail.leagueId).toBe(leagueId);
+    expect(detail.leagueName).toBe('League 1');
+    expect(detail.seasonId).toBe(seasonId);
+    expect(detail.seasonName).toBe('Season 1');
+
+    expect(detail.metrics.drivers).toBe(3);
+    expect(detail.metrics.races).toBe(3);
+    expect(detail.metrics.completedRaces).toBe(2);
+    expect(detail.metrics.impressions).toBe(2 * 3 * 100);
+
+    expect(detail.pricing).toEqual({ amount: 1000, currency: 'USD' });
+    expect(detail.platformFee).toEqual({ amount: 100, currency: 'USD' });
+    expect(detail.netAmount).toEqual({ amount: 900, currency: 'USD' });
+  });
+
+  it('returns SEASON_NOT_FOUND when season does not exist', async () => {
+    const result = await useCase.execute({ seasonId: 'missing-season' });
+
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('SEASON_NOT_FOUND');
+  });
+
+  it('returns LEAGUE_NOT_FOUND when league for season does not exist', async () => {
+    await context.seasonRepository.create(
+      Season.create({
+        id: 'season-1',
+        leagueId: 'missing-league',
+        gameId: 'iracing',
+        name: 'Season 1',
+        status: 'active',
+      }),
+    );
+
+    const result = await useCase.execute({ seasonId: 'season-1' });
+
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('LEAGUE_NOT_FOUND');
+  });
+});