upgrade health, use configuration and broker packages

src/modules/health/tests/unit/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('health.info', 'my-test');
+    expect(mockMessageBrokerPublisher.publish).toHaveBeenCalledTimes(1);
+  });
+});

src/modules/health/tests/unit/messager.spec.ts

@@ -1,47 +0,0 @@
-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/health/tests/unit/repositories.health-indicator.usecase.spec.ts

@@ -1,8 +1,7 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import { PrismaHealthIndicatorUseCase } from '../../domain/usecases/prisma.health-indicator.usecase';
 import { HealthCheckError, HealthIndicatorResult } from '@nestjs/terminus';
+import { RepositoriesHealthIndicatorUseCase } from '../../domain/usecases/repositories.health-indicator.usecase';
 import { AdsRepository } from '../../../ad/adapters/secondaries/ads.repository';
-import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
 
 const mockAdsRepository = {
   healthCheck: jest
@@ -11,47 +10,45 @@ const mockAdsRepository = {
       return Promise.resolve(true);
     })
     .mockImplementation(() => {
-      throw new PrismaClientKnownRequestError('Service unavailable', {
-        code: 'code',
-        clientVersion: 'version',
-      });
+      throw new Error('an error occured in the repository');
     }),
 };
 
-describe('PrismaHealthIndicatorUseCase', () => {
-  let prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase;
+describe('RepositoriesHealthIndicatorUseCase', () => {
+  let repositoriesHealthIndicatorUseCase: RepositoriesHealthIndicatorUseCase;
 
   beforeAll(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
+        RepositoriesHealthIndicatorUseCase,
         {
           provide: AdsRepository,
           useValue: mockAdsRepository,
         },
-        PrismaHealthIndicatorUseCase,
       ],
     }).compile();
 
-    prismaHealthIndicatorUseCase = module.get<PrismaHealthIndicatorUseCase>(
-      PrismaHealthIndicatorUseCase,
-    );
+    repositoriesHealthIndicatorUseCase =
+      module.get<RepositoriesHealthIndicatorUseCase>(
+        RepositoriesHealthIndicatorUseCase,
+      );
   });
 
   it('should be defined', () => {
-    expect(prismaHealthIndicatorUseCase).toBeDefined();
+    expect(repositoriesHealthIndicatorUseCase).toBeDefined();
   });
 
   describe('execute', () => {
     it('should check health successfully', async () => {
       const healthIndicatorResult: HealthIndicatorResult =
-        await prismaHealthIndicatorUseCase.isHealthy('prisma');
+        await repositoriesHealthIndicatorUseCase.isHealthy('repositories');
 
-      expect(healthIndicatorResult['prisma'].status).toBe('up');
+      expect(healthIndicatorResult['repositories'].status).toBe('up');
     });
 
     it('should throw an error if database is unavailable', async () => {
       await expect(
-        prismaHealthIndicatorUseCase.isHealthy('prisma'),
+        repositoriesHealthIndicatorUseCase.isHealthy('repositories'),
       ).rejects.toBeInstanceOf(HealthCheckError);
     });
   });