#RI-4796 - add tests in SSO module

redisinsight/api/src/__mocks__/cloud-capi-key.ts

@@ -1,5 +1,7 @@
 import { CloudCapiAuthDto } from 'src/modules/cloud/common/dto';
 import { CloudCapiKey, ICloudApiCapiAccessKey, ICloudApiCapiKey } from 'src/modules/cloud/capi-key/model';
+import { CloudCapiKeyEntity } from 'src/modules/cloud/capi-key/entity/cloud-capi-key.entity';
+import { EncryptionStrategy } from 'src/modules/encryption/models';
 import { mockServer } from 'src/__mocks__/server';
 
 export const mockCloudCapiAuthDto: CloudCapiAuthDto = {
@@ -31,6 +33,16 @@ export const mockCloudCapiKey = Object.assign(new CloudCapiKey(), {
   lastUsed: new Date(),
 });
 
+export const mockCapiKeyEncrypted = 'cloudCapiKey.capiKey_ENCRYPTED';
+export const mockCapiSecretEncrypted = 'cloudCapiKey.capiSecret_ENCRYPTED';
+
+export const mockCloudCapiKeyEntity = Object.assign(new CloudCapiKeyEntity(), {
+  ...mockCloudCapiKey,
+  capiKey: mockCapiKeyEncrypted,
+  capiSecret: mockCapiSecretEncrypted,
+  encryption: EncryptionStrategy.KEYTAR,
+});
+
 export const mockCloudCapiKeyApiProvider = jest.fn(() => ({
   enableCapi: jest.fn().mockResolvedValue(mockCloudApiCapiAccessKey.accessKey),
   createCapiKey: jest.fn().mockResolvedValue(mockCloudApiCapiKey),

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

@@ -4,3 +4,9 @@ export const mockCapiUnauthorizedError = {
     status: 401,
   },
 };
+
+export const mockUtm = {
+  source: 'redisinsight',
+  medium: 'app',
+  campaign: 'workbench',
+};

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

@@ -0,0 +1,40 @@
+import { CloudJobStatus, CloudJobStep } from 'src/modules/cloud/job/models/cloud-job-info';
+import { CloudJobName } from 'src/modules/cloud/job/constants';
+import { CloudJobRunMode } from 'src/modules/cloud/job/models';
+import { CloudJob } from 'src/modules/cloud/job/jobs';
+import { mockSessionMetadata } from 'src/__mocks__/common';
+
+export const mockCreateDatabaseCloudJobDataDto = {
+  name: CloudJobName.CreateFreeDatabase,
+  runMode: CloudJobRunMode.Async,
+  data: { planId: 123 },
+};
+
+export const mockCloudJobInfo = {
+  id: 'job-id',
+  name: CloudJobName.CreateFreeDatabase,
+  status: CloudJobStatus.Running,
+  step: CloudJobStep.Database,
+};
+
+export abstract class MockCloudJob extends CloudJob {
+  constructor() {
+    super({
+      abortController: new AbortController(),
+      sessionMetadata: mockSessionMetadata,
+    });
+  }
+}
+
+MockCloudJob['getWriteStream'] = jest.fn();
+MockCloudJob['addProfilerClient'] = jest.fn();
+MockCloudJob['removeProfilerClient'] = jest.fn();
+MockCloudJob['setAlias'] = jest.fn();
+MockCloudJob['destroy'] = jest.fn();
+MockCloudJob['getState'] = jest.fn().mockReturnValue(mockCloudJobInfo);
+
+export const mockCloudJobProvider = jest.fn(() => ({
+  addJob: jest.fn().mockResolvedValue(mockCloudJobInfo),
+  get: jest.fn().mockResolvedValue(MockCloudJob),
+  findUserJobs: jest.fn().mockResolvedValue([MockCloudJob]),
+}));

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

@@ -6,3 +6,7 @@ export const mockCloudTaskInit: ICloudCapiTask = {
   status: 'initialized',
   timestamp: '2023-07-01T00:00:00.000Z',
 };
+
+export const mockCloudTaskCapiProvider = jest.fn(() => ({
+  getTask: jest.fn().mockResolvedValue(mockCloudTaskInit),
+}));

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

@@ -10,7 +10,7 @@ import {
 import { ICloudApiCredentials } from 'src/modules/cloud/common/models';
 import config from 'src/utils/config';
 import { classToPlain } from 'class-transformer';
-import { mockCloudApiCapiAccessKey, mockCloudCapiAuthDto } from 'src/__mocks__/cloud-capi-key';
+import { mockCloudApiCapiAccessKey, mockCloudCapiAuthDto, mockCloudCapiKey } from 'src/__mocks__/cloud-capi-key';
 
 const serverConfig = config.get('server');
 
@@ -103,7 +103,7 @@ export const mockCloudUser = Object.assign(new CloudUser(), {
   name: mockCloudApiUser.name,
   currentAccountId: +mockCloudApiUser.current_account_id,
   accounts: [mockCloudUserAccount],
-  capiKey: mockCloudCapiAuthDto.capiKey,
+  capiKey: mockCloudCapiKey,
 });
 
 export const mockCloudUserSafe = classToPlain(mockCloudUser); // omits all data in the "security" group
@@ -125,4 +125,7 @@ export const mockCloudUserRepository = jest.fn(() => ({
 
 export const mockCloudUserApiService = jest.fn(() => ({
   getCapiKeys: jest.fn().mockResolvedValue(mockCloudCapiAuthDto),
+  me: jest.fn().mockResolvedValue(mockCloudUser),
+  setCurrentAccount: jest.fn(),
+  updateUser: jest.fn(),
 }));

redisinsight/api/src/__mocks__/index.ts

@@ -32,3 +32,4 @@ export * from './cloud-user';
 export * from './cloud-common';
 export * from './session';
 export * from './cloud-session';
+export * from './cloud-job';

redisinsight/api/src/modules/cloud/capi-key/cloud-capi-key.analytics.spec.ts

@@ -0,0 +1,53 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { InternalServerErrorException } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { TelemetryEvents } from 'src/constants';
+import { CloudCapiKeyAnalytics } from 'src/modules/cloud/capi-key/cloud-capi-key.analytics';
+
+describe('CloudCapiKeyAnalytics', () => {
+  let service: CloudCapiKeyAnalytics;
+  let sendEventSpy;
+  let sendFailedEventMethod;
+  const httpException = new InternalServerErrorException();
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        EventEmitter2,
+        CloudCapiKeyAnalytics,
+      ],
+    }).compile();
+
+    service = await module.get(CloudCapiKeyAnalytics);
+    sendEventSpy = jest.spyOn<CloudCapiKeyAnalytics, any>(service, 'sendEvent');
+    sendFailedEventMethod = jest.spyOn<CloudCapiKeyAnalytics, any>(
+      service,
+      'sendFailedEvent',
+    );
+  });
+
+  describe('sendCloudAccountKeyGenerated', () => {
+    it('should emit succeed event with manifest "yes"', () => {
+      service.sendCloudAccountKeyGenerated();
+
+      expect(sendEventSpy).toHaveBeenNthCalledWith(
+        1,
+        TelemetryEvents.CloudAccountKeyGenerated,
+      );
+    });
+  });
+
+  describe('sendCloudAccountKeyGenerationFailed', () => {
+    it('should emit 1 event with "Error" cause', () => {
+      service.sendCloudAccountKeyGenerationFailed(httpException);
+
+      expect(sendFailedEventMethod).toHaveBeenNthCalledWith(
+        1,
+        TelemetryEvents.CloudAccountKeyGenerationFailed,
+        httpException,
+      );
+    });
+  });
+});

redisinsight/api/src/modules/cloud/capi-key/cloud-capi-key.service.spec.ts

@@ -1,18 +1,30 @@
 import { Test, TestingModule } from '@nestjs/testing';
+import { BadRequestException } from '@nestjs/common';
 import { CloudCapiKeyService } from 'src/modules/cloud/capi-key/cloud-capi-key.service';
 import { CloudCapiKeyApiProvider } from 'src/modules/cloud/capi-key/cloud-capi-key.api.provider';
 import { CloudCapiKeyRepository } from 'src/modules/cloud/capi-key/repository/cloud-capi-key.repository';
 import {
   mockCloudCapiKey, mockCloudCapiKeyAnalytics,
   mockCloudSessionService, mockCloudUserApiService, mockRepository, mockServerService,
+  mockSessionMetadata,
+  mockCloudUser,
+  mockUtm,
+  MockType,
 } from 'src/__mocks__';
 import { CloudUserApiService } from 'src/modules/cloud/user/cloud-user.api.service';
 import { CloudSessionService } from 'src/modules/cloud/session/cloud-session.service';
 import { ServerService } from 'src/modules/server/server.service';
 import { CloudCapiKeyAnalytics } from 'src/modules/cloud/capi-key/cloud-capi-key.analytics';
+import { CloudApiBadRequestException } from 'src/modules/cloud/common/exceptions';
 
 describe('CloudCapiKeyService', () => {
   let service: CloudCapiKeyService;
+  let api: CloudCapiKeyApiProvider;
+  let repository: CloudCapiKeyRepository;
+  let cloudUserApiService: MockType<CloudUserApiService>;
+  let cloudSessionService: CloudSessionService;
+  let serverService: ServerService;
+  let analytics: CloudCapiKeyAnalytics;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -45,13 +57,40 @@ describe('CloudCapiKeyService', () => {
       ],
     }).compile();
 
-    service = module.get(CloudCapiKeyService);
+    service = await module.get(CloudCapiKeyService);
+    api = await module.get(CloudCapiKeyApiProvider);
+    repository = await module.get(CloudCapiKeyRepository);
+    cloudUserApiService = await module.get(CloudUserApiService);
+    cloudSessionService = await module.get(CloudSessionService);
+    serverService = await module.get(ServerService);
+    analytics = await module.get(CloudCapiKeyAnalytics);
   });
 
   describe('generateName', () => {
-    it('successfully get cloud databases', async () => {
+    it('successfully generate capi key name', async () => {
       expect(await service['generateName'](mockCloudCapiKey))
         .toEqual(mockCloudCapiKey.name);
     });
   });
+
+  describe('ensureCapiKeys', () => {
+    it('Should return exist capi key', async () => {
+      expect(await service['ensureCapiKeys'](mockSessionMetadata, mockUtm))
+        .toEqual(mockCloudUser.capiKey);
+    });
+    it('Should throw CloudApiBadRequestException', async () => {
+      cloudUserApiService.me.mockResolvedValue(null);
+      CloudUserApiService.getCurrentAccount(null);
+      await expect(service['ensureCapiKeys'](mockSessionMetadata, mockUtm))
+        .rejects.toThrowError(CloudApiBadRequestException);
+    });
+  });
+
+  describe('handleCapiKeyUnauthorizedError', () => {
+    it('should show BadRequestException error', async () => {
+      const mockError = new BadRequestException('error');
+      expect(await service.handleCapiKeyUnauthorizedError(mockError, mockSessionMetadata))
+        .toEqual(new BadRequestException('error'));
+    });
+  });
 });