euchre_camp/src/__tests__/unit/tournament-update.test.ts

/**
 * Unit tests for tournament update functionality
 * Tests the allowTies field is properly saved when updating tournaments
 */

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { prisma } from '@/lib/prisma';

// Mock the prisma client
vi.mock('@/lib/prisma', () => ({
  prisma: {
    event: {
      findUnique: vi.fn(),
      update: vi.fn(),
    },
  },
}));

// Mock the permissions module
vi.mock('@/lib/permissions', () => ({
  canManageTournament: vi.fn().mockResolvedValue({ allowed: true }),
  canDeleteTournament: vi.fn().mockResolvedValue({ allowed: true }),
}));

// Import the route handler after mocking
import { PUT } from '@/app/api/tournaments/[id]/route';

describe('Tournament Update API', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('should update allowTies field when provided', async () => {
    // Mock existing tournament
    vi.mocked(prisma.event.findUnique).mockResolvedValue({
      id: 1,
      name: 'Test Tournament',
      allowTies: false,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
    } as any);

    // Mock successful update
    vi.mocked(prisma.event.update).mockResolvedValue({
      id: 1,
      name: 'Test Tournament',
      allowTies: true,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
    } as any);

    const request = new Request('http://localhost/api/tournaments/1', {
      method: 'PUT',
      body: JSON.stringify({
        name: 'Test Tournament',
        allowTies: true,
        targetScore: 5,
      }),
    });

    const params = Promise.resolve({ id: '1' });
    const response = await PUT(request, { params });

    expect(response.status).toBe(200);
    expect(vi.mocked(prisma.event.update)).toHaveBeenCalledWith(
      expect.objectContaining({
        data: expect.objectContaining({
          allowTies: true,
        }),
      })
    );
  });

  it('should default allowTies to false when not provided', async () => {
    // Mock existing tournament
    vi.mocked(prisma.event.findUnique).mockResolvedValue({
      id: 1,
      name: 'Test Tournament',
      allowTies: true,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
    } as any);

    // Mock successful update
    vi.mocked(prisma.event.update).mockResolvedValue({
      id: 1,
      name: 'Test Tournament',
      allowTies: false,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
    } as any);

    const request = new Request('http://localhost/api/tournaments/1', {
      method: 'PUT',
      body: JSON.stringify({
        name: 'Test Tournament',
        targetScore: 5,
        // allowTies not provided
      }),
    });

    const params = Promise.resolve({ id: '1' });
    const response = await PUT(request, { params });

    expect(response.status).toBe(200);
    expect(vi.mocked(prisma.event.update)).toHaveBeenCalledWith(
      expect.objectContaining({
        data: expect.objectContaining({
          allowTies: false, // Should default to false
        }),
      })
    );
  });

  it('should preserve allowTies value when updating other fields', async () => {
    // Mock existing tournament with allowTies = true
    vi.mocked(prisma.event.findUnique).mockResolvedValue({
      id: 1,
      name: 'Test Tournament',
      allowTies: true,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
    } as any);

    // Mock successful update
    vi.mocked(prisma.event.update).mockResolvedValue({
      id: 1,
      name: 'Updated Tournament Name',
      allowTies: true,
      targetScore: 10,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
    } as any);

    const request = new Request('http://localhost/api/tournaments/1', {
      method: 'PUT',
      body: JSON.stringify({
        name: 'Updated Tournament Name',
        allowTies: true,
        targetScore: 10,
      }),
    });

    const params = Promise.resolve({ id: '1' });
    const response = await PUT(request, { params });

    expect(response.status).toBe(200);
    const updateCall = vi.mocked(prisma.event.update).mock.calls[0][0];
    expect(updateCall.data.allowTies).toBe(true);
    expect(updateCall.data.name).toBe('Updated Tournament Name');
    expect(updateCall.data.targetScore).toBe(10);
  });
});