refactor to ddh, first commit

old/modules/ad/tests/integration/ad.repository.spec.ts

@@ -0,0 +1,402 @@
+import { TestingModule, Test } from '@nestjs/testing';
+import { DatabaseModule } from '../../../database/database.module';
+import { PrismaService } from '../../../database/adapters/secondaries/prisma.service';
+import { AdRepository } from '../../adapters/secondaries/ad.repository';
+import { Ad } from '../../domain/entities/ad';
+import { Frequency } from '../../domain/types/frequency.enum';
+
+describe('AdRepository', () => {
+  let prismaService: PrismaService;
+  let adRepository: AdRepository;
+
+  const baseUuid = {
+    uuid: 'be459a29-7a41-4c0b-b371-abe90bfb6f00',
+  };
+  const baseUserUuid = {
+    userUuid: '4e52b54d-a729-4dbd-9283-f84a11bb2200',
+  };
+  const driverAd = {
+    driver: 'true',
+    passenger: 'false',
+    fwdAzimuth: 0,
+    backAzimuth: 180,
+    waypoints: "'LINESTRING(6 47,6.1 47.1,6.2 47.2)'",
+    direction: "'LINESTRING(6 47,6.05 47.05,6.1 47.1,6.15 47.15,6.2 47.2)'",
+    seatsDriver: 3,
+    seatsPassenger: 1,
+    seatsUsed: 0,
+    strict: 'false',
+  };
+  const passengerAd = {
+    driver: 'false',
+    passenger: 'true',
+    fwdAzimuth: 0,
+    backAzimuth: 180,
+    waypoints: "'LINESTRING(6 47,6.2 47.2)'",
+    direction: "'LINESTRING(6 47,6.05 47.05,6.15 47.15,6.2 47.2)'",
+    seatsDriver: 3,
+    seatsPassenger: 1,
+    seatsUsed: 0,
+    strict: 'false',
+  };
+  const driverAndPassengerAd = {
+    driver: 'true',
+    passenger: 'true',
+    fwdAzimuth: 0,
+    backAzimuth: 180,
+    waypoints: "'LINESTRING(6 47,6.1 47.1,6.2 47.2)'",
+    direction: "'LINESTRING(6 47,6.05 47.05,6.1 47.1,6.15 47.15,6.2 47.2)'",
+    seatsDriver: 3,
+    seatsPassenger: 1,
+    seatsUsed: 0,
+    strict: 'false',
+  };
+  const punctualAd = {
+    frequency: `'PUNCTUAL'`,
+    fromDate: `'2023-01-01'`,
+    toDate: `'2023-01-01'`,
+    monTime: 'NULL',
+    tueTime: 'NULL',
+    wedTime: 'NULL',
+    thuTime: 'NULL',
+    friTime: 'NULL',
+    satTime: 'NULL',
+    sunTime: `'2023-01-01T07:00Z'`,
+    monMargin: 900,
+    tueMargin: 900,
+    wedMargin: 900,
+    thuMargin: 900,
+    friMargin: 900,
+    satMargin: 900,
+    sunMargin: 900,
+  };
+  const recurrentAd = {
+    frequency: `'RECURRENT'`,
+    fromDate: `'2023-01-01'`,
+    toDate: `'2023-12-31'`,
+    monTime: `'2023-01-01T07:00Z'`,
+    tueTime: `'2023-01-01T07:00Z'`,
+    wedTime: `'2023-01-01T07:00Z'`,
+    thuTime: `'2023-01-01T07:00Z'`,
+    friTime: `'2023-01-01T07:00Z'`,
+    satTime: 'NULL',
+    sunTime: 'NULL',
+    monMargin: 900,
+    tueMargin: 900,
+    wedMargin: 900,
+    thuMargin: 900,
+    friMargin: 900,
+    satMargin: 900,
+    sunMargin: 900,
+  };
+
+  const createPunctualDriverAds = async (nbToCreate = 10) => {
+    const adToCreate = {
+      ...baseUuid,
+      ...baseUserUuid,
+      ...driverAd,
+      ...punctualAd,
+    };
+    for (let i = 0; i < nbToCreate; i++) {
+      adToCreate.uuid = `'${baseUuid.uuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      adToCreate.userUuid = `'${baseUserUuid.userUuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      await executeInsertCommand(adToCreate);
+    }
+  };
+
+  const createRecurrentDriverAds = async (nbToCreate = 10) => {
+    const adToCreate = {
+      ...baseUuid,
+      ...baseUserUuid,
+      ...driverAd,
+      ...recurrentAd,
+    };
+    for (let i = 0; i < nbToCreate; i++) {
+      adToCreate.uuid = `'${baseUuid.uuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      adToCreate.userUuid = `'${baseUserUuid.userUuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      await executeInsertCommand(adToCreate);
+    }
+  };
+
+  const createPunctualPassengerAds = async (nbToCreate = 10) => {
+    const adToCreate = {
+      ...baseUuid,
+      ...baseUserUuid,
+      ...passengerAd,
+      ...punctualAd,
+    };
+    for (let i = 0; i < nbToCreate; i++) {
+      adToCreate.uuid = `'${baseUuid.uuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      adToCreate.userUuid = `'${baseUserUuid.userUuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      await executeInsertCommand(adToCreate);
+    }
+  };
+
+  const createRecurrentPassengerAds = async (nbToCreate = 10) => {
+    const adToCreate = {
+      ...baseUuid,
+      ...baseUserUuid,
+      ...passengerAd,
+      ...recurrentAd,
+    };
+    for (let i = 0; i < nbToCreate; i++) {
+      adToCreate.uuid = `'${baseUuid.uuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      adToCreate.userUuid = `'${baseUserUuid.userUuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      await executeInsertCommand(adToCreate);
+    }
+  };
+
+  const createPunctualDriverPassengerAds = async (nbToCreate = 10) => {
+    const adToCreate = {
+      ...baseUuid,
+      ...baseUserUuid,
+      ...driverAndPassengerAd,
+      ...punctualAd,
+    };
+    for (let i = 0; i < nbToCreate; i++) {
+      adToCreate.uuid = `'${baseUuid.uuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      adToCreate.userUuid = `'${baseUserUuid.userUuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      await executeInsertCommand(adToCreate);
+    }
+  };
+
+  const createRecurrentDriverPassengerAds = async (nbToCreate = 10) => {
+    const adToCreate = {
+      ...baseUuid,
+      ...baseUserUuid,
+      ...driverAndPassengerAd,
+      ...recurrentAd,
+    };
+    for (let i = 0; i < nbToCreate; i++) {
+      adToCreate.uuid = `'${baseUuid.uuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      adToCreate.userUuid = `'${baseUserUuid.userUuid.slice(0, -2)}${i
+        .toString(16)
+        .padStart(2, '0')}'`;
+      await executeInsertCommand(adToCreate);
+    }
+  };
+
+  const executeInsertCommand = async (object: any) => {
+    const command = `INSERT INTO ad ("${Object.keys(object).join(
+      '","',
+    )}") VALUES (${Object.values(object).join(',')})`;
+    await prismaService.$executeRawUnsafe(command);
+  };
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [DatabaseModule],
+      providers: [AdRepository, PrismaService],
+    }).compile();
+
+    prismaService = module.get<PrismaService>(PrismaService);
+    adRepository = module.get<AdRepository>(AdRepository);
+  });
+
+  afterAll(async () => {
+    await prismaService.$disconnect();
+  });
+
+  beforeEach(async () => {
+    await prismaService.ad.deleteMany();
+  });
+
+  describe('findAll', () => {
+    it('should return an empty data array', async () => {
+      const res = await adRepository.findAll();
+      expect(res).toEqual({
+        data: [],
+        total: 0,
+      });
+    });
+
+    describe('drivers', () => {
+      it('should return a data array with 8 punctual driver ads', async () => {
+        await createPunctualDriverAds(8);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(8);
+        expect(ads.total).toBe(8);
+        expect(ads.data[0].driver).toBeTruthy();
+        expect(ads.data[0].passenger).toBeFalsy();
+      });
+
+      it('should return a data array limited to 10 punctual driver ads', async () => {
+        await createPunctualDriverAds(20);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(10);
+        expect(ads.total).toBe(20);
+        expect(ads.data[1].driver).toBeTruthy();
+        expect(ads.data[1].passenger).toBeFalsy();
+      });
+
+      it('should return a data array with 8 recurrent driver ads', async () => {
+        await createRecurrentDriverAds(8);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(8);
+        expect(ads.total).toBe(8);
+        expect(ads.data[2].driver).toBeTruthy();
+        expect(ads.data[2].passenger).toBeFalsy();
+      });
+
+      it('should return a data array limited to 10 recurrent driver ads', async () => {
+        await createRecurrentDriverAds(20);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(10);
+        expect(ads.total).toBe(20);
+        expect(ads.data[3].driver).toBeTruthy();
+        expect(ads.data[3].passenger).toBeFalsy();
+      });
+    });
+
+    describe('passengers', () => {
+      it('should return a data array with 7 punctual passenger ads', async () => {
+        await createPunctualPassengerAds(7);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(7);
+        expect(ads.total).toBe(7);
+        expect(ads.data[0].passenger).toBeTruthy();
+        expect(ads.data[0].driver).toBeFalsy();
+      });
+
+      it('should return a data array limited to 10 punctual passenger ads', async () => {
+        await createPunctualPassengerAds(15);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(10);
+        expect(ads.total).toBe(15);
+        expect(ads.data[1].passenger).toBeTruthy();
+        expect(ads.data[1].driver).toBeFalsy();
+      });
+
+      it('should return a data array with 7 recurrent passenger ads', async () => {
+        await createRecurrentPassengerAds(7);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(7);
+        expect(ads.total).toBe(7);
+        expect(ads.data[2].passenger).toBeTruthy();
+        expect(ads.data[2].driver).toBeFalsy();
+      });
+
+      it('should return a data array limited to 10 recurrent passenger ads', async () => {
+        await createRecurrentPassengerAds(15);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(10);
+        expect(ads.total).toBe(15);
+        expect(ads.data[3].passenger).toBeTruthy();
+        expect(ads.data[3].driver).toBeFalsy();
+      });
+    });
+
+    describe('drivers and passengers', () => {
+      it('should return a data array with 6 punctual driver and passenger ads', async () => {
+        await createPunctualDriverPassengerAds(6);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(6);
+        expect(ads.total).toBe(6);
+        expect(ads.data[0].passenger).toBeTruthy();
+        expect(ads.data[0].driver).toBeTruthy();
+      });
+
+      it('should return a data array limited to 10 punctual driver and passenger ads', async () => {
+        await createPunctualDriverPassengerAds(16);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(10);
+        expect(ads.total).toBe(16);
+        expect(ads.data[1].passenger).toBeTruthy();
+        expect(ads.data[1].driver).toBeTruthy();
+      });
+
+      it('should return a data array with 6 recurrent driver and passenger ads', async () => {
+        await createRecurrentDriverPassengerAds(6);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(6);
+        expect(ads.total).toBe(6);
+        expect(ads.data[2].passenger).toBeTruthy();
+        expect(ads.data[2].driver).toBeTruthy();
+      });
+
+      it('should return a data array limited to 10 recurrent driver and passenger ads', async () => {
+        await createRecurrentDriverPassengerAds(16);
+        const ads = await adRepository.findAll();
+        expect(ads.data.length).toBe(10);
+        expect(ads.total).toBe(16);
+        expect(ads.data[3].passenger).toBeTruthy();
+        expect(ads.data[3].driver).toBeTruthy();
+      });
+    });
+  });
+
+  describe('findOneByUuid', () => {
+    it('should return an ad', async () => {
+      await createPunctualDriverAds(1);
+      const ad = await adRepository.findOneByUuid(baseUuid.uuid);
+      expect(ad.uuid).toBe(baseUuid.uuid);
+    });
+
+    it('should return null', async () => {
+      const ad = await adRepository.findOneByUuid(
+        '544572be-11fb-4244-8235-587221fc9104',
+      );
+      expect(ad).toBeNull();
+    });
+  });
+
+  describe('create', () => {
+    it('should create an ad', async () => {
+      const beforeCount = await prismaService.ad.count();
+
+      const adToCreate: Ad = new Ad();
+      adToCreate.uuid = 'be459a29-7a41-4c0b-b371-abe90bfb6f00';
+      adToCreate.userUuid = '4e52b54d-a729-4dbd-9283-f84a11bb2200';
+      adToCreate.driver = true;
+      adToCreate.passenger = false;
+      adToCreate.fwdAzimuth = 0;
+      adToCreate.backAzimuth = 180;
+      adToCreate.waypoints = "'LINESTRING(6 47,6.1 47.1,6.2 47.2)'";
+      adToCreate.direction =
+        "'LINESTRING(6 47,6.05 47.05,6.1 47.1,6.15 47.15,6.2 47.2)'";
+      adToCreate.seatsDriver = 3;
+      adToCreate.seatsPassenger = 1;
+      adToCreate.seatsUsed = 0;
+      adToCreate.strict = false;
+      adToCreate.frequency = Frequency.PUNCTUAL;
+      adToCreate.fromDate = new Date(2023, 0, 1);
+      adToCreate.toDate = new Date(2023, 0, 1);
+      adToCreate.sunTime = new Date(2023, 0, 1, 6, 0, 0);
+      adToCreate.monMargin = 900;
+      adToCreate.tueMargin = 900;
+      adToCreate.wedMargin = 900;
+      adToCreate.thuMargin = 900;
+      adToCreate.friMargin = 900;
+      adToCreate.satMargin = 900;
+      adToCreate.sunMargin = 900;
+      const ad = await adRepository.createAd(adToCreate);
+
+      const afterCount = await prismaService.ad.count();
+
+      expect(afterCount - beforeCount).toBe(1);
+      expect(ad.uuid).toBe('be459a29-7a41-4c0b-b371-abe90bfb6f00');
+    });
+  });
+});

old/modules/ad/tests/unit/adapters/secondaries/default-params.provider.spec.ts

@@ -0,0 +1,38 @@
+import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { DefaultParamsProvider } from '../../../../adapters/secondaries/default-params.provider';
+import { DefaultParams } from '../../../../domain/types/default-params.type';
+
+const mockConfigService = {
+  get: jest.fn().mockImplementation(() => 'some_default_value'),
+};
+
+describe('DefaultParamsProvider', () => {
+  let defaultParamsProvider: DefaultParamsProvider;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [],
+      providers: [
+        DefaultParamsProvider,
+        {
+          provide: ConfigService,
+          useValue: mockConfigService,
+        },
+      ],
+    }).compile();
+
+    defaultParamsProvider = module.get<DefaultParamsProvider>(
+      DefaultParamsProvider,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(defaultParamsProvider).toBeDefined();
+  });
+
+  it('should provide default params', async () => {
+    const params: DefaultParams = defaultParamsProvider.getParams();
+    expect(params.GEOROUTER_URL).toBe('some_default_value');
+  });
+});

old/modules/ad/tests/unit/adapters/secondaries/message-publisher.spec.ts

@@ -0,0 +1,36 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { MessagePublisher } from '../../../../adapters/secondaries/message-publisher';
+import { MESSAGE_BROKER_PUBLISHER } from '../../../../../../app.constants';
+
+const mockMessageBrokerPublisher = {
+  publish: jest.fn().mockImplementation(),
+};
+
+describe('Messager', () => {
+  let messagePublisher: MessagePublisher;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [],
+      providers: [
+        MessagePublisher,
+        {
+          provide: MESSAGE_BROKER_PUBLISHER,
+          useValue: mockMessageBrokerPublisher,
+        },
+      ],
+    }).compile();
+
+    messagePublisher = module.get<MessagePublisher>(MessagePublisher);
+  });
+
+  it('should be defined', () => {
+    expect(messagePublisher).toBeDefined();
+  });
+
+  it('should publish a message', async () => {
+    jest.spyOn(mockMessageBrokerPublisher, 'publish');
+    messagePublisher.publish('ad.info', 'my-test');
+    expect(mockMessageBrokerPublisher.publish).toHaveBeenCalledTimes(1);
+  });
+});

old/modules/ad/tests/unit/adapters/secondaries/timezone-finder.spec.ts

@@ -0,0 +1,35 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { TimezoneFinder } from '../../../../adapters/secondaries/timezone-finder';
+import { GeoTimezoneFinder } from '../../../../../geography/adapters/secondaries/geo-timezone-finder';
+
+const mockGeoTimezoneFinder = {
+  timezones: jest.fn().mockImplementation(() => ['Europe/Paris']),
+};
+
+describe('Timezone Finder', () => {
+  let timezoneFinder: TimezoneFinder;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [],
+      providers: [
+        TimezoneFinder,
+        {
+          provide: GeoTimezoneFinder,
+          useValue: mockGeoTimezoneFinder,
+        },
+      ],
+    }).compile();
+
+    timezoneFinder = module.get<TimezoneFinder>(TimezoneFinder);
+  });
+
+  it('should be defined', () => {
+    expect(timezoneFinder).toBeDefined();
+  });
+  it('should get timezone for Nancy(France) as Europe/Paris', () => {
+    const timezones = timezoneFinder.timezones(6.179373, 48.687913);
+    expect(timezones.length).toBe(1);
+    expect(timezones[0]).toBe('Europe/Paris');
+  });
+});

old/modules/ad/tests/unit/domain/create-ad.usecase.spec.ts

@@ -0,0 +1,182 @@
+import { CreateAdRequest } from '../../../domain/dtos/create-ad.request';
+import { CreateAdUseCase } from '../../../domain/usecases/create-ad.usecase';
+import { Test, TestingModule } from '@nestjs/testing';
+import { AutomapperModule } from '@automapper/nestjs';
+import { classes } from '@automapper/classes';
+import { AdRepository } from '../../../adapters/secondaries/ad.repository';
+import { CreateAdCommand } from '../../../commands/create-ad.command';
+import { Ad } from '../../../domain/entities/ad';
+import { AdProfile } from '../../../mappers/ad.profile';
+import { Frequency } from '../../../domain/types/frequency.enum';
+import { RouteType } from '../../../domain/entities/geography';
+import { DatabaseException } from '../../../../database/exceptions/database.exception';
+import { Route } from '../../../../geography/domain/entities/route';
+import {
+  DIRECTION_ENCODER,
+  GEOROUTER_CREATOR,
+  PARAMS_PROVIDER,
+  TIMEZONE_FINDER,
+} from '../../../ad.constants';
+
+const mockAdRepository = {
+  createAd: jest.fn().mockImplementation((ad) => {
+    if (ad.uuid == '00000000-0000-0000-0000-000000000000')
+      throw new DatabaseException();
+    return new Ad();
+  }),
+};
+const mockGeorouterCreator = {
+  create: jest.fn().mockImplementation(() => ({
+    route: jest.fn().mockImplementation(() => [
+      {
+        key: RouteType.DRIVER,
+        route: <Route>{
+          points: [],
+          fwdAzimuth: 0,
+          backAzimuth: 180,
+          distance: 20000,
+          duration: 1800,
+        },
+      },
+      {
+        key: RouteType.PASSENGER,
+        route: <Route>{
+          points: [],
+          fwdAzimuth: 0,
+          backAzimuth: 180,
+          distance: 20000,
+          duration: 1800,
+        },
+      },
+      {
+        key: RouteType.COMMON,
+        route: <Route>{
+          points: [],
+          fwdAzimuth: 0,
+          backAzimuth: 180,
+          distance: 20000,
+          duration: 1800,
+        },
+      },
+    ]),
+  })),
+};
+const mockParamsProvider = {
+  getParams: jest.fn().mockImplementation(() => ({
+    DEFAULT_TIMEZONE: 'Europe/Paris',
+    GEOROUTER_TYPE: 'graphhopper',
+    GEOROUTER_URL: 'localhost',
+  })),
+};
+const mockTimezoneFinder = {
+  timezones: jest.fn().mockImplementation(() => ['Europe/Paris']),
+};
+const mockDirectionEncoder = {
+  encode: jest.fn(),
+};
+
+const createAdRequest: CreateAdRequest = {
+  uuid: '77c55dfc-c28b-4026-942e-f94e95401fb1',
+  userUuid: 'dfd993f6-7889-4876-9570-5e1d7b6e3f42',
+  driver: true,
+  passenger: false,
+  frequency: Frequency.RECURRENT,
+  fromDate: new Date('2023-04-26'),
+  toDate: new Date('2024-04-25'),
+  monTime: '07:00',
+  tueTime: '07:00',
+  wedTime: '07:00',
+  thuTime: '07:00',
+  friTime: '07:00',
+  satTime: null,
+  sunTime: null,
+  monMargin: 900,
+  tueMargin: 900,
+  wedMargin: 900,
+  thuMargin: 900,
+  friMargin: 900,
+  satMargin: 900,
+  sunMargin: 900,
+  seatsDriver: 3,
+  seatsPassenger: 1,
+  strict: false,
+  addresses: [
+    { lon: 6, lat: 45 },
+    { lon: 6.5, lat: 45.5 },
+  ],
+};
+
+const setUuid = async (uuid: string): Promise<void> => {
+  createAdRequest.uuid = uuid;
+};
+
+const setIsDriver = async (isDriver: boolean): Promise<void> => {
+  createAdRequest.driver = isDriver;
+};
+
+const setIsPassenger = async (isPassenger: boolean): Promise<void> => {
+  createAdRequest.passenger = isPassenger;
+};
+
+describe('CreateAdUseCase', () => {
+  let createAdUseCase: CreateAdUseCase;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [AutomapperModule.forRoot({ strategyInitializer: classes() })],
+      providers: [
+        {
+          provide: AdRepository,
+          useValue: mockAdRepository,
+        },
+        {
+          provide: GEOROUTER_CREATOR,
+          useValue: mockGeorouterCreator,
+        },
+        {
+          provide: PARAMS_PROVIDER,
+          useValue: mockParamsProvider,
+        },
+        {
+          provide: TIMEZONE_FINDER,
+          useValue: mockTimezoneFinder,
+        },
+        {
+          provide: DIRECTION_ENCODER,
+          useValue: mockDirectionEncoder,
+        },
+        AdProfile,
+        CreateAdUseCase,
+      ],
+    }).compile();
+
+    createAdUseCase = module.get<CreateAdUseCase>(CreateAdUseCase);
+  });
+
+  it('should be defined', () => {
+    expect(createAdUseCase).toBeDefined();
+  });
+
+  describe('execute', () => {
+    it('should create an ad as driver', async () => {
+      const ad = await createAdUseCase.execute(
+        new CreateAdCommand(createAdRequest),
+      );
+      expect(ad).toBeInstanceOf(Ad);
+    });
+    it('should create an ad as passenger', async () => {
+      await setIsDriver(false);
+      await setIsPassenger(true);
+      const ad = await createAdUseCase.execute(
+        new CreateAdCommand(createAdRequest),
+      );
+      expect(ad).toBeInstanceOf(Ad);
+    });
+    it('should throw an exception if repository fails', async () => {
+      await setUuid('00000000-0000-0000-0000-000000000000');
+      await expect(
+        createAdUseCase.execute(new CreateAdCommand(createAdRequest)),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+  });
+});

old/modules/ad/tests/unit/domain/geography.spec.ts

@@ -0,0 +1,138 @@
+import { Role } from '../../../domain/types/role.enum';
+import { Geography } from '../../../domain/entities/geography';
+import { Coordinate } from '../../../../geography/domain/entities/coordinate';
+import { IGeorouter } from '../../../../geography/domain/interfaces/georouter.interface';
+import { GeorouterSettings } from '../../../../geography/domain/types/georouter-settings.type';
+import { Route } from '../../../../geography/domain/entities/route';
+import { IGeodesic } from '../../../../geography/domain/interfaces/geodesic.interface';
+
+const simpleCoordinates: Coordinate[] = [
+  {
+    lon: 6,
+    lat: 47,
+  },
+  {
+    lon: 6.1,
+    lat: 47.1,
+  },
+];
+
+const complexCoordinates: Coordinate[] = [
+  {
+    lon: 6,
+    lat: 47,
+  },
+  {
+    lon: 6.1,
+    lat: 47.1,
+  },
+  {
+    lon: 6.2,
+    lat: 47.2,
+  },
+];
+
+const mockGeodesic: IGeodesic = {
+  inverse: jest.fn(),
+};
+
+const driverRoute: Route = new Route(mockGeodesic);
+driverRoute.distance = 25000;
+
+const commonRoute: Route = new Route(mockGeodesic);
+commonRoute.distance = 20000;
+
+const mockGeorouter: IGeorouter = {
+  route: jest
+    .fn()
+    .mockResolvedValueOnce([
+      {
+        key: 'driver',
+        route: driverRoute,
+      },
+    ])
+    .mockResolvedValueOnce([
+      {
+        key: 'passenger',
+        route: commonRoute,
+      },
+    ])
+    .mockResolvedValueOnce([
+      {
+        key: 'common',
+        route: commonRoute,
+      },
+    ])
+    .mockResolvedValueOnce([
+      {
+        key: 'driver',
+        route: driverRoute,
+      },
+      {
+        key: 'passenger',
+        route: commonRoute,
+      },
+    ]),
+};
+
+const georouterSettings: GeorouterSettings = {
+  withDistance: false,
+  withPoints: true,
+  withTime: false,
+};
+
+describe('Geography entity', () => {
+  it('should be defined', () => {
+    expect(new Geography(simpleCoordinates)).toBeDefined();
+  });
+
+  it('should create a route as driver', async () => {
+    const geography = new Geography(complexCoordinates);
+    await geography.createRoutes(
+      [Role.DRIVER],
+      mockGeorouter,
+      georouterSettings,
+    );
+    expect(geography.driverRoute).toBeDefined();
+    expect(geography.passengerRoute).toBeUndefined();
+    expect(geography.driverRoute.distance).toBe(25000);
+  });
+
+  it('should create a route as passenger', async () => {
+    const geography = new Geography(simpleCoordinates);
+    await geography.createRoutes(
+      [Role.PASSENGER],
+      mockGeorouter,
+      georouterSettings,
+    );
+    expect(geography.driverRoute).toBeUndefined();
+    expect(geography.passengerRoute).toBeDefined();
+    expect(geography.passengerRoute.distance).toBe(20000);
+  });
+
+  it('should create routes as driver and passenger with simple coordinates', async () => {
+    const geography = new Geography(simpleCoordinates);
+    await geography.createRoutes(
+      [Role.DRIVER, Role.PASSENGER],
+      mockGeorouter,
+      georouterSettings,
+    );
+    expect(geography.driverRoute).toBeDefined();
+    expect(geography.passengerRoute).toBeDefined();
+    expect(geography.driverRoute.distance).toBe(20000);
+    expect(geography.passengerRoute.distance).toBe(20000);
+  });
+
+  it('should create routes as driver and passenger with complex coordinates', async () => {
+    const geography = new Geography(complexCoordinates);
+    await geography.createRoutes(
+      [Role.DRIVER, Role.PASSENGER],
+      mockGeorouter,
+      georouterSettings,
+    );
+    expect(geography.driverRoute).toBeDefined();
+    expect(geography.passengerRoute).toBeDefined();
+    expect(geography.driverRoute.distance).toBe(25000);
+    expect(geography.passengerRoute.distance).toBe(20000);
+  });
+});

old/modules/ad/tests/unit/domain/time-converter.spec.ts

@@ -0,0 +1,53 @@
+import { TimeConverter } from '../../../domain/entities/time-converter';
+
+describe('TimeConverter', () => {
+  it('should be defined', () => {
+    expect(new TimeConverter()).toBeDefined();
+  });
+
+  it('should convert a Europe/Paris datetime to utc datetime', () => {
+    expect(
+      TimeConverter.toUtcDatetime(
+        new Date('2023-05-01'),
+        '07:00',
+        'Europe/Paris',
+      ).getUTCHours(),
+    ).toBe(6);
+  });
+
+  it('should return undefined when trying to convert a Europe/Paris datetime to utc datetime without a valid date', () => {
+    expect(
+      TimeConverter.toUtcDatetime(undefined, '07:00', 'Europe/Paris'),
+    ).toBeUndefined();
+    expect(
+      TimeConverter.toUtcDatetime(
+        new Date('2023-13-01'),
+        '07:00',
+        'Europe/Paris',
+      ),
+    ).toBeUndefined();
+  });
+
+  it('should return undefined when trying to convert a Europe/Paris datetime to utc datetime without a valid time', () => {
+    expect(
+      TimeConverter.toUtcDatetime(
+        new Date('2023-05-01'),
+        undefined,
+        'Europe/Paris',
+      ),
+    ).toBeUndefined();
+    expect(
+      TimeConverter.toUtcDatetime(new Date('2023-05-01'), 'a', 'Europe/Paris'),
+    ).toBeUndefined();
+  });
+
+  it('should return undefined when trying to convert a datetime to utc datetime without a valid timezone', () => {
+    expect(
+      TimeConverter.toUtcDatetime(
+        new Date('2023-12-01'),
+        '07:00',
+        'OlympusMons/Mars',
+      ),
+    ).toBeUndefined();
+  });
+});