#RI-2509-add tests

Author: AmirAllayarovSofteq

redisinsight/api/src/modules/workbench/models/command-execution-result.ts

@@ -25,12 +25,6 @@ export class CommandExecutionResult {
   })
   response: any;
 
-  @ApiPropertyOptional({
-    type: Boolean,
-    description: 'Result did not stored in db',
-  })
-  isNotStored?: boolean;
-
   @ApiPropertyOptional({
     type: () => ClusterNode,
     description: 'Redis Cluster Node info',

redisinsight/api/src/modules/workbench/models/command-execution.ts

@@ -70,6 +70,13 @@ export class CommandExecution {
   @Expose()
   result: CommandExecutionResult[];
 
+  @ApiPropertyOptional({
+    type: Boolean,
+    description: 'Result did not stored in db',
+  })
+  @Expose()
+  isNotStored?: boolean;
+
   @ApiPropertyOptional({
     description: 'Nodes roles where command was executed',
     default: ClusterNodeRole.All,

redisinsight/api/src/modules/workbench/plugins.service.spec.ts

@@ -7,6 +7,7 @@ import {
   ClusterNodeRole,
   CreateCommandExecutionDto,
   RunQueryMode,
+  ResultsMode,
 } from 'src/modules/workbench/dto/create-command-execution.dto';
 import { CommandExecutionResult } from 'src/modules/workbench/models/command-execution-result';
 import { CommandExecutionStatus } from 'src/modules/cli/dto/cli.dto';
@@ -34,6 +35,7 @@ const mockCreateCommandExecutionDto: CreateCommandExecutionDto = {
   },
   role: ClusterNodeRole.All,
   mode: RunQueryMode.ASCII,
+  resultsMode: ResultsMode.Default,
 };
 
 const mockCommandExecutionResults: CommandExecutionResult[] = [

redisinsight/api/src/modules/workbench/providers/command-execution.provider.ts

@@ -31,13 +31,14 @@ export class CommandExecutionProvider {
    */
   async createMany(commandExecutions: Partial<CommandExecution>[]): Promise<CommandExecution[]> {
     // todo: limit by 30 max to insert
-    let entities = await Promise.all(commandExecutions.map(async (commandExecution) => {
+    let notStoredIndexes = {}
+    let entities = await Promise.all(commandExecutions.map(async (commandExecution, idx) => {
       const entity = plainToClass(CommandExecutionEntity, commandExecution);
 
       // Do not store command execution result that exceeded limitation
-      if (JSON.stringify(entity.result).length > WORKBENCH_CONFIG.maxResultSize) {
-        // eslint-disable-next-line no-param-reassign
-        commandExecution.result[0].isNotStored = true;
+      // if (JSON.stringify(entity.result).length > WORKBENCH_CONFIG.maxResultSize) {
+      if (JSON.stringify(entity.result).length > 1000) {
+        notStoredIndexes[idx] = true;
         entity.result = JSON.stringify([
           {
             status: CommandExecutionStatus.Success,
@@ -60,10 +61,11 @@ export class CommandExecutionProvider {
           result: commandExecutions[idx].result,
           nodeOptions: commandExecutions[idx].nodeOptions,
           summary: commandExecutions[idx].summary,
+          isNotStored: notStoredIndexes[idx] || false,
         },
       )),
     );
-
+    this.logger.log(response[0].isNotStored)
     // cleanup history and ignore error if any
     try {
       await this.cleanupDatabaseHistory(entities[0].databaseId);

redisinsight/api/src/modules/workbench/workbench.service.spec.ts

@@ -35,6 +35,21 @@ const mockCreateCommandExecutionDto: CreateCommandExecutionDto = {
   mode: RunQueryMode.ASCII,
   resultsMode: ResultsMode.Default,
 };
+
+const mockCommands = ["set 1 1", "get 1"];
+
+const mockCreateCommandExecutionDtoWithGroupMode: CreateCommandExecutionsDto = {
+  commands: mockCommands,
+  nodeOptions: {
+    host: '127.0.0.1',
+    port: 7002,
+    enableRedirection: true,
+  },
+  role: ClusterNodeRole.All,
+  mode: RunQueryMode.ASCII,
+  resultsMode: ResultsMode.GroupMode,
+};
+
 const mockCreateCommandExecutionsDto: CreateCommandExecutionsDto = {
   commands: [
     mockCreateCommandExecutionDto.command,
@@ -66,6 +81,21 @@ const mockCommandExecution: CommandExecution = new CommandExecution({
   result: mockCommandExecutionResults,
 });
 
+const mockSendCommandResultSuccess = { response: "1", status: "success" };
+const mockSendCommandResultFail = { response: "error", status: "fail" };
+
+const mockCommandExecutionWithGroupMode = {
+  mode: "ASCII",
+  commands: mockCommands,
+  resultsMode: "GROUP_MODE",
+  databaseId: "d05043d0 - 0d12- 4ce1-9ca3 - 30c6d7e391ea",
+  summary: { "total": 2, "success": 1, "fail": 1 },
+  command: "set 1 1\r\nget 1",
+  result: [{
+    "status": "success", "response": [{ "response": "OK", "status": "success", "command": "set 1 1" }, { "response": "error", "status": "fail", "command": "get 1" }]
+  }]
+}
+
 const mockCommandExecutionProvider = () => ({
   createMany: jest.fn(),
   getList: jest.fn(),
@@ -158,6 +188,41 @@ describe('WorkbenchService', () => {
 
       expect(result).toEqual([mockCommandExecution, mockCommandExecution]);
     });
+
+    it('should successfully execute commands and save in group mode view', async () => {
+      when(workbenchCommandsExecutor.sendCommand)
+        .calledWith(mockClientOptions, expect.anything())
+        .mockResolvedValue([mockSendCommandResultSuccess]);
+
+      commandExecutionProvider.createMany.mockResolvedValueOnce([mockCommandExecutionWithGroupMode]);
+
+      const result = await service.createCommandExecutions(
+        mockClientOptions,
+        mockCreateCommandExecutionDtoWithGroupMode,
+      );
+
+      expect(result).toEqual([mockCommandExecutionWithGroupMode]);
+    });
+
+    it('should successfully execute commands with error and save summary', async () => {
+      when(workbenchCommandsExecutor.sendCommand)
+        .calledWith(mockClientOptions, {...mockCreateCommandExecutionDtoWithGroupMode, command: mockCommands[0]})
+        .mockResolvedValue([mockSendCommandResultSuccess]);
+      
+      when(workbenchCommandsExecutor.sendCommand)
+        .calledWith(mockClientOptions, {...mockCreateCommandExecutionDtoWithGroupMode, command: mockCommands[1]})
+        .mockResolvedValue([mockSendCommandResultFail]);
+
+      commandExecutionProvider.createMany.mockResolvedValueOnce([mockCommandExecutionWithGroupMode]);
+
+      const result = await service.createCommandExecutions(
+        mockClientOptions,
+        mockCreateCommandExecutionDtoWithGroupMode,
+      );
+
+      expect(result).toEqual([mockCommandExecutionWithGroupMode]);
+    });
+
     it('should throw an error when command execution failed', async () => {
       workbenchCommandsExecutor.sendCommand.mockRejectedValueOnce(new BadRequestException('error'));
 

redisinsight/ui/src/components/query-card/QueryCard.tsx

@@ -17,7 +17,7 @@ import { sendEventTelemetry, TelemetryEvent } from 'uiSrc/telemetry'
 import { toggleOpenWBResult } from 'uiSrc/slices/workbench/wb-results'
 
 import QueryCardHeader from './QueryCardHeader'
-import QueryCardCliResult from './QueryCardCliResultWrapper'
+import QueryCardCliResultWrapper from './QueryCardCliResultWrapper'
 import QueryCardCliPlugin from './QueryCardCliPlugin'
 import QueryCardCommonResult, { CommonErrorResponse } from './QueryCardCommonResult'
 
@@ -35,6 +35,7 @@ export interface Props {
   summary?: ResultsSummary
   createdAt?: Date
   loading?: boolean
+  isNotStored?: boolean
   onQueryDelete: () => void
   onQueryReRun: () => void
   onQueryOpen: () => void
@@ -67,6 +68,7 @@ const QueryCard = (props: Props) => {
     onQueryReRun,
     loading,
     emptyCommand,
+    isNotStored,
   } = props
 
   const { visualizations = [] } = useSelector(appPluginsSelector)
@@ -175,11 +177,12 @@ const QueryCard = (props: Props) => {
               : (
                 <>
                   {resultsMode === ResultsMode.GroupMode && (
-                    <QueryCardCliResult
+                    <QueryCardCliResultWrapper
                       loading={loading}
                       query={command}
                       resultsMode={resultsMode}
                       result={result}
+                      isNotStored={isNotStored}
                       data-testid="group-mode-card"
                     />
                   )}
@@ -203,11 +206,12 @@ const QueryCard = (props: Props) => {
                         </>
                       )}
                       {(viewTypeSelected === WBQueryType.Text) && (
-                        <QueryCardCliResult
+                        <QueryCardCliResultWrapper
                           loading={loading}
                           query={command}
                           resultsMode={resultsMode}
                           result={result}
+                          isNotStored={isNotStored}
                         />
                       )}
                     </>

redisinsight/ui/src/components/query-card/QueryCardCliDefaultResult/QueryCardCliDefaultResult.spec.tsx

@@ -1,7 +1,7 @@
 import React from 'react'
 import { instance, mock } from 'ts-mockito'
 import { render } from 'uiSrc/utils/test-utils'
-import QueryCardCliDefaultResult, { Props, resultTestId } from './QueryCardCliDefaultResult'
+import QueryCardCliDefaultResult, { Props } from './QueryCardCliDefaultResult'
 
 const mockedProps = mock<Props>()
 
@@ -20,7 +20,7 @@ describe('QueryCardCliDefaultResult', () => {
       <QueryCardCliDefaultResult {...instance(mockedProps)} result={mockResult} />
     )
 
-    const resultEl = queryByTestId(resultTestId)
+    const resultEl = queryByTestId('query-cli-group-result')
 
     expect(resultEl).toHaveTextContent('(nil)')
   })

redisinsight/ui/src/components/query-card/QueryCardCliDefaultResult/QueryCardCliDefaultResult.tsx

@@ -8,13 +8,11 @@ export interface Props {
   result: Maybe<CommandExecutionResult[]>
 }
 
-export const resultTestId = 'query-cli-group-result'
-
 const QueryCardCliGroupResult = (props: Props) => {
   const { result = [], query } = props
 
   return (
-    <div data-testid={resultTestId}>
+    <div data-testid="query-cli-group-result">
       {result?.map(({ response, status }) =>
         cliParseTextResponse(response || '(nil)', query, status, CliPrefix.QueryCard))}
     </div>

redisinsight/ui/src/components/query-card/QueryCardCliGroupResult/QueryCardCliGroupResult.spec.tsx

@@ -15,8 +15,6 @@ describe('QueryCardCliGroupResult', () => {
   })
 
   it('Should render result when result is undefined', () => {
-    const mockResult = undefined
-
-    expect(render(<QueryCardCliGroupResult result={mockResult} />)).toBeTruthy()
+    expect(render(<QueryCardCliGroupResult />)).toBeTruthy()
   })
 })

redisinsight/ui/src/components/query-card/QueryCardCliGroupResult/QueryCardCliGroupResult.tsx

@@ -4,7 +4,7 @@ import { CommandExecutionResult } from 'uiSrc/slices/interfaces'
 import { cliParseCommandsGroupResult, Maybe } from 'uiSrc/utils'
 
 export interface Props {
-  result: Maybe<CommandExecutionResult[]>
+  result?: Maybe<CommandExecutionResult[]>
 }
 
 const QueryCardCliGroupResult = (props: Props) => {