Merge pull request #2221 from RedisInsight/be/bugfix/RI-4661_cloud_recommendation

#RI-4661 - remove duplicates

Author: vlad-dargel

redisinsight/api/migration/1687435940110-database-recommendation-unique.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class DatabaseRecommendationUnique1687435940110 implements MigrationInterface {
+    name = 'DatabaseRecommendationUnique1687435940110'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`DROP INDEX "IDX_2487bdd9dbde3fdf65bcb96fc5"`);
+        await queryRunner.query(`DROP INDEX "IDX_d6107e5e16648b038c511f3b00"`);
+        await queryRunner.query(`CREATE TABLE "temporary_database_recommendations" ("id" varchar PRIMARY KEY NOT NULL, "databaseId" varchar NOT NULL, "name" varchar NOT NULL, "read" boolean NOT NULL DEFAULT (0), "disabled" boolean NOT NULL DEFAULT (0), "vote" varchar, "hide" boolean NOT NULL DEFAULT (0), "createdAt" datetime NOT NULL DEFAULT (datetime('now')), "params" blob, "encryption" varchar, CONSTRAINT "UQ_b772d2856a42685ce4227321251" UNIQUE ("databaseId", "name"), CONSTRAINT "FK_2487bdd9dbde3fdf65bcb96fc52" FOREIGN KEY ("databaseId") REFERENCES "database_instance" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`);
+        await queryRunner.query(`INSERT OR IGNORE INTO "temporary_database_recommendations"("id", "databaseId", "name", "read", "disabled", "vote", "hide", "createdAt", "params", "encryption") SELECT "id", "databaseId", "name", "read", "disabled", "vote", "hide", "createdAt", "params", "encryption" FROM "database_recommendations"`);
+        await queryRunner.query(`DROP TABLE "database_recommendations"`);
+        await queryRunner.query(`ALTER TABLE "temporary_database_recommendations" RENAME TO "database_recommendations"`);
+        await queryRunner.query(`CREATE INDEX "IDX_2487bdd9dbde3fdf65bcb96fc5" ON "database_recommendations" ("databaseId") `);
+        await queryRunner.query(`CREATE INDEX "IDX_d6107e5e16648b038c511f3b00" ON "database_recommendations" ("createdAt") `);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`DROP INDEX "IDX_d6107e5e16648b038c511f3b00"`);
+        await queryRunner.query(`DROP INDEX "IDX_2487bdd9dbde3fdf65bcb96fc5"`);
+        await queryRunner.query(`ALTER TABLE "database_recommendations" RENAME TO "temporary_database_recommendations"`);
+        await queryRunner.query(`CREATE TABLE "database_recommendations" ("id" varchar PRIMARY KEY NOT NULL, "databaseId" varchar NOT NULL, "name" varchar NOT NULL, "read" boolean NOT NULL DEFAULT (0), "disabled" boolean NOT NULL DEFAULT (0), "vote" varchar, "hide" boolean NOT NULL DEFAULT (0), "createdAt" datetime NOT NULL DEFAULT (datetime('now')), "params" blob, "encryption" varchar, CONSTRAINT "FK_2487bdd9dbde3fdf65bcb96fc52" FOREIGN KEY ("databaseId") REFERENCES "database_instance" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`);
+        await queryRunner.query(`INSERT INTO "database_recommendations"("id", "databaseId", "name", "read", "disabled", "vote", "hide", "createdAt", "params", "encryption") SELECT "id", "databaseId", "name", "read", "disabled", "vote", "hide", "createdAt", "params", "encryption" FROM "temporary_database_recommendations"`);
+        await queryRunner.query(`DROP TABLE "temporary_database_recommendations"`);
+        await queryRunner.query(`CREATE INDEX "IDX_d6107e5e16648b038c511f3b00" ON "database_recommendations" ("createdAt") `);
+        await queryRunner.query(`CREATE INDEX "IDX_2487bdd9dbde3fdf65bcb96fc5" ON "database_recommendations" ("databaseId") `);
+    }
+
+}

redisinsight/api/migration/index.ts

@@ -33,6 +33,7 @@ import { databaseRecommendations1681900503586 } from './1681900503586-database-r
 import { databaseRecommendationParams1683006064293 } from './1683006064293-database-recommendation-params';
 import { Feature1684931530343 } from './1684931530343-feature';
 import { DatabaseRedisServer1686719451753 } from './1686719451753-database-redis-server';
+import { DatabaseRecommendationUnique1687435940110 } from './1687435940110-database-recommendation-unique';
 import { CloudDatabaseDetails1687166457712 } from './1687166457712-cloud-database-details';
 
 export default [
@@ -71,5 +72,6 @@ export default [
   databaseRecommendationParams1683006064293,
   Feature1684931530343,
   DatabaseRedisServer1686719451753,
+  DatabaseRecommendationUnique1687435940110,
   CloudDatabaseDetails1687166457712,
 ];

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/entities/database-recommendation.entity.ts

@@ -1,11 +1,12 @@
 import {
-  Column, CreateDateColumn, Entity, ManyToOne, PrimaryGeneratedColumn, JoinColumn, Index,
+  Column, CreateDateColumn, Entity, ManyToOne, PrimaryGeneratedColumn, JoinColumn, Index, Unique,
 } from 'typeorm';
 import { Expose } from 'class-transformer';
 import { DataAsJsonString } from 'src/common/decorators';
 import { DatabaseEntity } from 'src/modules/database/entities/database.entity';
 
 @Entity('database_recommendations')
+@Unique(['databaseId', 'name'])
 export class DatabaseRecommendationEntity {
   @PrimaryGeneratedColumn('uuid')
   @Expose()

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,116 @@
+import { when } from 'jest-when';
+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 () => {
+      const result = await service.create(mockDatabaseRecommendation);
+
+      expect(result).toEqual(mockDatabaseRecommendation);
+    });
+
+    it('should not create recommendation', async () => {
+      repository.save.mockRejectedValueOnce(new Error());
+
+      const result = await service.create(mockDatabaseRecommendation);
+
+      expect(result).toEqual(null);
+    });
+  });
+
+  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);
+      }
+    });
+  });
+});

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

@@ -46,17 +46,23 @@ export class LocalDatabaseRecommendationRepository extends DatabaseRecommendatio
   async create(entity: DatabaseRecommendation): Promise<DatabaseRecommendation> {
     this.logger.log('Creating database recommendation');
 
-    const model = await this.repository.save(
-      await this.modelEncryptor.encryptEntity(plainToClass(DatabaseRecommendationEntity, entity)),
-    );
+    try {
+      const model = await this.repository.save(
+        await this.modelEncryptor.encryptEntity(plainToClass(DatabaseRecommendationEntity, entity)),
+      );
 
-    const recommendation = classToClass(
-      DatabaseRecommendation,
-      await this.modelEncryptor.decryptEntity(model, true),
-    );
-    this.eventEmitter.emit(RecommendationEvents.NewRecommendation, [recommendation]);
+      const recommendation = classToClass(
+        DatabaseRecommendation,
+        await this.modelEncryptor.decryptEntity(model, true),
+      );
+      this.eventEmitter.emit(RecommendationEvents.NewRecommendation, [recommendation]);
 
-    return recommendation;
+      return recommendation;
+    } catch (err) {
+      this.logger.error('Failed to create database recommendation', err);
+
+      return null;
+    }
   }
 
   /**

redisinsight/api/test/helpers/constants.ts

@@ -496,7 +496,7 @@ export const constants = {
 
   TEST_RECOMMENDATION_NAME_1: RECOMMENDATION_NAMES.BIG_SETS,
   TEST_RECOMMENDATION_NAME_2: RECOMMENDATION_NAMES.BIG_STRINGS,
-  TEST_RECOMMENDATION_NAME_3: RECOMMENDATION_NAMES.BIG_STRINGS,
+  TEST_RECOMMENDATION_NAME_3: RECOMMENDATION_NAMES.AVOID_LOGICAL_DATABASES,
 
   TEST_LUA_DATABASE_ANALYSIS_RECOMMENDATION: {
     name: RECOMMENDATION_NAMES.LUA_SCRIPT,