Merge pull request #3460 from RedisInsight/be/feature/RI-5156_rdi_tip

#RI-5156 - add rdi tip check

Author: AmirAllayarovSofteq

redisinsight/api/src/constants/recommendations.ts

@@ -15,11 +15,13 @@ export const RECOMMENDATION_NAMES = Object.freeze({
   SET_PASSWORD: 'setPassword',
   RTS: 'RTS',
   REDIS_VERSION: 'redisVersion',
+  TRY_RDI: 'tryRDI',
   SEARCH_INDEXES: 'searchIndexes',
   SEARCH_JSON: 'searchJSON',
   STRING_TO_JSON: 'stringToJson',
   SEARCH_VISUALIZATION: 'searchVisualization',
   SEARCH_HASH: 'searchHash',
+
 });
 
 export const ONE_NODE_RECOMMENDATIONS = [

redisinsight/api/src/modules/database-recommendation/scanner/recommendation.provider.spec.ts

@@ -17,6 +17,7 @@ import {
   BigStringStrategy,
   CompressionForListStrategy,
   BigAmountConnectedClientsStrategy,
+  TryRdiStrategyStrategy,
 } from 'src/modules/database-recommendation/scanner/strategies';
 
 describe('RecommendationProvider', () => {
@@ -51,6 +52,7 @@ describe('RecommendationProvider', () => {
       [RECOMMENDATION_NAMES.BIG_STRINGS, new BigStringStrategy()],
       [RECOMMENDATION_NAMES.COMPRESSION_FOR_LIST, new CompressionForListStrategy()],
       [RECOMMENDATION_NAMES.BIG_AMOUNT_OF_CONNECTED_CLIENTS, new BigAmountConnectedClientsStrategy()],
+      [RECOMMENDATION_NAMES.TRY_RDI, new TryRdiStrategyStrategy()],
       ['default', new DefaultRecommendationStrategy()],
       ['unknown', new DefaultRecommendationStrategy()],
       [null, new DefaultRecommendationStrategy()],

redisinsight/api/src/modules/database-recommendation/scanner/recommendation.provider.ts

@@ -18,6 +18,7 @@ import {
   BigStringStrategy,
   CompressionForListStrategy,
   BigAmountConnectedClientsStrategy,
+  TryRdiStrategyStrategy,
 } from 'src/modules/database-recommendation/scanner/strategies';
 
 @Injectable()
@@ -43,6 +44,7 @@ export class RecommendationProvider {
     this.strategies.set(RECOMMENDATION_NAMES.BIG_STRINGS, new BigStringStrategy());
     this.strategies.set(RECOMMENDATION_NAMES.COMPRESSION_FOR_LIST, new CompressionForListStrategy());
     this.strategies.set(RECOMMENDATION_NAMES.BIG_AMOUNT_OF_CONNECTED_CLIENTS, new BigAmountConnectedClientsStrategy());
+    this.strategies.set(RECOMMENDATION_NAMES.TRY_RDI, new TryRdiStrategyStrategy());
   }
 
   getStrategy(type: string): IRecommendationStrategy {

redisinsight/api/src/modules/database-recommendation/scanner/strategies/index.ts

@@ -13,3 +13,4 @@ export * from './avoid-lua-scripts.strategy';
 export * from './big-string.strategy';
 export * from './compression-for-list.strategy';
 export * from './big-amount-connected-clients.strategy';
+export * from './try-rdi.strategy';

redisinsight/api/src/modules/database-recommendation/scanner/strategies/try-rdi.strategy.spec.ts

@@ -0,0 +1,39 @@
+import { TryRdiStrategyStrategy } from 'src/modules/database-recommendation/scanner/strategies';
+import { RedisClientConnectionType } from 'src/modules/redis/client';
+import { HostingProvider } from 'src/modules/database/entities/database.entity';
+
+const mockClusterConnectionType = RedisClientConnectionType.CLUSTER;
+const mockNotClusterConnectionType = RedisClientConnectionType.STANDALONE;
+
+const mockREProvider = HostingProvider.RE_CLUSTER;
+const mockNotREProvider = HostingProvider.RE_CLOUD;
+
+describe('TryRdiStrategyStrategy', () => {
+  let strategy: TryRdiStrategyStrategy;
+
+  beforeEach(async () => {
+    strategy = new TryRdiStrategyStrategy();
+  });
+
+  describe('isRecommendationReached', () => {
+    it('should return true when connectionType is cluster', async () => {
+      expect(await strategy.isRecommendationReached({ connectionType: mockClusterConnectionType, provider: mockNotREProvider }))
+        .toEqual({ isReached: true });
+    });
+
+    it('should return true when provider is Redis Enterprise', async () => {
+      expect(await strategy.isRecommendationReached({ connectionType: mockNotClusterConnectionType, provider: mockREProvider }))
+        .toEqual({ isReached: true });
+    });
+
+    it('should return true when provider is Redis Enterprise and connectionType is cluster', async () => {
+      expect(await strategy.isRecommendationReached({ connectionType: mockClusterConnectionType, provider: mockREProvider }))
+        .toEqual({ isReached: true });
+    });
+
+    it('should return false when provider is not Redis Enterprise and connectionType is not cluster', async () => {
+      expect(await strategy.isRecommendationReached({ connectionType: mockNotClusterConnectionType, provider: mockNotREProvider }))
+        .toEqual({ isReached: false });
+    });
+  });
+});

redisinsight/api/src/modules/database-recommendation/scanner/strategies/try-rdi.strategy.ts

@@ -0,0 +1,22 @@
+import { AbstractRecommendationStrategy }
+  from 'src/modules/database-recommendation/scanner/strategies/abstract.recommendation.strategy';
+import { IDatabaseRecommendationStrategyData }
+  from 'src/modules/database-recommendation/scanner/recommendation.strategy.interface';
+import { HostingProvider } from 'src/modules/database/entities/database.entity';
+import { RedisClientConnectionType } from 'src/modules/redis/client';
+
+export class TryRdiStrategyStrategy extends AbstractRecommendationStrategy {
+  /**
+   * Check try rdi recommendation
+   * @param data
+   */
+
+  async isRecommendationReached(
+    data: { provider: HostingProvider, connectionType: RedisClientConnectionType },
+  ): Promise<IDatabaseRecommendationStrategyData> {
+    const isReCLusterOrCluster = data.provider === HostingProvider.RE_CLUSTER
+      || data.connectionType === RedisClientConnectionType.CLUSTER;
+
+    return { isReached: isReCLusterOrCluster };
+  }
+}

redisinsight/api/src/modules/database/database-connection.service.spec.ts

@@ -1,18 +1,19 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { get } from 'lodash';
+import { when, resetAllWhenMocks } from 'jest-when';
 import {
   mockCommonClientMetadata,
   mockDatabase,
   mockDatabaseAnalytics,
   mockDatabaseInfoProvider,
   mockDatabaseRepository,
   mockDatabaseService,
-  mockStandaloneRedisClient,
   mockDatabaseRecommendationService,
   MockType,
   mockRedisGeneralInfo,
   mockRedisClientListResult,
   mockDatabaseClientFactory,
+  mockFeatureService,
 } from 'src/__mocks__';
 import { DatabaseAnalytics } from 'src/modules/database/database.analytics';
 import { DatabaseService } from 'src/modules/database/database.service';
@@ -22,15 +23,19 @@ import { DatabaseInfoProvider } from 'src/modules/database/providers/database-in
 import { DatabaseConnectionService } from 'src/modules/database/database-connection.service';
 import { RECOMMENDATION_NAMES } from 'src/constants';
 import { DatabaseClientFactory } from 'src/modules/database/providers/database.client.factory';
+import { FeatureService } from 'src/modules/feature/feature.service';
+import { KnownFeatures } from 'src/modules/feature/constants';
 
 describe('DatabaseConnectionService', () => {
   let service: DatabaseConnectionService;
   let analytics: MockType<DatabaseAnalytics>;
   let recommendationService: MockType<DatabaseRecommendationService>;
   let databaseInfoProvider: MockType<DatabaseInfoProvider>;
+  let featureService: MockType<FeatureService>;
 
   beforeEach(async () => {
     jest.clearAllMocks();
+    resetAllWhenMocks();
 
     const module: TestingModule = await Test.createTestingModule({
       providers: [
@@ -59,13 +64,22 @@ describe('DatabaseConnectionService', () => {
           provide: DatabaseRecommendationService,
           useFactory: mockDatabaseRecommendationService,
         },
+        {
+          provide: FeatureService,
+          useFactory: mockFeatureService,
+        },
       ],
     }).compile();
 
     service = await module.get(DatabaseConnectionService);
     analytics = await module.get(DatabaseAnalytics);
     recommendationService = module.get(DatabaseRecommendationService);
     databaseInfoProvider = module.get(DatabaseInfoProvider);
+    featureService = module.get(FeatureService);
+
+    featureService.getByName.mockResolvedValue({
+      flag: false,
+    });
   });
 
   describe('connect', () => {
@@ -95,6 +109,38 @@ describe('DatabaseConnectionService', () => {
       );
     });
 
+    it('should call check try rdi recommendation', async () => {
+      featureService.getByName.mockResolvedValueOnce({
+        flag: true,
+      });
+
+      expect(await service.connect(mockCommonClientMetadata)).toEqual(undefined);
+
+      expect(recommendationService.check).toHaveBeenCalledTimes(4);
+
+      expect(recommendationService.check).toBeCalledWith(
+        mockCommonClientMetadata,
+        RECOMMENDATION_NAMES.REDIS_VERSION,
+        mockRedisGeneralInfo,
+      );
+      expect(recommendationService.check).toBeCalledWith(
+        mockCommonClientMetadata,
+        RECOMMENDATION_NAMES.LUA_SCRIPT,
+        mockRedisGeneralInfo,
+      );
+      expect(recommendationService.check).toBeCalledWith(
+        mockCommonClientMetadata,
+        RECOMMENDATION_NAMES.BIG_AMOUNT_OF_CONNECTED_CLIENTS,
+        mockRedisGeneralInfo,
+      );
+
+      expect(recommendationService.check).toBeCalledWith(
+        mockCommonClientMetadata,
+        RECOMMENDATION_NAMES.TRY_RDI,
+        { connectionType: 'STANDALONE', provider: undefined },
+      );
+    });
+
     it('should call databaseInfoProvider', async () => {
       expect(await service.connect(mockCommonClientMetadata)).toEqual(undefined);
 

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

@@ -8,6 +8,8 @@ import { Database } from 'src/modules/database/models/database';
 import { ClientMetadata } from 'src/common/models';
 import { DatabaseClientFactory } from 'src/modules/database/providers/database.client.factory';
 import { RedisClient, RedisClientConnectionType } from 'src/modules/redis/client';
+import { FeatureService } from 'src/modules/feature/feature.service';
+import { KnownFeatures } from 'src/modules/feature/constants';
 
 @Injectable()
 export class DatabaseConnectionService {
@@ -18,6 +20,7 @@ export class DatabaseConnectionService {
     private readonly databaseInfoProvider: DatabaseInfoProvider,
     private readonly repository: DatabaseRepository,
     private readonly analytics: DatabaseAnalytics,
+    private readonly featureService: FeatureService,
     private recommendationService: DatabaseRecommendationService,
   ) {}
 
@@ -27,7 +30,6 @@ export class DatabaseConnectionService {
    */
   async connect(clientMetadata: ClientMetadata): Promise<void> {
     const client = await this.databaseClientFactory.getOrCreateClient(clientMetadata);
-
     // refresh modules list and last connected time
     // mark database as not a new
     // will be refreshed after user navigate to particular database from the databases list
@@ -39,8 +41,9 @@ export class DatabaseConnectionService {
       version: await this.databaseInfoProvider.determineDatabaseServer(client),
     };
 
+    const connectionType = client?.getConnectionType();
     // Update cluster nodes db record
-    if (client?.getConnectionType() === RedisClientConnectionType.CLUSTER) {
+    if (connectionType === RedisClientConnectionType.CLUSTER) {
       toUpdate.nodes = (await client.nodes()).map(({ options }) => ({
         host: options.host,
         port: options.port,
@@ -67,6 +70,17 @@ export class DatabaseConnectionService {
       generalInfo,
     );
 
+    const rdiFeature = await this.featureService.getByName(KnownFeatures.Rdi);
+
+    if (rdiFeature?.flag) {
+      const database = await this.repository.get(clientMetadata.databaseId);
+      this.recommendationService.check(
+        clientMetadata,
+        RECOMMENDATION_NAMES.TRY_RDI,
+        { connectionType, provider: database.provider },
+      );
+    }
+
     this.collectClientInfo(clientMetadata, client, generalInfo?.version);
 
     this.logger.log(`Succeed to connect to database ${clientMetadata.databaseId}`);

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

@@ -129,6 +129,10 @@ export class RecommendationService {
         RECOMMENDATION_NAMES.SEARCH_VISUALIZATION,
         () => null,
       ],
+      [
+        RECOMMENDATION_NAMES.TRY_RDI,
+        () => null,
+      ],
     ]);
 
     const recommendationsToDetermine = difference(Object.values(RECOMMENDATION_NAMES), exclude);

redisinsight/ui/src/components/index.ts

@@ -23,12 +23,17 @@ import ImportDatabasesDialog from './import-databases-dialog'
 import OnboardingTour from './onboarding-tour'
 import CodeBlock from './code-block'
 import ShowChildByCondition from './show-child-by-condition'
-import RecommendationVoting from './recommendation-voting'
-import RecommendationCopyComponent from './recommendation-copy-component'
 import FeatureFlagComponent from './feature-flag-component'
 import AutoRefresh from './auto-refresh'
 import { ModuleNotLoaded, FilterNotAvailable } from './messages'
 import RdiInstanceHeader from './rdi-instance-header'
+import {
+  RecommendationBody,
+  RecommendationBadges,
+  RecommendationBadgesLegend,
+  RecommendationCopyComponent,
+  RecommendationVoting,
+} from './recommendation'
 
 export { FullScreen } from './full-screen'
 
@@ -71,4 +76,7 @@ export {
   FilterNotAvailable,
   AutoRefresh,
   RdiInstanceHeader,
+  RecommendationBody,
+  RecommendationBadges,
+  RecommendationBadgesLegend,
 }