gridpilot.gg/tests/integration/sponsor/campaigns/sponsor-campaigns.test.ts

import { describe, it, expect, beforeEach } from 'vitest';
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 { SponsorTestContext } from '../SponsorTestContext';

describe('Sponsor Campaigns Use Case Orchestration', () => {
  let context: SponsorTestContext;
  let getSponsorSponsorshipsUseCase: GetSponsorSponsorshipsUseCase;

  beforeEach(() => {
    context = new SponsorTestContext();
    getSponsorSponsorshipsUseCase = new GetSponsorSponsorshipsUseCase(
      context.sponsorRepository,
      context.seasonSponsorshipRepository,
      context.seasonRepository,
      context.leagueRepository,
      context.leagueMembershipRepository,
      context.raceRepository,
    );
  });

  describe('GetSponsorSponsorshipsUseCase - Success Path', () => {
    it('should retrieve all sponsorships for a sponsor', async () => {
      const sponsor = Sponsor.create({
        id: 'sponsor-123',
        name: 'Test Company',
        contactEmail: 'test@example.com',
      });
      await context.sponsorRepository.create(sponsor);

      const league1 = League.create({
        id: 'league-1',
        name: 'League 1',
        description: 'Description 1',
        ownerId: 'owner-1',
      });
      await context.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 context.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 context.seasonSponsorshipRepository.create(sponsorship1);

      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 context.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 context.raceRepository.create(race);
      }

      const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });

      expect(result.isOk()).toBe(true);
      const sponsorships = result.unwrap();

      expect(sponsorships.sponsor.name.toString()).toBe('Test Company');
      expect(sponsorships.sponsorships).toHaveLength(1);
      expect(sponsorships.summary.totalSponsorships).toBe(1);
      expect(sponsorships.summary.activeSponsorships).toBe(1);
      expect(sponsorships.summary.totalInvestment.amount).toBe(1000);
      
      const s1 = sponsorships.sponsorships[0];
      expect(s1.metrics.drivers).toBe(10);
      expect(s1.metrics.races).toBe(5);
      expect(s1.metrics.impressions).toBe(5000);
    });

    it('should retrieve sponsorships with empty result when no sponsorships exist', async () => {
      const sponsor = Sponsor.create({
        id: 'sponsor-123',
        name: 'Test Company',
        contactEmail: 'test@example.com',
      });
      await context.sponsorRepository.create(sponsor);

      const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'sponsor-123' });

      expect(result.isOk()).toBe(true);
      const sponsorships = result.unwrap();
      expect(sponsorships.sponsorships).toHaveLength(0);
      expect(sponsorships.summary.totalSponsorships).toBe(0);
    });
  });

  describe('GetSponsorSponsorshipsUseCase - Error Handling', () => {
    it('should return error when sponsor does not exist', async () => {
      const result = await getSponsorSponsorshipsUseCase.execute({ sponsorId: 'non-existent-sponsor' });

      expect(result.isErr()).toBe(true);
      const error = result.unwrapErr();
      expect(error.code).toBe('SPONSOR_NOT_FOUND');
    });
  });
});