Mock db methods to test the service's delete method

Author: GnaneshKunal

redisinsight/api/src/__mocks__/databases.ts

@@ -251,6 +251,12 @@ export const mockDatabaseRepository = jest.fn(() => ({
     pick(mockDatabase, 'id', 'name'),
     pick(mockDatabase, 'id', 'name'),
   ]),
+  createQueryBuilder: jest.fn().mockReturnThis(),
+  leftJoinAndSelect: jest.fn().mockReturnThis(),
+  where: jest.fn().mockReturnThis(),
+  select: jest.fn().mockReturnThis(),
+  getMany: jest.fn().mockResolvedValue([]),
+  findOneBy: jest.fn().mockResolvedValue(mockDatabase),
 }));
 
 export const mockDatabaseService = jest.fn(() => ({

redisinsight/api/src/modules/certificate/repositories/local.ca-certificate.repository.spec.ts

@@ -107,24 +107,45 @@ describe('LocalCaCertificateRepository', () => {
   });
 
   describe('delete', () => {
-    it('should delete ca certificate', async () => {
-      const result = await service.delete(mockCaCertificate.id);
-
-      expect(result).toEqual(undefined);
+    it('should delete ca certificate and return affected databases', async () => {
+      const mockId = 'mock-ca-cert-id';
+      const mockAffectedDatabases = ['db1', 'db2'];
+
+      // Mock findOneBy to return a certificate
+      repository.findOneBy.mockResolvedValue(mockCaCertificate);
+
+      // Mock getMany to return affected databases
+      const mockQueryBuilder = {
+        leftJoinAndSelect: jest.fn().mockReturnThis(),
+        where: jest.fn().mockReturnThis(),
+        select: jest.fn().mockReturnThis(),
+        getMany: jest.fn().mockResolvedValue(mockAffectedDatabases.map((id) => ({ id }))),
+      };
+      jest.spyOn(service['databaseRepository'], 'createQueryBuilder').mockReturnValue(mockQueryBuilder as any);
+
+      // Mock delete operation
+      repository.delete.mockResolvedValue(undefined);
+
+      const result = await service.delete(mockId);
+
+      expect(result).toEqual({ affectedDatabases: mockAffectedDatabases });
+      expect(repository.findOneBy).toHaveBeenCalledWith({ id: mockId });
+      expect(service['databaseRepository'].createQueryBuilder).toHaveBeenCalledWith('d');
+      expect(mockQueryBuilder.leftJoinAndSelect).toHaveBeenCalledWith('d.caCert', 'c');
+      expect(mockQueryBuilder.where).toHaveBeenCalledWith({ caCert: mockId });
+      expect(mockQueryBuilder.select).toHaveBeenCalledWith(['d.id']);
+      expect(repository.delete).toHaveBeenCalledWith(mockId);
     });
 
-    it('should throw an error when trying to delete non-existing ca certificate', async () => {
-      repository.findOneBy.mockResolvedValueOnce(null);
+    it('should throw NotFoundException when trying to delete non-existing ca certificate', async () => {
+      const mockId = 'non-existent-id';
 
-      try {
-        await service.delete(mockCaCertificate.id);
-        fail();
-      } catch (e) {
-        expect(e).toBeInstanceOf(NotFoundException);
-        // todo: why such message?
-        expect(e.message).toEqual('Not Found');
-        expect(repository.delete).not.toHaveBeenCalled();
-      }
+      // Mock findOneBy to return null (certificate not found)
+      repository.findOneBy.mockResolvedValue(null);
+
+      await expect(service.delete(mockId)).rejects.toThrow(NotFoundException);
+      expect(repository.findOneBy).toHaveBeenCalledWith({ id: mockId });
+      expect(repository.delete).not.toHaveBeenCalled();
     });
   });
 });

redisinsight/api/src/modules/certificate/repositories/local.client-certificate.repository.spec.ts

@@ -123,24 +123,43 @@ describe('LocalClientCertificateRepository', () => {
   });
 
   describe('delete', () => {
-    it('should delete client certificate', async () => {
-      const result = await service.delete(mockClientCertificate.id);
+    const mockId = 'mock-client-cert-id';
+    const mockAffectedDatabases = ['db1', 'db2'];
 
-      expect(result).toEqual(undefined);
+    beforeEach(() => {
+      jest.clearAllMocks();
     });
 
-    it('should throw an error when trying to delete non-existing client certificate', async () => {
-      repository.findOneBy.mockResolvedValueOnce(null);
+    it('should delete client certificate and return affected databases', async () => {
+      jest.spyOn(repository, 'findOneBy').mockResolvedValue(mockClientCertificate);
 
-      try {
-        await service.delete(mockClientCertificate.id);
-        fail();
-      } catch (e) {
-        expect(e).toBeInstanceOf(NotFoundException);
-        // todo: why such message?
-        expect(e.message).toEqual('Not Found');
-        expect(repository.delete).not.toHaveBeenCalled();
-      }
+      const mockQueryBuilder = {
+        leftJoinAndSelect: jest.fn().mockReturnThis(),
+        where: jest.fn().mockReturnThis(),
+        select: jest.fn().mockReturnThis(),
+        getMany: jest.fn().mockResolvedValue(mockAffectedDatabases.map((id) => ({ id })))
+      };
+      jest.spyOn(service['databaseRepository'], 'createQueryBuilder').mockReturnValue(mockQueryBuilder as any);
+
+      jest.spyOn(repository, 'delete').mockResolvedValue(undefined);
+
+      const result = await service.delete(mockId);
+
+      expect(result).toEqual({ affectedDatabases: mockAffectedDatabases });
+      expect(repository.findOneBy).toHaveBeenCalledWith({ id: mockId });
+      expect(service['databaseRepository'].createQueryBuilder).toHaveBeenCalledWith('d');
+      expect(mockQueryBuilder.leftJoinAndSelect).toHaveBeenCalledWith('d.clientCert', 'c');
+      expect(mockQueryBuilder.where).toHaveBeenCalledWith({ clientCert: mockId });
+      expect(mockQueryBuilder.select).toHaveBeenCalledWith(['d.id']);
+      expect(repository.delete).toHaveBeenCalledWith(mockId);
+    });
+
+    it('should throw NotFoundException when trying to delete non-existing client certificate', async () => {
+      jest.spyOn(repository, 'findOneBy').mockResolvedValue(null);
+
+      await expect(service.delete(mockId)).rejects.toThrow(NotFoundException);
+      expect(repository.findOneBy).toHaveBeenCalledWith({ id: mockId });
+      expect(repository.delete).not.toHaveBeenCalled();
     });
   });
 });