import { AuditLogService } from './audit-log.service';
import { PrismaService } from '../prisma/prisma.service';

describe('AuditLogService', () => {
  let service: AuditLogService;
  let prisma: {
    auditLog: { create: jest.Mock; findMany: jest.Mock };
  };

  beforeEach(() => {
    prisma = {
      auditLog: {
        create: jest.fn(),
        findMany: jest.fn().mockResolvedValue([]),
      },
    };
    service = new AuditLogService(prisma as unknown as PrismaService);
  });

  it('record writes the entity type, action, and actor', async () => {
    await service.record({
      entityType: 'Colony',
      entityId: 'colony-1',
      action: 'CREATE',
      userId: 'user-1',
    });

    const [[createArg]] = prisma.auditLog.create.mock.calls as [
      [
        {
          data: {
            entityType: string;
            entityId: string;
            action: string;
            userId?: string;
          };
        },
      ],
    ];
    expect(createArg.data.entityType).toBe('Colony');
    expect(createArg.data.entityId).toBe('colony-1');
    expect(createArg.data.action).toBe('CREATE');
    expect(createArg.data.userId).toBe('user-1');
  });

  it('writes through the transaction client when one is given', async () => {
    const tx = { auditLog: { create: jest.fn() } };

    await service.record(
      { entityType: 'Inspection', entityId: 'i1', action: 'CREATE' },
      tx as never,
    );

    expect(tx.auditLog.create).toHaveBeenCalledTimes(1);
    expect(prisma.auditLog.create).not.toHaveBeenCalled();
  });

  it('findAll filters by entity type and id', async () => {
    await service.findAll({ entityType: 'Colony', entityId: 'colony-1' });

    const [[queryArg]] = prisma.auditLog.findMany.mock.calls as [
      [{ where: { entityType?: string; entityId?: string } }],
    ];
    expect(queryArg.where.entityType).toBe('Colony');
    expect(queryArg.where.entityId).toBe('colony-1');
  });
});