add mode to match wip

src/modules/ad/domain/dtos/create-ad.request.ts

@@ -43,37 +43,37 @@ export class CreateAdRequest {
   @IsOptional()
   @IsString()
   @AutoMap()
-  monTime: string | null;
+  monTime?: string | null;
 
   @IsOptional()
   @IsString()
   @AutoMap()
-  tueTime: string | null;
+  tueTime?: string | null;
 
   @IsOptional()
   @IsString()
   @AutoMap()
-  wedTime: string | null;
+  wedTime?: string | null;
 
   @IsOptional()
   @IsString()
   @AutoMap()
-  thuTime!: string | null;
+  thuTime?: string | null;
 
   @IsOptional()
   @IsString()
   @AutoMap()
-  friTime: string | null;
+  friTime?: string | null;
 
   @IsOptional()
   @IsString()
   @AutoMap()
-  satTime: string | null;
+  satTime?: string | null;
 
   @IsOptional()
   @IsString()
   @AutoMap()
-  sunTime: string | null;
+  sunTime?: string | null;
 
   @IsNumber()
   @AutoMap()
@@ -127,7 +127,7 @@ export class CreateAdRequest {
   @IsOptional()
   @IsNumber()
   @AutoMap()
-  seatsUsed: number;
+  seatsUsed?: number;
 
   @IsString()
   @AutoMap()
@@ -137,5 +137,5 @@ export class CreateAdRequest {
   @AutoMap()
   updatedAt: string;
 
-  timezone: string;
+  timezone?: string;
 }

src/modules/ad/domain/entities/time-converter.ts

@@ -4,13 +4,16 @@ export class TimeConverter {
   static toUtcDatetime = (
     date: string,
     time: string,
-    ianaTimezone: string,
-  ): Date =>
-    date && time
-      ? new Date(
-          new DateTime(`${date}T${time}:00`, TimeZone.zone(ianaTimezone, false))
-            .convert(TimeZone.zone('UTC'))
-            .toIsoString(),
-        )
-      : undefined;
+    timezone: string,
+  ): Date => {
+    try {
+      return new Date(
+        new DateTime(`${date}T${time}:00`, TimeZone.zone(timezone, false))
+          .convert(TimeZone.zone('UTC'))
+          .toIsoString(),
+      );
+    } catch (e) {
+      return undefined;
+    }
+  };
 }

src/modules/ad/mappers/ad.profile.ts

@@ -55,72 +55,44 @@ export class AdProfile extends AutomapperProfile {
         ),
         forMember(
           (dest) => dest.monTime,
-          mapFrom((source) =>
-            TimeConverter.toUtcDatetime(
-              source.fromDate,
-              source.monTime,
-              source.timezone,
-            ),
+          mapFrom(({ monTime: time, fromDate: date, timezone }) =>
+            TimeConverter.toUtcDatetime(date, time, timezone),
           ),
         ),
         forMember(
           (dest) => dest.tueTime,
-          mapFrom((source) =>
-            TimeConverter.toUtcDatetime(
-              source.fromDate,
-              source.tueTime,
-              source.timezone,
-            ),
+          mapFrom(({ tueTime: time, fromDate: date, timezone }) =>
+            TimeConverter.toUtcDatetime(date, time, timezone),
           ),
         ),
         forMember(
           (dest) => dest.wedTime,
-          mapFrom((source) =>
-            TimeConverter.toUtcDatetime(
-              source.fromDate,
-              source.wedTime,
-              source.timezone,
-            ),
+          mapFrom(({ wedTime: time, fromDate: date, timezone }) =>
+            TimeConverter.toUtcDatetime(date, time, timezone),
           ),
         ),
         forMember(
           (dest) => dest.thuTime,
-          mapFrom((source) =>
-            TimeConverter.toUtcDatetime(
-              source.fromDate,
-              source.thuTime,
-              source.timezone,
-            ),
+          mapFrom(({ thuTime: time, fromDate: date, timezone }) =>
+            TimeConverter.toUtcDatetime(date, time, timezone),
           ),
         ),
         forMember(
           (dest) => dest.friTime,
-          mapFrom((source) =>
-            TimeConverter.toUtcDatetime(
-              source.fromDate,
-              source.friTime,
-              source.timezone,
-            ),
+          mapFrom(({ friTime: time, fromDate: date, timezone }) =>
+            TimeConverter.toUtcDatetime(date, time, timezone),
           ),
         ),
         forMember(
           (dest) => dest.satTime,
-          mapFrom((source) =>
-            TimeConverter.toUtcDatetime(
-              source.fromDate,
-              source.satTime,
-              source.timezone,
-            ),
+          mapFrom(({ satTime: time, fromDate: date, timezone }) =>
+            TimeConverter.toUtcDatetime(date, time, timezone),
           ),
         ),
         forMember(
           (dest) => dest.sunTime,
-          mapFrom((source) =>
-            TimeConverter.toUtcDatetime(
-              source.fromDate,
-              source.sunTime,
-              source.timezone,
-            ),
+          mapFrom(({ sunTime: time, fromDate: date, timezone }) =>
+            TimeConverter.toUtcDatetime(date, time, timezone),
           ),
         ),
       );

src/modules/ad/tests/unit/adapters/secondaries/messager.spec.ts

@@ -0,0 +1,47 @@
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { Messager } from '../../../../adapters/secondaries/messager';
+
+const mockAmqpConnection = {
+  publish: jest.fn().mockImplementation(),
+};
+
+const mockConfigService = {
+  get: jest.fn().mockResolvedValue({
+    RMQ_EXCHANGE: 'mobicoop',
+  }),
+};
+
+describe('Messager', () => {
+  let messager: Messager;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [],
+      providers: [
+        Messager,
+        {
+          provide: AmqpConnection,
+          useValue: mockAmqpConnection,
+        },
+        {
+          provide: ConfigService,
+          useValue: mockConfigService,
+        },
+      ],
+    }).compile();
+
+    messager = module.get<Messager>(Messager);
+  });
+
+  it('should be defined', () => {
+    expect(messager).toBeDefined();
+  });
+
+  it('should publish a message', async () => {
+    jest.spyOn(mockAmqpConnection, 'publish');
+    messager.publish('test.create.info', 'my-test');
+    expect(mockAmqpConnection.publish).toHaveBeenCalledTimes(1);
+  });
+});

src/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');
+  });
+});

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

@@ -0,0 +1,91 @@
+import { CreateAdRequest } from '../../../domain/dtos/create-ad.request';
+import { PointType } from '../../../../geography/domain/types/point-type.enum';
+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';
+
+const mockAdRepository = {};
+
+const createAdRequest: CreateAdRequest = {
+  uuid: '77c55dfc-c28b-4026-942e-f94e95401fb1',
+  driver: true,
+  passenger: false,
+  frequency: 2,
+  fromDate: '2023-04-26',
+  toDate: '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,
+  originType: PointType.OTHER,
+  destinationType: PointType.OTHER,
+  seatsDriver: 3,
+  seatsPassenger: 1,
+  createdAt: '2023-04-01 12:45',
+  updatedAt: '2023-04-01 12:45',
+  waypoints: [
+    { lon: 6, lat: 45 },
+    { lon: 6.5, lat: 45.5 },
+  ],
+};
+
+describe('CreateAdUseCase', () => {
+  let createAdUseCase: CreateAdUseCase;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [AutomapperModule.forRoot({ strategyInitializer: classes() })],
+      providers: [
+        {
+          provide: AdRepository,
+          useValue: mockAdRepository,
+        },
+        AdProfile,
+        CreateAdUseCase,
+      ],
+    }).compile();
+
+    createAdUseCase = module.get<CreateAdUseCase>(CreateAdUseCase);
+  });
+
+  it('should be defined', () => {
+    expect(createAdUseCase).toBeDefined();
+  });
+
+  describe('execute', () => {
+    it('should create an ad', async () => {
+      const ad = await createAdUseCase.execute(
+        new CreateAdCommand(createAdRequest),
+      );
+      expect(ad).toBeInstanceOf(Ad);
+    });
+
+    //   it('should throw an exception when error occurs', async () => {
+    //     await expect(
+    //       createAdUseCase.execute(
+    //         new MatchQuery(
+    //           matchRequest,
+    //           defaultParams,
+    //           mockGeorouterCreator,
+    //           mockTimezoneFinder,
+    //         ),
+    //       ),
+    //     ).rejects.toBeInstanceOf(MatcherException);
+    //   });
+  });
+});

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

@@ -0,0 +1,35 @@
+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(
+        '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, time or timezone', () => {
+    expect(
+      TimeConverter.toUtcDatetime(undefined, '07:00', 'Europe/Paris'),
+    ).toBeUndefined();
+    expect(
+      TimeConverter.toUtcDatetime('2023-13-01', '07:00', 'Europe/Paris'),
+    ).toBeUndefined();
+    expect(
+      TimeConverter.toUtcDatetime('2023-05-01', undefined, 'Europe/Paris'),
+    ).toBeUndefined();
+    expect(
+      TimeConverter.toUtcDatetime('2023-05-01', 'a', 'Europe/Paris'),
+    ).toBeUndefined();
+    expect(
+      TimeConverter.toUtcDatetime('2023-13-01', '07:00', 'OlympusMons/Mars'),
+    ).toBeUndefined();
+  });
+});