CR-263: Update tests

Author: seth-riedel

redisinsight/api/src/modules/browser/keys/keys.service.spec.ts

@@ -153,19 +153,13 @@ describe('KeysService', () => {
         getKeyInfoResponse.name,
       );
 
-      expect(recommendationService.check).toBeCalledWith(
-        mockBrowserClientMetadata,
-        RECOMMENDATION_NAMES.BIG_SETS,
-        result,
-      );
-      expect(recommendationService.check).toBeCalledWith(
+      expect(recommendationService.checkMulti).toBeCalledWith(
         mockBrowserClientMetadata,
-        RECOMMENDATION_NAMES.BIG_STRINGS,
-        result,
-      );
-      expect(recommendationService.check).toBeCalledWith(
-        mockBrowserClientMetadata,
-        RECOMMENDATION_NAMES.COMPRESSION_FOR_LIST,
+        [
+          RECOMMENDATION_NAMES.BIG_SETS,
+          RECOMMENDATION_NAMES.BIG_STRINGS,
+          RECOMMENDATION_NAMES.COMPRESSION_FOR_LIST,
+        ],
         result,
       );
     });

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

@@ -57,23 +57,21 @@ export class DatabaseRecommendationService {
     exists: boolean,
     clientMetadata: ClientMetadata, data: any,
   ): Promise<DatabaseRecommendation> {
-    if (exists) {
-      return null;
-    }
-
-    const recommendation = await this.scanner.determineRecommendation(
-      clientMetadata.sessionMetadata,
-      recommendationName,
-      data,
-    );
-
-    if (recommendation) {
-      const entity = plainToClass(
-        DatabaseRecommendation,
-        { databaseId: clientMetadata?.databaseId, ...recommendation },
+    if (!exists) {
+      const recommendation = await this.scanner.determineRecommendation(
+        clientMetadata.sessionMetadata,
+        recommendationName,
+        data,
       );
 
-      return await this.create(clientMetadata, entity);
+      if (recommendation) {
+        const entity = plainToClass(
+          DatabaseRecommendation,
+          { databaseId: clientMetadata?.databaseId, ...recommendation },
+        );
+
+        return await this.create(clientMetadata, entity);
+      }
     }
 
     return null;
@@ -91,14 +89,19 @@ export class DatabaseRecommendationService {
           ?? (await this.databaseService.get(clientMetadata.sessionMetadata, clientMetadata.databaseId))?.db
           ?? 0,
       };
-      const isRecommendationExist = await this.databaseRecommendationRepository.isExist(
+      const isRecommendationExist = await this.databaseRecommendationRepository.isExistMulti(
         newClientMetadata,
         recommendationNames,
       );
 
       const results = await Promise.all(
         recommendationNames.map(
-          (name) => this.checkRecommendation(name, isRecommendationExist[name], newClientMetadata, data),
+          (name) => this.checkRecommendation(
+            name,
+            isRecommendationExist[name],
+            newClientMetadata,
+            data,
+          ),
         ),
       );
 

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

@@ -42,12 +42,19 @@ export abstract class DatabaseRecommendationRepository {
   ): Promise<DatabaseRecommendation>;
 
   /**
-   * Check is recommendation already exist in repository
+   * Check if recommendation already exist in repository
+   * @param clientMetadata
+   * @param name
+   * @return Boolean
+   */
+  abstract isExist(clientMetadata: ClientMetadata, name: string): Promise<boolean>;
+
+  /**
+   * Check if one or more recommendations exist in repository
    * @param clientMetadata
    * @param names
-   * @return Map<string, boolean>
    */
-  abstract isExist(clientMetadata: ClientMetadata, names: string[]): Promise<Map<string, boolean>>;
+  abstract isExistMulti(clientMetadata: ClientMetadata, names: string[]): Promise<Map<string, boolean>>;
 
   /**
    * Get database recommendation by id

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

@@ -64,17 +64,33 @@ describe('LocalDatabaseRecommendationRepository', () => {
 
   describe('isExist', () => {
     it('should return true when receive database entity', async () => {
-      expect(await service.isExist(mockClientMetadata, [mockRecommendationName])).toEqual({ [mockRecommendationName]: true });
+      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({ [mockRecommendationName]: false });
+      expect(await service.isExist(mockClientMetadata, mockRecommendationName)).toEqual(false);
     });
 
-    it('should return empty object when received error', async () => {
+    it('should return false when received error', async () => {
       repository.findOneBy.mockRejectedValueOnce(new Error());
-      expect(await service.isExist(mockClientMetadata, [mockRecommendationName])).toEqual({});
+      expect(await service.isExist(mockClientMetadata, mockRecommendationName)).toEqual(false);
+    });
+  });
+
+  describe('isExistMulti', () => {
+    it('should return results for multiple recommendation names', async () => {
+      repository.findOneBy.mockResolvedValueOnce(null);
+      repository.findOneBy.mockResolvedValueOnce({});
+      expect(await service.isExistMulti(mockClientMetadata, ['test1', 'test2'])).toEqual({
+        test1: false,
+        test2: true,
+      });
+    });
+
+    it('should return empty Map when received error', async () => {
+      repository.findOneBy.mockRejectedValueOnce(new Error());
+      expect(await service.isExistMulti(mockClientMetadata, ['test1', 'test2'])).toEqual({});
     });
   });
 

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

@@ -41,7 +41,7 @@ export class LocalDatabaseRecommendationRepository extends DatabaseRecommendatio
 
   /**
    * Save entire entity
-   * @param _
+   * @param sessionMetadata
    * @param entity
    */
   async create(sessionMetadata: SessionMetadata, entity: DatabaseRecommendation): Promise<DatabaseRecommendation> {
@@ -102,7 +102,7 @@ export class LocalDatabaseRecommendationRepository extends DatabaseRecommendatio
   }
 
   /**
-   * Read all recommendations recommendations
+   * Read all recommendations
    * @param clientMetadata
    */
   async read(clientMetadata: ClientMetadata): Promise<void> {
@@ -147,24 +147,46 @@ export class LocalDatabaseRecommendationRepository extends DatabaseRecommendatio
   /**
    * Check is recommendation exist in database
    * @param clientMetadata
-   * @param names
+   * @param name
    */
   async isExist(
     clientMetadata: ClientMetadata,
-    names: string[],
-  ): Promise<Map<string, boolean>> {
+    name: string,
+  ): Promise<boolean> {
     const { databaseId } = clientMetadata;
     try {
-      this.logger.debug('Checking if recommendations exist', clientMetadata, names);
+      this.logger.debug(`Checking is recommendation ${name} exist`, clientMetadata);
+      const recommendation = await this.repository.findOneBy({ databaseId, name });
+
+      this.logger.debug(`Succeed to check is recommendation ${name} exist'`, clientMetadata);
+      return !!recommendation;
+    } catch (err) {
+      this.logger.error(`Failed to check is recommendation ${name} exist'`, err, clientMetadata);
+      return false;
+    }
+  }
 
-      const results = await Promise.all(names.map((name) => this.repository.findOneBy({ databaseId, name })));
+  /**
+   * Check if one or more recommendations exist in database
+   * @param clientMetadata
+   * @param names
+   */
+  async isExistMulti(clientMetadata: ClientMetadata, names: string[]): Promise<Map<string, boolean>> {
+    const { databaseId } = clientMetadata;
+
+    try {
+      this.logger.debug('Checking if recommendations exist', names, clientMetadata);
+
+      const results = await Promise.all(
+        names.map((name) => this.repository.findOneBy({ databaseId, name })),
+      );
 
       return results.reduce((acc, result, idx) => ({
         ...acc,
         [names[idx]]: !!result,
       }), {} as Map<string, boolean>);
     } catch (err) {
-      this.logger.error('Failed to check existence of recommendations', err, clientMetadata, names);
+      this.logger.error('Failed to check existence of recommendations', err, names, clientMetadata);
       return {} as Map<string, boolean>;
     }
   }