gridpilot.gg/tests/integration/database/integrity/data-integrity.integration.test.ts

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

describe('Database Constraints - Data Integrity After Failed Operations', () => {
  let context: DatabaseTestContext;

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

  it('should maintain repository state after constraint violations', 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 valid team is created
    const validTeamResult = await context.createTeamUseCase.execute({
      name: 'Valid Team',
      tag: 'VT',
      description: 'Valid team',
      ownerId: driver.id,
      leagues: [],
    });
    expect(validTeamResult.isOk()).toBe(true);

    // When: Attempt to create duplicate team (should fail)
    const duplicateResult = await context.createTeamUseCase.execute({
      name: 'Valid Team',
      tag: 'VT',
      description: 'Duplicate team',
      ownerId: driver.id,
      leagues: [],
    });
    expect(duplicateResult.isErr()).toBe(true);

    // Then: Original team should still exist and be retrievable
    const teams = await context.teamRepository.findAll();
    expect(teams.length).toBe(1);
    expect(teams[0].name).toBe('Valid Team');
  });

  it('should handle multiple failed operations without corruption', 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);

    // When: Multiple failed operations occur
    await context.joinTeamUseCase.execute({ teamId: 'non-existent', driverId: driver.id });
    await context.joinTeamUseCase.execute({ teamId: team.id, driverId: 'non-existent' });
    await context.createTeamUseCase.execute({ name: 'Test Team', tag: 'TT', description: 'Duplicate', ownerId: driver.id, leagues: [] });

    // Then: Repositories should remain in valid state
    const drivers = await context.driverRepository.findById(driver.id);
    const teams = await context.teamRepository.findAll();
    const membership = await context.teamMembershipRepository.getMembership(team.id, driver.id);

    expect(drivers).not.toBeNull();
    expect(teams.length).toBe(1);
    expect(membership).toBeNull(); // No successful joins
  });
});