#RI-4661 - remove duplicates

Author: AmirAllayarovSofteq

redisinsight/api/src/__mocks__/database-recommendation.ts

@@ -1,17 +1,35 @@
 import { DatabaseRecommendation } from 'src/modules/database-recommendation/models';
+import { DatabaseRecommendationEntity }
+  from 'src/modules/database-recommendation/entities/database-recommendation.entity';
+import { EncryptionStrategy } from 'src/modules/encryption/models';
 import { mockDatabaseId } from 'src/__mocks__/databases';
 
 export const mockDatabaseRecommendationId = 'databaseRecommendationID';
 
+export const mockRecommendationName = 'string';
+
+export const mockDatabaseRecommendationParamsEncrypted = 'recommendation.params_ENCRYPTED';
+
+export const mockDatabaseRecommendationParamsPlain = [];
+
 export const mockDatabaseRecommendation = Object.assign(new DatabaseRecommendation(), {
   id: mockDatabaseRecommendationId,
-  name: 'string',
+  name: mockRecommendationName,
   databaseId: mockDatabaseId,
   read: false,
   disabled: false,
   hide: false,
+  params: mockDatabaseRecommendationParamsPlain,
 });
 
+export const mockDatabaseRecommendationEntity = new DatabaseRecommendationEntity(
+  {
+    ...mockDatabaseRecommendation,
+    params: mockDatabaseRecommendationParamsEncrypted,
+    encryption: EncryptionStrategy.KEYTAR,
+  },
+);
+
 export const mockDatabaseRecommendationService = () => ({
   create: jest.fn(),
   list: jest.fn(),

redisinsight/api/src/modules/database-recommendation/models/database-recommendation.ts

@@ -50,6 +50,9 @@ export class DatabaseRecommendation {
     type: Boolean,
     example: false,
   })
+  @Expose()
+  @IsOptional()
+  @IsBoolean()
   disabled?: boolean;
 
   @ApiPropertyOptional({

redisinsight/api/src/modules/database-recommendation/repositories/local.database.recommendation.repository.spec.ts

@@ -0,0 +1,127 @@
+import { when } from 'jest-when';
+import { pick } from 'lodash';
+import { InternalServerErrorException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import {
+  mockEncryptionService,
+  mockRepository,
+  mockDatabaseRecommendationEntity,
+  mockRecommendationName,
+  mockClientMetadata,
+  mockDatabaseRecommendation,
+  MockType,
+} from 'src/__mocks__';
+import { EncryptionService } from 'src/modules/encryption/encryption.service';
+import { LocalDatabaseRecommendationRepository }
+  from 'src/modules/database-recommendation/repositories/local.database.recommendation.repository';
+import { DatabaseRecommendationEntity }
+  from 'src/modules/database-recommendation/entities/database-recommendation.entity';
+import ERROR_MESSAGES from 'src/constants/error-messages';
+
+describe('LocalDatabaseRecommendationRepository', () => {
+  let service: LocalDatabaseRecommendationRepository;
+  let encryptionService: MockType<EncryptionService>;
+  let repository: MockType<Repository<DatabaseRecommendationEntity>>;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        LocalDatabaseRecommendationRepository,
+        {
+          provide: getRepositoryToken(DatabaseRecommendationEntity),
+          useFactory: mockRepository,
+        },
+        {
+          provide: EncryptionService,
+          useFactory: mockEncryptionService,
+        },
+        EventEmitter2,
+      ],
+    }).compile();
+
+    repository = await module.get(getRepositoryToken(DatabaseRecommendationEntity));
+    encryptionService = await module.get(EncryptionService);
+    service = module.get(LocalDatabaseRecommendationRepository);
+
+    repository.findOneBy.mockResolvedValue(mockDatabaseRecommendationEntity);
+    repository.save.mockResolvedValue(mockDatabaseRecommendationEntity);
+    repository.update.mockResolvedValue(mockDatabaseRecommendationEntity);
+
+    when(encryptionService.encrypt)
+    .calledWith(JSON.stringify(mockDatabaseRecommendation.params))
+    .mockReturnValue({
+      encryption: mockDatabaseRecommendationEntity.encryption,
+      data: mockDatabaseRecommendationEntity.params,
+    });
+    when(encryptionService.decrypt)
+      .calledWith(mockDatabaseRecommendationEntity.params, jasmine.anything())
+      .mockReturnValue(JSON.stringify(mockDatabaseRecommendation.params));
+  });
+
+  describe('isExist', () => {
+    it('should return true when receive database entity', async () => {
+      expect(await service.isExist(mockClientMetadata, mockRecommendationName)).toEqual(true);
+    });
+
+    it('should return false when no database received', async () => {
+      repository.findOneBy.mockResolvedValueOnce(null);
+      expect(await service.isExist(mockClientMetadata, mockRecommendationName)).toEqual(false);
+    });
+
+    it('should return false when received error', async () => {
+      repository.findOneBy.mockRejectedValueOnce(new Error());
+      expect(await service.isExist(mockClientMetadata, mockRecommendationName)).toEqual(false);
+    });
+  });
+
+  describe('create', () => {
+    it('should create recommendation', async () => {
+      service.cleanupDatabaseRecommendations = jest
+        .fn()
+        .mockResolvedValue(undefined);
+
+      const result = await service.create(mockDatabaseRecommendation);
+
+      expect(result).toEqual(mockDatabaseRecommendation);
+      expect(service.cleanupDatabaseRecommendations).toHaveBeenCalledWith(
+        mockDatabaseRecommendation.databaseId
+      );
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete recommendation by id', async () => {
+      repository.delete.mockResolvedValueOnce({ affected: 1 });
+
+      expect(await service.delete(mockClientMetadata, 'id')).toEqual(undefined);
+    });
+
+    it('should return InternalServerErrorException when recommendation does not found', async () => {
+      repository.delete.mockResolvedValueOnce({ affected: 0 });
+
+      try {
+        await service.delete(mockClientMetadata, 'id');
+        fail();
+      } catch (e) {
+        expect(e).toBeInstanceOf(InternalServerErrorException);
+        expect(e.message).toEqual(ERROR_MESSAGES.DATABASE_RECOMMENDATION_NOT_FOUND);
+      }
+    });
+  });
+
+  describe('cleanupDatabaseRecommendations', () => {
+    it('Should not return anything on cleanup', async () => {
+      repository.createQueryBuilder().getRawMany.mockResolvedValueOnce([
+        { id: mockDatabaseRecommendationEntity.id },
+        { id: mockDatabaseRecommendationEntity.id },
+      ]);
+
+      expect(await service.cleanupDatabaseRecommendations(mockDatabaseRecommendationEntity.databaseId)).toEqual(undefined);
+    });
+  });
+});

redisinsight/api/src/modules/database-recommendation/repositories/local.database.recommendation.repository.ts

@@ -49,6 +49,12 @@ export class LocalDatabaseRecommendationRepository extends DatabaseRecommendatio
     const model = await this.repository.save(
       await this.modelEncryptor.encryptEntity(plainToClass(DatabaseRecommendationEntity, entity)),
     );
+    // cleanup recommendations and ignore error if any
+    try {
+      await this.cleanupDatabaseRecommendations(entity.databaseId);
+    } catch (e) {
+      this.logger.error('Error when trying to cleanup recommendations after insert', e);
+    }
 
     const recommendation = classToClass(
       DatabaseRecommendation,
@@ -57,6 +63,7 @@ export class LocalDatabaseRecommendationRepository extends DatabaseRecommendatio
     this.eventEmitter.emit(RecommendationEvents.NewRecommendation, [recommendation]);
 
     return recommendation;
+
   }
 
   /**
@@ -226,4 +233,25 @@ export class LocalDatabaseRecommendationRepository extends DatabaseRecommendatio
       throw new InternalServerErrorException(error.message);
     }
   }
+
+  /**
+   * Remove duplicates for particular database
+   * @param databaseId
+   */
+   async cleanupDatabaseRecommendations(databaseId: string): Promise<void> {
+    // todo: investigate why delete with sub-query doesn't works
+    const idsDuplicates = (await this.repository
+      .createQueryBuilder()
+      .where({ databaseId })
+      .select('id')
+      .groupBy('name')
+      .having('COUNT(name) > 1')
+      .getRawMany()).map((item) => item.id);
+
+    await this.repository
+      .createQueryBuilder()
+      .delete()
+      .whereInIds(idsDuplicates)
+      .execute();
+  }
 }