matcher/src/modules/ad/tests/integration/ad.repository.spec.ts

import {
  AD_DIRECTION_ENCODER,
  AD_MESSAGE_PUBLISHER,
  AD_REPOSITORY,
} from '@modules/ad/ad.di-tokens';
import { AdMapper } from '@modules/ad/ad.mapper';
import { AdEntity } from '@modules/ad/core/domain/ad.entity';
import { CreateAdProps, Frequency } from '@modules/ad/core/domain/ad.types';
import { AdRepository } from '@modules/ad/infrastructure/ad.repository';
import { PrismaService } from '@modules/ad/infrastructure/prisma.service';
import { PostgresDirectionEncoder } from '@modules/geography/infrastructure/postgres-direction-encoder';
import { ConfigModule } from '@nestjs/config';
import { EventEmitterModule } from '@nestjs/event-emitter';
import { Test } from '@nestjs/testing';

describe('Ad Repository', () => {
  let prismaService: PrismaService;
  let adRepository: AdRepository;

  const mockMessagePublisher = {
    publish: jest.fn().mockImplementation(),
  };

  const mockLogger = {
    log: jest.fn(),
    warn: jest.fn(),
    error: jest.fn(),
  };

  beforeAll(async () => {
    const module = await Test.createTestingModule({
      imports: [
        EventEmitterModule.forRoot(),
        ConfigModule.forRoot({ isGlobal: true }),
      ],
      providers: [
        PrismaService,
        AdMapper,
        {
          provide: AD_REPOSITORY,
          useClass: AdRepository,
        },
        {
          provide: AD_MESSAGE_PUBLISHER,
          useValue: mockMessagePublisher,
        },
        {
          provide: AD_DIRECTION_ENCODER,
          useClass: PostgresDirectionEncoder,
        },
      ],
    })
      // disable logging
      .setLogger(mockLogger)
      .compile();

    prismaService = module.get<PrismaService>(PrismaService);
    adRepository = module.get<AdRepository>(AD_REPOSITORY);
  });

  afterAll(async () => {
    await prismaService.$disconnect();
  });

  beforeEach(async () => {
    await prismaService.ad.deleteMany();
  });

  describe('create', () => {
    it('should create a punctual ad', async () => {
      const beforeCount = await prismaService.ad.count();

      const createAdProps: CreateAdProps = {
        id: 'b4b56444-f8d3-4110-917c-e37bba77f383',
        driver: true,
        passenger: false,
        frequency: Frequency.PUNCTUAL,
        fromDate: '2023-02-01',
        toDate: '2023-02-01',
        schedule: [
          {
            day: 3,
            time: '12:05',
            margin: 900,
          },
        ],
        seatsProposed: 3,
        seatsRequested: 1,
        strict: false,
        waypoints: [
          {
            lon: 43.7102,
            lat: 7.262,
          },
          {
            lon: 43.2965,
            lat: 5.3698,
          },
        ],
        points: [
          {
            lon: 7.262,
            lat: 43.7102,
          },
          {
            lon: 6.797838,
            lat: 43.547031,
          },
          {
            lon: 6.18535,
            lat: 43.407517,
          },
          {
            lon: 5.3698,
            lat: 43.2965,
          },
        ],
        driverDuration: 7668,
        driverDistance: 199000,
        passengerDuration: 7668,
        passengerDistance: 199000,
        fwdAzimuth: 273,
        backAzimuth: 93,
      };

      const adToCreate: AdEntity = AdEntity.create(createAdProps);
      await adRepository.insertExtra(adToCreate, 'ad');

      const afterCount = await prismaService.ad.count();

      expect(afterCount - beforeCount).toBe(1);
    });

    it('should create a recurrent ad', async () => {
      const beforeCount = await prismaService.ad.count();

      const createAdProps: CreateAdProps = {
        id: 'b4b56444-f8d3-4110-917c-e37bba77f383',
        driver: true,
        passenger: false,
        frequency: Frequency.RECURRENT,
        fromDate: '2023-02-01',
        toDate: '2024-01-31',
        schedule: [
          {
            day: 1,
            time: '08:00',
            margin: 900,
          },
          {
            day: 2,
            time: '08:00',
            margin: 900,
          },
          {
            day: 3,
            time: '09:00',
            margin: 900,
          },
          {
            day: 4,
            time: '08:00',
            margin: 900,
          },
          {
            day: 5,
            time: '08:00',
            margin: 900,
          },
        ],
        seatsProposed: 3,
        seatsRequested: 1,
        strict: false,
        waypoints: [
          {
            lon: 43.7102,
            lat: 7.262,
          },
          {
            lon: 43.2965,
            lat: 5.3698,
          },
        ],
        points: [
          {
            lon: 7.262,
            lat: 43.7102,
          },
          {
            lon: 6.797838,
            lat: 43.547031,
          },
          {
            lon: 6.18535,
            lat: 43.407517,
          },
          {
            lon: 5.3698,
            lat: 43.2965,
          },
        ],
        driverDuration: 7668,
        driverDistance: 199000,
        passengerDuration: 7668,
        passengerDistance: 199000,
        fwdAzimuth: 273,
        backAzimuth: 93,
      };

      const adToCreate: AdEntity = AdEntity.create(createAdProps);
      await adRepository.insertExtra(adToCreate, 'ad');

      const afterCount = await prismaService.ad.count();

      expect(afterCount - beforeCount).toBe(1);
    });
  });
});