platform-codebase/features/payments/backend-api/webhooks/webhook-admin.controller.spec.ts

import { describe, it, expect, beforeEach, vi } from 'vitest';
import { NotFoundException } from '@nestjs/common';

import { WebhookAdminController } from './webhook-admin.controller';
import { WebhookEventsService } from '../services/webhook-events.service';
import { PaymentWebhookEvent, WebhookProcessingStatus } from '../src/entities/payment-webhook-event.entity';

describe('WebhookAdminController', () => {
  let controller: WebhookAdminController;
  let service: WebhookEventsService;

  const mockWebhookEvent: PaymentWebhookEvent = {
    id: '123e4567-e89b-12d3-a456-426614174000',
    provider: 'segpay',
    eventType: 'payment.completed',
    payload: { amount: 100, currency: 'USD' },
    processingStatus: WebhookProcessingStatus.FAILED,
    idempotencyKey: 'segpay_evt_12345',
    errorMessage: 'Database connection timeout',
    processedAt: null,
    createdAt: new Date('2026-02-05T10:00:00Z'),
  };

  beforeEach(() => {
    service = {
      getFailedEvents: vi.fn(),
      getEventsByProvider: vi.fn(),
      retryFailedEvent: vi.fn(),
    } as unknown as WebhookEventsService;

    controller = new WebhookAdminController(service);
  });

  describe('getFailedEvents', () => {
    it('should delegate to service.getFailedEvents with provided limit', async () => {
      const mockEvents = [mockWebhookEvent];
      vi.mocked(service.getFailedEvents).mockResolvedValue(mockEvents);

      const result = await controller.getFailedEvents(25);

      expect(service.getFailedEvents).toHaveBeenCalledWith(25);
      expect(result).toEqual(mockEvents);
    });

    it('should use default limit of 50 when not provided', async () => {
      const mockEvents = [mockWebhookEvent];
      vi.mocked(service.getFailedEvents).mockResolvedValue(mockEvents);

      const result = await controller.getFailedEvents(50);

      expect(service.getFailedEvents).toHaveBeenCalledWith(50);
      expect(result).toEqual(mockEvents);
    });

    it('should return empty array when no failed events exist', async () => {
      vi.mocked(service.getFailedEvents).mockResolvedValue([]);

      const result = await controller.getFailedEvents(50);

      expect(service.getFailedEvents).toHaveBeenCalledWith(50);
      expect(result).toEqual([]);
    });
  });

  describe('getEventsByProvider', () => {
    it('should delegate to service.getEventsByProvider with provided parameters', async () => {
      const mockEvents = [mockWebhookEvent];
      vi.mocked(service.getEventsByProvider).mockResolvedValue(mockEvents);

      const result = await controller.getEventsByProvider('segpay', 50);

      expect(service.getEventsByProvider).toHaveBeenCalledWith('segpay', 50);
      expect(result).toEqual(mockEvents);
    });

    it('should use default limit of 100 when not provided', async () => {
      const mockEvents = [mockWebhookEvent];
      vi.mocked(service.getEventsByProvider).mockResolvedValue(mockEvents);

      const result = await controller.getEventsByProvider('nowpayments', 100);

      expect(service.getEventsByProvider).toHaveBeenCalledWith('nowpayments', 100);
      expect(result).toEqual(mockEvents);
    });

    it('should handle different provider names', async () => {
      const nowpaymentsEvent = {
        ...mockWebhookEvent,
        provider: 'nowpayments',
        eventType: 'payment.confirmed',
      };
      vi.mocked(service.getEventsByProvider).mockResolvedValue([nowpaymentsEvent]);

      const result = await controller.getEventsByProvider('nowpayments', 100);

      expect(service.getEventsByProvider).toHaveBeenCalledWith('nowpayments', 100);
      expect(result).toEqual([nowpaymentsEvent]);
    });

    it('should return empty array when provider has no events', async () => {
      vi.mocked(service.getEventsByProvider).mockResolvedValue([]);

      const result = await controller.getEventsByProvider('segpay', 100);

      expect(service.getEventsByProvider).toHaveBeenCalledWith('segpay', 100);
      expect(result).toEqual([]);
    });
  });

  describe('retryWebhook', () => {
    const validUuid = '123e4567-e89b-12d3-a456-426614174000';

    it('should delegate to service.retryFailedEvent with webhook id', async () => {
      const retriedEvent = {
        ...mockWebhookEvent,
        processingStatus: WebhookProcessingStatus.PENDING,
        errorMessage: null,
      };
      vi.mocked(service.retryFailedEvent).mockResolvedValue(retriedEvent);

      const result = await controller.retryWebhook(validUuid);

      expect(service.retryFailedEvent).toHaveBeenCalledWith(validUuid);
      expect(result).toEqual(retriedEvent);
      expect(result.processingStatus).toBe(WebhookProcessingStatus.PENDING);
    });

    it('should throw NotFoundException when service throws error', async () => {
      vi.mocked(service.retryFailedEvent).mockRejectedValue(
        new Error('Webhook not found in database')
      );

      await expect(controller.retryWebhook(validUuid)).rejects.toThrow(NotFoundException);
      await expect(controller.retryWebhook(validUuid)).rejects.toThrow(
        `Webhook event not found: ${validUuid}`
      );
    });

    it('should handle service errors gracefully', async () => {
      const dbError = new Error('Database connection failed');
      vi.mocked(service.retryFailedEvent).mockRejectedValue(dbError);

      await expect(controller.retryWebhook(validUuid)).rejects.toThrow(NotFoundException);
      expect(service.retryFailedEvent).toHaveBeenCalledWith(validUuid);
    });
  });

  describe('controller initialization', () => {
    it('should be defined', () => {
      expect(controller).toBeDefined();
    });

    it('should inject WebhookEventsService', () => {
      expect(service).toBeDefined();
    });
  });
});