#RI-3030, #RI-3032, #RI-3034, #RI-3036 Itests

Author: Artem

redisinsight/api/src/modules/cli/utils/getUnsupportedCommands.spec.ts

@@ -2,7 +2,7 @@ import { getUnsupportedCommands } from './getUnsupportedCommands';
 
 describe('cli unsupported commands', () => {
   it('should return correct list', () => {
-    const expectedResult = ['monitor', 'subscribe', 'psubscribe', 'sync', 'psync', 'script debug'];
+    const expectedResult = ['monitor', 'subscribe', 'psubscribe', 'ssubscribe', 'sync', 'psync', 'script debug'];
 
     expect(getUnsupportedCommands()).toEqual(expectedResult);
   });

redisinsight/api/src/modules/profiler/models/log-file.ts

@@ -124,7 +124,7 @@ export class LogFile {
       this.writeStream?.close();
       this.writeStream = null;
       const size = this.getFileSize();
-      fs.unlink(this.filePath);
+      fs.unlinkSync(this.filePath);
 
       this.analyticsEvents.get(TelemetryEvents.ProfilerLogDeleted)(this.instanceId, size);
     } catch (e) {

redisinsight/api/src/modules/pub-sub/pub-sub.controller.ts

@@ -1,6 +1,6 @@
 import {
   Body,
-  Controller, Param, Post,
+  Controller, Param, Post, UsePipes, ValidationPipe
 } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { ApiRedisInstanceOperation } from 'src/decorators/api-redis-instance-operation.decorator';
@@ -11,6 +11,7 @@ import { PublishResponse } from 'src/modules/pub-sub/dto/publish.response';
 
 @ApiTags('Pub/Sub')
 @Controller('pub-sub')
+@UsePipes(new ValidationPipe())
 export class PubSubController {
   constructor(private service: PubSubService) {}
 

redisinsight/api/src/modules/pub-sub/pub-sub.gateway.ts

@@ -31,24 +31,14 @@ export class PubSubGateway implements OnGatewayConnection, OnGatewayDisconnect {
 
   @SubscribeMessage(PubSubClientEvents.Subscribe)
   async subscribe(@Client() client: UserClient, @Body() dto: SubscribeDto): Promise<any> {
-    try {
-      await this.service.subscribe(client, dto);
-      return { status: 'ok' };
-    } catch (e) {
-      this.logger.error('Unable to subscribe', e);
-      throw e;
-    }
+    await this.service.subscribe(client, dto);
+    return { status: 'ok' };
   }
 
   @SubscribeMessage(PubSubClientEvents.Unsubscribe)
   async unsubscribe(@Client() client: UserClient, @Body() dto: SubscribeDto): Promise<any> {
-    try {
-      await this.service.unsubscribe(client, dto);
-      return { status: 'ok' };
-    } catch (e) {
-      this.logger.error('Unable to unsubscribe', e);
-      throw e;
-    }
+    await this.service.unsubscribe(client, dto);
+    return { status: 'ok' };
   }
 
   async handleConnection(client: Socket): Promise<void> {

redisinsight/api/src/modules/pub-sub/pub-sub.service.ts

@@ -33,7 +33,12 @@ export class PubSubService {
       )));
     } catch (e) {
       this.logger.error('Unable to create subscriptions', e);
-      throw e;
+
+      if (e instanceof HttpException) {
+        throw e;
+      }
+
+      throw catchAclError(e);
     }
   }
 
@@ -49,7 +54,13 @@ export class PubSubService {
         this.subscriptionProvider.createSubscription(userClient, subDto),
       )));
     } catch (e) {
-      this.logger.error('Unable to create subscriptions', e);
+      this.logger.error('Unable to unsubscribe', e);
+
+      if (e instanceof HttpException) {
+        throw e;
+      }
+
+      throw catchAclError(e);
     }
   }
 

redisinsight/api/src/modules/workbench/utils/getUnsupportedCommands.spec.ts

@@ -2,7 +2,7 @@ import { getUnsupportedCommands } from './getUnsupportedCommands';
 
 describe('workbench unsupported commands', () => {
   it('should return correct list', () => {
-    const expectedResult = ['monitor', 'subscribe', 'psubscribe', 'sync', 'psync', 'script debug', 'select'];
+    const expectedResult = ['monitor', 'subscribe', 'psubscribe', 'ssubscribe', 'sync', 'psync', 'script debug', 'select'];
 
     expect(getUnsupportedCommands()).toEqual(expectedResult);
   });

redisinsight/api/test/api/info/GET-info-cli-unsupported-commands.test.ts

@@ -27,7 +27,7 @@ describe('GET /info/cli-unsupported-commands', () => {
       name: 'Should return array with unsupported commands for CLI tool',
       statusCode: 200,
       responseSchema,
-      responseBody: ['monitor', 'subscribe', 'psubscribe', 'sync', 'psync', 'script debug'],
+      responseBody: ['monitor', 'subscribe', 'psubscribe', 'ssubscribe', 'sync', 'psync', 'script debug'],
     },
   ].map(mainCheckFn);
 });

redisinsight/api/test/api/pub-sub/POST-instance-id-pub-sub-messages.test.ts

@@ -0,0 +1,144 @@
+import {
+  describe,
+  it,
+  before,
+  deps,
+  Joi,
+  requirements,
+  generateInvalidDataTestCases,
+  validateInvalidDataTestCase,
+  validateApiCall
+} from '../deps';
+import { Socket } from 'socket.io-client';
+const { server, request, constants, rte, getSocket } = deps;
+
+// endpoint to test
+const endpoint = (instanceId = constants.TEST_INSTANCE_ID) =>
+  request(server).post(`/instance/${instanceId}/pub-sub/messages`);
+
+const dataSchema = Joi.object({
+  channel: Joi.string().required(),
+  message: Joi.string().required(),
+}).messages({
+  'any.required': '{#label} should not be empty',
+}).strict();
+
+const validInputData = {
+  channel: constants.TEST_PUB_SUB_CHANNEL_1,
+  message: constants.TEST_PUB_SUB_MESSAGE_1,
+};
+
+const responseSchema = Joi.object().keys({
+  affected: Joi.number().integer().required().min(0),
+}).required().strict();
+
+const mainCheckFn = async (testCase) => {
+  it(testCase.name, async () => {
+    // additional checks before test run
+    if (testCase.before) {
+      await testCase.before();
+    }
+
+    await validateApiCall({
+      endpoint,
+      ...testCase,
+    });
+
+    // additional checks after test pass
+    if (testCase.after) {
+      await testCase.after();
+    }
+  });
+};
+
+const getClient = async (instanceId): Promise<Socket> => {
+  return getSocket('pub-sub', {
+    query: { instanceId },
+  });
+};
+
+const pSubscription = {
+  channel: '*',
+  type: 'p',
+};
+
+let client;
+
+describe('POST /instance/:instanceId/pub-sub/messages', () => {
+  describe('Validation', () => {
+    generateInvalidDataTestCases(dataSchema, validInputData).map(
+      validateInvalidDataTestCase(endpoint, dataSchema),
+    );
+  });
+
+  describe('Common', () => {
+    beforeEach(async () => {
+      client = await getClient(constants.TEST_INSTANCE_ID);
+      await new Promise((res) => {
+        client.emit('subscribe', { subscriptions: [pSubscription] }, res);
+      });
+    });
+
+    afterEach(async () => {
+      client.close();
+    });
+
+    [
+      {
+        name: 'Should send message',
+        data: {
+          ...validInputData,
+        },
+        responseSchema,
+        statusCode: 201,
+        responseBody: {
+          affected: 1,
+        },
+      },
+      {
+        name: 'Should return NotFound error if instance id does not exists',
+        endpoint: () => endpoint(constants.TEST_NOT_EXISTED_INSTANCE_ID),
+        data: {
+          ...validInputData,
+        },
+        statusCode: 404,
+        responseBody: {
+          statusCode: 404,
+          error: 'Not Found',
+          message: 'Invalid database instance id.',
+        },
+      },
+    ].map(mainCheckFn);
+  });
+
+  describe('ACL', () => {
+    requirements('rte.acl');
+
+    before(async () => await rte.data.generateKeys(true));
+    before(async () => rte.data.setAclUserRules('~* +@all'));
+
+    [
+      {
+        name: 'Should publish method',
+        endpoint: () => endpoint(constants.TEST_INSTANCE_ACL_ID),
+        statusCode: 201,
+        data: {
+          ...validInputData,
+        },
+      },
+      {
+        name: 'Should throw error if no permissions for "publish" command',
+        endpoint: () => endpoint(constants.TEST_INSTANCE_ACL_ID),
+        data: {
+          ...validInputData,
+        },
+        statusCode: 403,
+        responseBody: {
+          statusCode: 403,
+          error: 'Forbidden',
+        },
+        before: () => rte.data.setAclUserRules('~* +@all -publish')
+      },
+    ].map(mainCheckFn);
+  });
+});