#RI-4530 redactor redis-cloud module to be a part of cloud autodiscov…

redisinsight/api/.jest.setup.ts

@@ -0,0 +1,7 @@
+// Workaround for @Type test coverage
+jest.mock("class-transformer", () => {
+  return {
+    ...(jest.requireActual("class-transformer") as Object),
+    Type: (f: Function) => f() && jest.requireActual("class-transformer").Type(f),
+  };
+});

redisinsight/api/config/ormconfig.ts

@@ -17,6 +17,7 @@ import { BrowserHistoryEntity } from 'src/modules/browser/entities/browser-histo
 import { CustomTutorialEntity } from 'src/modules/custom-tutorial/entities/custom-tutorial.entity';
 import { FeatureEntity } from 'src/modules/feature/entities/feature.entity';
 import { FeaturesConfigEntity } from 'src/modules/feature/entities/features-config.entity';
+import { CloudDatabaseDetailsEntity } from 'src/modules/cloud/autodiscovery/entities/cloud-database-details.entity';
 import migrations from '../migration';
 import * as config from '../src/utils/config';
 
@@ -44,6 +45,7 @@ const ormConfig = {
     CustomTutorialEntity,
     FeatureEntity,
     FeaturesConfigEntity,
+    CloudDatabaseDetailsEntity,
   ],
   migrations,
 };

redisinsight/api/migration/1687166457712-cloud-database-details.ts

@@ -0,0 +1,22 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class CloudDatabaseDetails1687166457712 implements MigrationInterface {
+    name = 'CloudDatabaseDetails1687166457712'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "database_cloud_details" ("id" varchar PRIMARY KEY NOT NULL, "cloudId" integer NOT NULL, "subscriptionType" varchar NOT NULL, "planMemoryLimit" integer, "memoryLimitMeasurementUnit" integer, "databaseId" varchar, CONSTRAINT "REL_f41ee5027391b3be8ad95e3d15" UNIQUE ("databaseId"))`);
+        await queryRunner.query(`CREATE TABLE "temporary_database_cloud_details" ("id" varchar PRIMARY KEY NOT NULL, "cloudId" integer NOT NULL, "subscriptionType" varchar NOT NULL, "planMemoryLimit" integer, "memoryLimitMeasurementUnit" integer, "databaseId" varchar, CONSTRAINT "REL_f41ee5027391b3be8ad95e3d15" UNIQUE ("databaseId"), CONSTRAINT "FK_f41ee5027391b3be8ad95e3d158" FOREIGN KEY ("databaseId") REFERENCES "database_instance" ("id") ON DELETE CASCADE ON UPDATE NO ACTION)`);
+        await queryRunner.query(`INSERT INTO "temporary_database_cloud_details"("id", "cloudId", "subscriptionType", "planMemoryLimit", "memoryLimitMeasurementUnit", "databaseId") SELECT "id", "cloudId", "subscriptionType", "planMemoryLimit", "memoryLimitMeasurementUnit", "databaseId" FROM "database_cloud_details"`);
+        await queryRunner.query(`DROP TABLE "database_cloud_details"`);
+        await queryRunner.query(`ALTER TABLE "temporary_database_cloud_details" RENAME TO "database_cloud_details"`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "database_cloud_details" RENAME TO "temporary_database_cloud_details"`);
+        await queryRunner.query(`CREATE TABLE "database_cloud_details" ("id" varchar PRIMARY KEY NOT NULL, "cloudId" integer NOT NULL, "subscriptionType" varchar NOT NULL, "planMemoryLimit" integer, "memoryLimitMeasurementUnit" integer, "databaseId" varchar, CONSTRAINT "REL_f41ee5027391b3be8ad95e3d15" UNIQUE ("databaseId"))`);
+        await queryRunner.query(`INSERT INTO "database_cloud_details"("id", "cloudId", "subscriptionType", "planMemoryLimit", "memoryLimitMeasurementUnit", "databaseId") SELECT "id", "cloudId", "subscriptionType", "planMemoryLimit", "memoryLimitMeasurementUnit", "databaseId" FROM "temporary_database_cloud_details"`);
+        await queryRunner.query(`DROP TABLE "temporary_database_cloud_details"`);
+        await queryRunner.query(`DROP TABLE "database_cloud_details"`);
+    }
+
+}

redisinsight/api/migration/index.ts

@@ -32,6 +32,7 @@ import { customTutorials1677135091633 } from './1677135091633-custom-tutorials';
 import { databaseRecommendations1681900503586 } from './1681900503586-database-recommendations';
 import { databaseRecommendationParams1683006064293 } from './1683006064293-database-recommendation-params';
 import { Feature1684931530343 } from './1684931530343-feature';
+import { CloudDatabaseDetails1687166457712 } from './1687166457712-cloud-database-details';
 
 export default [
   initialMigration1614164490968,
@@ -68,4 +69,5 @@ export default [
   databaseRecommendations1681900503586,
   databaseRecommendationParams1683006064293,
   Feature1684931530343,
+  CloudDatabaseDetails1687166457712,
 ];

redisinsight/api/package.json

@@ -143,6 +143,7 @@
       ".spec.ts$"
     ],
     "testEnvironment": "node",
+    "setupFilesAfterEnv": ["<rootDir>/../.jest.setup.ts"],
     "moduleNameMapper": {
       "src/(.*)": "<rootDir>/$1",
       "apiSrc/(.*)": "<rootDir>/$1",

redisinsight/api/src/__mocks__/cloud-autodiscovery.ts

@@ -0,0 +1,279 @@
+import {
+  CloudAccountInfo,
+  CloudDatabase, CloudDatabaseProtocol,
+  CloudDatabaseStatus,
+  CloudSubscription,
+  CloudSubscriptionStatus, CloudSubscriptionType, ICloudApiAccount, ICloudApiDatabase, ICloudApiSubscription,
+} from 'src/modules/cloud/autodiscovery/models';
+import {
+  AddCloudDatabaseDto, AddCloudDatabaseResponse,
+  CloudAuthDto,
+  GetCloudSubscriptionDatabaseDto,
+  GetCloudSubscriptionDatabasesDto,
+} from 'src/modules/cloud/autodiscovery/dto';
+import { ActionStatus } from 'src/common/models';
+
+export const mockCloudApiAccount: ICloudApiAccount = {
+  id: 40131,
+  name: 'Redis Labs',
+  createdTimestamp: '2018-12-23T15:15:31Z',
+  updatedTimestamp: '2020-06-03T13:16:59Z',
+  key: {
+    name: 'QA-HashedIn-Test-API-Key-2',
+    accountId: 40131,
+    accountName: 'Redis Labs',
+    allowedSourceIps: ['0.0.0.0/0'],
+    createdTimestamp: '2020-04-06T09:22:38Z',
+    owner: {
+      name: 'Cloud Account',
+      email: '[email protected]',
+    },
+    httpSourceIp: '198.141.36.229',
+  },
+};
+
+export const mockCloudAccountInfo = Object.assign(new CloudAccountInfo(), {
+  accountId: mockCloudApiAccount.id,
+  accountName: mockCloudApiAccount.name,
+  ownerEmail: mockCloudApiAccount.key.owner.email,
+  ownerName: mockCloudApiAccount.key.owner.name,
+});
+
+export const mockCloudApiSubscription: ICloudApiSubscription = {
+  id: 108353,
+  name: 'external CA',
+  status: CloudSubscriptionStatus.Active,
+  paymentMethodId: 8240,
+  memoryStorage: 'ram',
+  storageEncryption: false,
+  numberOfDatabases: 7,
+  subscriptionPricing: [
+    {
+      type: 'Shards',
+      typeDetails: 'high-throughput',
+      quantity: 2,
+      quantityMeasurement: 'shards',
+      pricePerUnit: 0.124,
+      priceCurrency: 'USD',
+      pricePeriod: 'hour',
+    },
+  ],
+  cloudDetails: [
+    {
+      provider: 'AWS',
+      cloudAccountId: 16424,
+      totalSizeInGb: 0.0323,
+      regions: [
+        {
+          region: 'us-east-1',
+          networking: [
+            {
+              deploymentCIDR: '10.0.0.0/24',
+              subnetId: 'subnet-0a2dd5829daf83024',
+            },
+          ],
+          preferredAvailabilityZones: ['us-east-1a'],
+          multipleAvailabilityZones: false,
+        },
+      ],
+    },
+  ],
+};
+
+export const mockCloudSubscription = Object.assign(new CloudSubscription(), {
+  id: mockCloudApiSubscription.id,
+  type: CloudSubscriptionType.Flexible,
+  name: mockCloudApiSubscription.name,
+  numberOfDatabases: mockCloudApiSubscription.numberOfDatabases,
+  provider: mockCloudApiSubscription.cloudDetails[0].provider,
+  region: mockCloudApiSubscription.cloudDetails[0].regions[0].region,
+  status: mockCloudApiSubscription.status,
+});
+
+export const mockCloudSubscriptionFixed = Object.assign(new CloudSubscription(), {
+  ...mockCloudSubscription,
+  type: CloudSubscriptionType.Fixed,
+});
+
+export const mockCloudApiDatabase: ICloudApiDatabase = {
+  databaseId: 50859754,
+  name: 'bdb',
+  protocol: CloudDatabaseProtocol.Redis,
+  provider: 'GCP',
+  region: 'us-central1',
+  redisVersionCompliance: '5.0.5',
+  status: CloudDatabaseStatus.Active,
+  memoryLimitInGb: 1.0,
+  memoryUsedInMb: 6.0,
+  memoryStorage: 'ram',
+  supportOSSClusterApi: false,
+  dataPersistence: 'none',
+  replication: true,
+  dataEvictionPolicy: 'volatile-lru',
+  throughputMeasurement: {
+    by: 'operations-per-second',
+    value: 25000,
+  },
+  activatedOn: '2019-12-31T09:38:41Z',
+  lastModified: '2019-12-31T09:38:41Z',
+  publicEndpoint:
+    'redis-14621.c34097.us-central1-mz.gcp.qa-cloud.rlrcp.com:14621',
+  privateEndpoint:
+    'redis-14621.internal.c34097.us-central1-mz.gcp.qa-cloud.rlrcp.com:14621',
+  replicaOf: {
+    endpoints: [
+      'redis-19669.c9244.us-central1-mz.gcp.cloud.rlrcp.com:19669',
+      'redis-14074.c9243.us-central1-mz.gcp.cloud.rlrcp.com:14074',
+    ],
+  },
+  clustering: {
+    numberOfShards: 1,
+    regexRules: [],
+    hashingPolicy: 'standard',
+  },
+  security: {
+    sslClientAuthentication: false,
+    sourceIps: ['0.0.0.0/0'],
+  },
+  modules: [
+    {
+      id: 1,
+      name: 'ReJSON',
+      version: 'v10007',
+    },
+  ],
+  alerts: [],
+};
+
+export const mockCloudApiDatabaseFixed: ICloudApiDatabase = {
+  ...mockCloudApiDatabase,
+  protocol: CloudDatabaseProtocol.Stack,
+  planMemoryLimit: 256,
+  memoryLimitMeasurementUnit: 'MB',
+};
+
+export const mockCloudDatabase = Object.assign(new CloudDatabase(), {
+  subscriptionId: mockCloudSubscription.id,
+  subscriptionType: CloudSubscriptionType.Flexible,
+  databaseId: mockCloudApiDatabase.databaseId,
+  name: mockCloudApiDatabase.name,
+  publicEndpoint: mockCloudApiDatabase.publicEndpoint,
+  status: mockCloudApiDatabase.status,
+  sslClientAuthentication: false,
+  modules: ['ReJSON'],
+  options: {
+    enabledBackup: false,
+    enabledClustering: false,
+    enabledDataPersistence: false,
+    enabledRedisFlash: false,
+    enabledReplication: true,
+    isReplicaDestination: true,
+    persistencePolicy: 'none',
+  },
+  cloudDetails: {
+    cloudId: mockCloudApiDatabase.databaseId,
+    subscriptionType: CloudSubscriptionType.Flexible,
+  },
+});
+
+export const mockCloudDatabaseFixed = Object.assign(new CloudDatabase(), {
+  ...mockCloudDatabase,
+  subscriptionType: CloudSubscriptionType.Fixed,
+  cloudDetails: {
+    cloudId: mockCloudApiDatabase.databaseId,
+    subscriptionType: CloudSubscriptionType.Fixed,
+    planMemoryLimit: mockCloudApiDatabaseFixed.planMemoryLimit,
+    memoryLimitMeasurementUnit: mockCloudApiDatabaseFixed.memoryLimitMeasurementUnit,
+  },
+});
+
+export const mockCloudDatabaseFromList = Object.assign(new CloudDatabase(), {
+  ...mockCloudDatabase,
+  options: {
+    ...mockCloudDatabase.options,
+    isReplicaSource: false,
+  },
+});
+
+export const mockCloudDatabaseFromListFixed = Object.assign(new CloudDatabase(), {
+  ...mockCloudDatabaseFixed,
+  options: {
+    ...mockCloudDatabaseFixed.options,
+    isReplicaSource: false,
+  },
+});
+
+export const mockCloudApiSubscriptionDatabases = {
+  accountId: mockCloudAccountInfo.accountId,
+  subscription: [
+    {
+      subscriptionId: mockCloudSubscription.id,
+      numberOfDatabases: mockCloudSubscription.numberOfDatabases,
+      databases: [mockCloudApiDatabase],
+    },
+  ],
+};
+
+export const mockCloudApiSubscriptionDatabasesFixed = {
+  ...mockCloudApiSubscriptionDatabases,
+  subscription: {
+    ...mockCloudApiSubscriptionDatabases.subscription[0],
+    databases: [mockCloudApiDatabaseFixed],
+  },
+};
+
+export const mockCloudAuthDto: CloudAuthDto = {
+  apiKey: 'api_key',
+  apiSecret: 'api_secret_key',
+};
+
+export const mockGetCloudSubscriptionDatabasesDto = Object.assign(new GetCloudSubscriptionDatabasesDto(), {
+  subscriptionId: mockCloudSubscription.id,
+  subscriptionType: mockCloudSubscription.type,
+});
+
+export const mockGetCloudSubscriptionDatabasesDtoFixed = Object.assign(new GetCloudSubscriptionDatabasesDto(), {
+  subscriptionId: mockCloudSubscription.id,
+  subscriptionType: CloudSubscriptionType.Fixed,
+});
+
+export const mockGetCloudSubscriptionDatabaseDto = Object.assign(new GetCloudSubscriptionDatabaseDto(), {
+  subscriptionId: mockCloudSubscription.id,
+  subscriptionType: mockCloudSubscription.type,
+  databaseId: mockCloudDatabase.databaseId,
+});
+
+export const mockGetCloudSubscriptionDatabaseDtoFixed = Object.assign(new GetCloudSubscriptionDatabaseDto(), {
+  ...mockGetCloudSubscriptionDatabaseDto,
+  subscriptionType: mockCloudSubscriptionFixed.type,
+});
+
+export const mockAddCloudDatabaseDto = Object.assign(new AddCloudDatabaseDto(), {
+  ...mockGetCloudSubscriptionDatabaseDto,
+});
+
+export const mockAddCloudDatabaseDtoFixed = Object.assign(new AddCloudDatabaseDto(), {
+  ...mockGetCloudSubscriptionDatabaseDto,
+  subscriptionType: CloudSubscriptionType.Fixed,
+});
+
+export const mockAddCloudDatabaseResponse = Object.assign(new AddCloudDatabaseResponse(), {
+  ...mockAddCloudDatabaseDto,
+  status: ActionStatus.Success,
+  message: 'Added',
+  databaseDetails: mockCloudDatabase,
+});
+
+export const mockAddCloudDatabaseResponseFixed = Object.assign(new AddCloudDatabaseResponse(), {
+  ...mockAddCloudDatabaseDtoFixed,
+  status: ActionStatus.Success,
+  message: 'Added',
+  databaseDetails: mockCloudDatabaseFixed,
+});
+
+export const mockCloudAutodiscoveryAnalytics = jest.fn(() => ({
+  sendGetRECloudSubsSucceedEvent: jest.fn(),
+  sendGetRECloudSubsFailedEvent: jest.fn(),
+  sendGetRECloudDbsSucceedEvent: jest.fn(),
+  sendGetRECloudDbsFailedEvent: jest.fn(),
+}));

redisinsight/api/src/__mocks__/databases.ts

@@ -15,6 +15,8 @@ import {
   mockSshOptionsPrivateKey,
   mockSshOptionsPrivateKeyEntity,
 } from 'src/__mocks__/ssh';
+import { CloudDatabaseDetails, CloudSubscriptionType } from 'src/modules/cloud/autodiscovery/models';
+import { CloudDatabaseDetailsEntity } from 'src/modules/cloud/autodiscovery/entities/cloud-database-details.entity';
 
 export const mockDatabaseId = 'a77b23c1-7816-4ea4-b61f-d37795a0f805-db-id';
 
@@ -37,11 +39,31 @@ export const mockDatabase = Object.assign(new Database(), {
   compressor: Compressor.NONE,
 });
 
+export const mockDatabaseCloudDetails = Object.assign(new CloudDatabaseDetails(), {
+  subscriptionType: CloudSubscriptionType.Fixed,
+  cloudId: 500001,
+  planMemoryLimit: 256,
+  memoryLimitMeasurementUnit: 'MB',
+});
+
+export const mockDatabaseWithCloudDetails = Object.assign(new Database(), {
+  ...mockDatabase,
+  cloudDetails: mockDatabaseCloudDetails,
+});
+
 export const mockDatabaseEntity = Object.assign(new DatabaseEntity(), {
   ...mockDatabase,
   encryption: null,
 });
 
+export const mockDatabaseEntityWithCloudDetails = Object.assign(new DatabaseEntity(), {
+  ...mockDatabaseEntity,
+  cloudDetails: Object.assign(new CloudDatabaseDetailsEntity(), {
+    id: 'some-uuid',
+    ...mockDatabaseCloudDetails,
+  }),
+});
+
 export const mockDatabaseWithSshBasic = Object.assign(new Database(), {
   ...mockDatabase,
   ssh: true,

redisinsight/api/src/__mocks__/index.ts

@@ -23,3 +23,4 @@ export * from './ssh';
 export * from './browser-history';
 export * from './database-recommendation';
 export * from './feature';
+export * from './cloud-autodiscovery';