Merge pull request #2632 from RedisInsight/be/feature/RI-4988-filter-cloud-plans

#RI-4988 add feature config for plan filters

Author: vlad-dargel

redisinsight/api/config/features-config.json

@@ -1,5 +1,5 @@
 {
-  "version": 2.34,
+  "version": 2.3401,
   "features": {
     "insightsRecommendations": {
       "flag": true,
@@ -28,6 +28,11 @@
         }
       ],
       "data": {
+        "filterFreePlan": [{
+          "field": "name",
+          "expression": "^(No HA?.)|(Cache?.)",
+          "options": "i"
+        }],
         "selectPlan": {
           "components": {
             "triggersAndFunctions": [

redisinsight/api/src/modules/cloud/subscription/cloud-subscription.api.service.spec.ts

@@ -5,24 +5,24 @@ import {
   mockCloudSubscriptionApiProvider,
   mockCloudSubscriptionCapiService,
   mockCloudSubscriptionRegions,
+  mockFeatureService,
   mockSessionMetadata,
   mockSubscriptionPlanResponse,
   MockType,
 } from 'src/__mocks__';
 import { CloudApiUnauthorizedException } from 'src/modules/cloud/common/exceptions';
 import { CloudCapiKeyService } from 'src/modules/cloud/capi-key/cloud-capi-key.service';
+import { FeatureService } from 'src/modules/feature/feature.service';
 import { CloudSubscriptionApiService } from './cloud-subscription.api.service';
-import { CloudUserApiService } from '../user/cloud-user.api.service';
 import { CloudSessionService } from '../session/cloud-session.service';
 import { CloudSubscriptionCapiService } from './cloud-subscription.capi.service';
 import { CloudSubscriptionApiProvider } from './providers/cloud-subscription.api.provider';
 
 describe('CloudSubscriptionApiService', () => {
   let service: CloudSubscriptionApiService;
   let api: MockType<CloudSubscriptionApiProvider>;
-  let sessionService: MockType<CloudSessionService>;
-  let cloudUserApiService: MockType<CloudUserApiService>;
-  let cloudSubscriptionCapiService: MockType<CloudSubscriptionCapiService>;
+  let capi: MockType<CloudSubscriptionCapiService>;
+  let featureService: MockType<FeatureService>;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -44,11 +44,17 @@ describe('CloudSubscriptionApiService', () => {
           provide: CloudCapiKeyService,
           useFactory: mockCloudCapiKeyService,
         },
+        {
+          provide: FeatureService,
+          useFactory: mockFeatureService,
+        },
       ],
     }).compile();
 
     service = module.get(CloudSubscriptionApiService);
     api = module.get(CloudSubscriptionApiProvider);
+    capi = module.get(CloudSubscriptionCapiService);
+    featureService = module.get(FeatureService);
   });
 
   describe('getSubscriptionPlans', () => {
@@ -61,6 +67,55 @@ describe('CloudSubscriptionApiService', () => {
         CloudApiUnauthorizedException,
       );
     });
+
+    describe('filter', () => {
+      beforeEach(() => {
+        featureService.getByName.mockResolvedValueOnce({
+          flag: true,
+          data: {
+            filterFreePlan: [{
+              field: 'name',
+              expression: '^(No HA?.)|(Cache?.)',
+              options: 'i',
+            }],
+          },
+        });
+      });
+
+      it('get empty list due to filter', async () => {
+        capi.getSubscriptionsPlans.mockResolvedValueOnce([
+          { name: 'some name', price: 0 },
+        ]);
+        expect(await service.getSubscriptionPlans(mockSessionMetadata)).toEqual([]);
+      });
+
+      it('filter only "no ha" and "cache" plans', async () => {
+        capi.getSubscriptionsPlans.mockResolvedValueOnce([
+          { name: 'some name', price: 0 },
+          { name: 'no thing', price: 0 },
+          { name: 'No HA', price: 0 },
+          { name: 'No HA 30MB price:0', price: 0 },
+          { name: 'No HA 30MB price:1', price: 1 },
+          { name: 'no ha 30MB', price: 0 },
+          { name: 'no ha', price: 0 },
+          { name: 'Cache', price: 0 },
+          { name: 'Cache 30MB', price: 0 },
+          { name: 'cache', price: 0 },
+          { name: 'cache 30MB', price: 0 },
+          { name: '', price: 0 },
+        ]);
+        expect(await service.getSubscriptionPlans(mockSessionMetadata)).toEqual([
+          { name: 'No HA', price: 0 },
+          { name: 'No HA 30MB price:0', price: 0 },
+          { name: 'no ha 30MB', price: 0 },
+          { name: 'no ha', price: 0 },
+          { name: 'Cache', price: 0 },
+          { name: 'Cache 30MB', price: 0 },
+          { name: 'cache', price: 0 },
+          { name: 'cache 30MB', price: 0 },
+        ]);
+      });
+    });
   });
 
   describe('getCloudRegions', () => {

redisinsight/api/src/modules/cloud/subscription/cloud-subscription.api.service.ts

@@ -4,6 +4,8 @@ import { SessionMetadata } from 'src/common/models';
 import { wrapHttpError } from 'src/common/utils';
 import { CloudRequestUtm, ICloudApiCredentials } from 'src/modules/cloud/common/models';
 import { CloudCapiKeyService } from 'src/modules/cloud/capi-key/cloud-capi-key.service';
+import { FeatureService } from 'src/modules/feature/feature.service';
+import { KnownFeatures } from 'src/modules/feature/constants';
 import { CloudSubscriptionCapiService } from './cloud-subscription.capi.service';
 import { CloudSubscriptionRegion, CloudSubscriptionType } from './models';
 import { CloudSessionService } from '../session/cloud-session.service';
@@ -20,6 +22,7 @@ export class CloudSubscriptionApiService {
     private readonly sessionService: CloudSessionService,
     private readonly cloudCapiKeyService: CloudCapiKeyService,
     private readonly cloudSubscriptionCapiService: CloudSubscriptionCapiService,
+    private readonly featureService: FeatureService,
   ) {}
 
   /**
@@ -42,9 +45,22 @@ export class CloudSubscriptionApiService {
         ),
       ]);
 
+      const cloudSsoFeature = await this.featureService.getByName(KnownFeatures.CloudSso);
+
       const freePlans = filter(
         fixedPlans,
-        ({ price, name }) => price === 0 && name.startsWith('Cache'),
+        (plan) => {
+          if (plan.price !== 0) {
+            return false;
+          }
+
+          if (!cloudSsoFeature?.data?.filterFreePlan?.length) {
+            return true;
+          }
+
+          return !!((cloudSsoFeature?.data?.filterFreePlan).find((f) => f.expression
+            && (new RegExp(f.expression, f.options)).test(plan[f?.field])));
+        },
       );
 
       return freePlans.map((plan) => ({