gridpilot.gg/tests/integration/database/constraints/unique-constraints.integration.test.ts

import { describe, it, expect, beforeEach } from 'vitest';
import { DatabaseTestContext, DriverData } from '../DatabaseTestContext';

describe('Database Constraints - Unique Constraint Violations', () => {
  let context: DatabaseTestContext;

  beforeEach(() => {
    context = DatabaseTestContext.create();
  });

  it('should handle duplicate team creation gracefully', async () => {
    // Given: A driver exists
    const driver: DriverData = {
      id: 'driver-123',
      iracingId: '12345',
      name: 'Test Driver',
      country: 'US',
      joinedAt: new Date(),
    };
    await context.driverRepository.create(driver);

    // And: A team is created successfully
    const teamResult1 = await context.createTeamUseCase.execute({
      name: 'Test Team',
      tag: 'TT',
      description: 'A test team',
      ownerId: driver.id,
      leagues: [],
    });
    expect(teamResult1.isOk()).toBe(true);

    // When: Attempt to create the same team again (same name/tag)
    const teamResult2 = await context.createTeamUseCase.execute({
      name: 'Test Team',
      tag: 'TT',
      description: 'Another test team',
      ownerId: driver.id,
      leagues: [],
    });

    // Then: Should fail with appropriate error
    expect(teamResult2.isErr()).toBe(true);
    if (teamResult2.isErr()) {
      expect(teamResult2.error.code).toBe('VALIDATION_ERROR');
    }
  });

  it('should handle duplicate membership gracefully', async () => {
    // Given: A driver and team exist
    const driver: DriverData = {
      id: 'driver-123',
      iracingId: '12345',
      name: 'Test Driver',
      country: 'US',
      joinedAt: new Date(),
    };
    await context.driverRepository.create(driver);

    const team = {
      id: 'team-123',
      name: 'Test Team',
      tag: 'TT',
      description: 'A test team',
      ownerId: 'other-driver',
      leagues: [],
      isRecruiting: false,
      createdAt: new Date(),
    };
    await context.teamRepository.create(team);

    // And: Driver joins the team successfully
    const joinResult1 = await context.joinTeamUseCase.execute({
      teamId: team.id,
      driverId: driver.id,
    });
    expect(joinResult1.isOk()).toBe(true);

    // When: Driver attempts to join the same team again
    const joinResult2 = await context.joinTeamUseCase.execute({
      teamId: team.id,
      driverId: driver.id,
    });

    // Then: Should fail with appropriate error
    expect(joinResult2.isErr()).toBe(true);
    if (joinResult2.isErr()) {
      expect(joinResult2.error.code).toBe('ALREADY_MEMBER');
    }
  });
});