added Tests support for Grpc

Author: sharan-bruno

packages/bruno-app/src/components/RequestPane/GrpcRequestPane/index.js

@@ -15,6 +15,7 @@ import StyledWrapper from './StyledWrapper';
 import { hasEffectiveAuth } from 'utils/auth';
 import { AUTH_MODES_GRPC } from 'utils/common/constants';
 import Script from 'components/RequestPane/Script';
+import Tests from 'components/RequestPane/Tests';
 
 const GrpcRequestPane = ({ item, collection, handleRun }) => {
   const dispatch = useDispatch();
@@ -50,6 +51,9 @@ const GrpcRequestPane = ({ item, collection, handleRun }) => {
       case 'scripts': {
         return <Script protocol="grpc" item={item} collection={collection} />;
       }
+      case 'tests': {
+        return <Tests item={item} collection={collection} protocol="grpc" />;
+      }
       default: {
         return <div className="mt-4">404 | Not found</div>;
       }
@@ -59,6 +63,10 @@ const GrpcRequestPane = ({ item, collection, handleRun }) => {
   const body = getPropertyFromDraftOrRequest(item, 'request.body');
   const headers = getPropertyFromDraftOrRequest(item, 'request.headers');
   const docs = getPropertyFromDraftOrRequest(item, 'request.docs');
+  const script = getPropertyFromDraftOrRequest(item, 'request.script');
+  const tests = getPropertyFromDraftOrRequest(item, 'request.tests');
+  const hasTestError = item.testScriptErrorMessage;
+
   const itemAuthMode = item.draft?.request?.auth?.mode ?? item.request?.auth?.mode ?? item.root?.request?.auth?.mode;
   const hasAuth = useMemo(
     () => hasEffectiveAuth(collection, item, AUTH_MODES_GRPC),
@@ -72,6 +80,7 @@ const GrpcRequestPane = ({ item, collection, handleRun }) => {
   const isClientStreaming = request.methodType === 'client-streaming' || request.methodType === 'bidi-streaming';
 
   const allTabs = useMemo(() => {
+    const hasScriptError = item.preRequestScriptErrorMessage || item.onMessageScriptErrorMessage || item.postResponseScriptErrorMessage;
     const getMessageIndicator = () => {
       if (grpcMessagesCount > 0) {
         return isClientStreaming ? (
@@ -107,10 +116,15 @@ const GrpcRequestPane = ({ item, collection, handleRun }) => {
       {
         key: 'scripts',
         label: 'Scripts',
-        indicator: docs && docs.length > 0 ? <StatusDot type="default" /> : null
+        indicator: (script.req || script.stream || script.res) ? (hasScriptError ? <StatusDot type="error" /> : <StatusDot />) : null
+      },
+      {
+        key: 'tests',
+        label: 'Tests',
+        indicator: tests && tests.length > 0 ? hasTestError ? <StatusDot type="error" /> : <StatusDot type="default" /> : null
       }
     ];
-  }, [grpcMessagesCount, isClientStreaming, activeHeadersLength, hasAuth, docs]);
+  }, [grpcMessagesCount, isClientStreaming, activeHeadersLength, hasAuth, tests, hasTestError, docs, item.preRequestScriptErrorMessage, item.onMessageScriptErrorMessage, item.postResponseScriptErrorMessage]);
 
   // Initialize tab to 'body' if no tab is currently set
   useEffect(() => {

packages/bruno-app/src/components/RequestPane/Script/index.js

@@ -208,7 +208,7 @@ const Script = ({ item, collection, protocol = 'http' }) => {
             className="mt-2"
             dataTestId={`${phase.key}-script-editor`}
           >
-            {renderEditor(phase)}
+            {activeTab === phase.key ? renderEditor(phase) : null}
           </TabsContent>
         ))}
       </Tabs>

packages/bruno-app/src/components/RequestPane/Tests/index.js

@@ -10,7 +10,15 @@ import { useTheme } from 'providers/Theme';
 import { usePersistedState } from 'hooks/usePersistedState';
 import { useFocusErrorLine } from 'hooks/useFocusErrorLine';
 
-const Tests = ({ item, collection }) => {
+/**
+ * @typedef {Object} TestsProps
+ * @property {Object} item - The request item (http or grpc).
+ * @property {Object} collection - The collection the item belongs to.
+ * @property {'http' | 'grpc'} [protocol] - Request protocol; defaults to 'http'.
+ */
+
+/** @param {TestsProps} props */
+const Tests = ({ item, collection, protocol = 'http' }) => {
   const dispatch = useDispatch();
   const testsEditorRef = useRef(null);
   const tests = item.draft ? get(item, 'draft.request.tests') : get(item, 'request.tests');
@@ -46,6 +54,7 @@ const Tests = ({ item, collection }) => {
         ref={testsEditorRef}
         collection={collection}
         item={item}
+        protocol={protocol}
         docKey="tests"
         value={tests || ''}
         theme={displayedTheme}

packages/bruno-app/src/components/ResponsePane/GrpcResponsePane/index.js

@@ -18,6 +18,8 @@ import ResponseLayoutToggle from '../ResponseLayoutToggle';
 import ResponsiveTabs from 'ui/ResponsiveTabs';
 import ScriptError from '../ScriptError';
 import ScriptErrorIcon from '../ScriptErrorIcon';
+import TestResults from '../TestResults';
+import TestResultsLabel from '../TestResultsLabel';
 
 const GrpcResponsePane = ({ item, collection }) => {
   const dispatch = useDispatch();
@@ -80,6 +82,18 @@ const GrpcResponsePane = ({ item, collection }) => {
       key: 'timeline',
       label: 'Timeline',
       indicator: null
+    },
+    {
+      key: 'tests',
+      label: (
+        <TestResultsLabel
+          results={item.testResults}
+          assertionResults={item.assertionResults}
+          preRequestTestResults={item.preRequestTestResults}
+          postResponseTestResults={item.postResponseTestResults}
+        />
+      ),
+      indicator: null
     }
   ];
 
@@ -97,6 +111,17 @@ const GrpcResponsePane = ({ item, collection }) => {
       case 'timeline': {
         return <Timeline collection={collection} item={item} activeTabUid={activeTabUid} />;
       }
+      case 'tests': {
+        return (
+          <TestResults
+            item={item}
+            results={item.testResults}
+            assertionResults={item.assertionResults}
+            preRequestTestResults={item.preRequestTestResults}
+            postResponseTestResults={item.postResponseTestResults}
+          />
+        );
+      }
       default: {
         return <div>404 | Not found</div>;
       }

packages/bruno-electron/src/ipc/network/grpc-event-handlers.js

@@ -1,7 +1,7 @@
 // To implement grpc event handlers
 const { ipcMain, app } = require('electron');
 const { GrpcClient } = require('@usebruno/requests');
-const { ScriptRuntime, formatErrorWithContextV2 } = require('@usebruno/js');
+const { ScriptRuntime, TestRuntime, formatErrorWithContextV2 } = require('@usebruno/js');
 const decomment = require('decomment');
 const { safeParseJSON, safeStringifyJSON } = require('../../utils/common');
 const { cloneDeep, get } = require('lodash');
@@ -365,6 +365,85 @@ const registerGrpcEventHandlers = (window) => {
     return { scriptResult, scriptError };
   };
 
+  /**
+   * Run the gRPC request tests (the `tests` block) once the call terminates.
+   * Mirrors the HTTP post-response test execution: runs the test source stored in
+   * the .bru file against the collected responses, emits the `test-results` event,
+   * and surfaces any test script error via a `test-script-execution` event so the
+   * existing ScriptError card renders for gRPC too.
+   *
+   * @returns {{ testResults: object | null, testError: Error | null }}
+   */
+  const runResponseTests = async ({
+    request,
+    collection,
+    envVars,
+    runtimeVariables,
+    processEnvVars,
+    scriptingConfig,
+    requestUid,
+    itemUid,
+    responses
+  }) => {
+    const testFile = get(request, 'tests');
+    if (typeof testFile !== 'string' || !testFile.length) {
+      return { testResults: null, testError: null };
+    }
+
+    const testRuntime = new TestRuntime({ runtime: scriptingConfig?.runtime });
+    let testResults = null;
+    let testError = null;
+    try {
+      testResults = await testRuntime.runTests(
+        decomment(testFile, { space: true }),
+        request,
+        { responses: responses || [] },
+        envVars,
+        runtimeVariables,
+        collection.pathname,
+        onConsoleLog,
+        processEnvVars,
+        scriptingConfig,
+        null,
+        collection.name
+      );
+    } catch (error) {
+      testError = error;
+      // Preserve any test() calls that passed before the script errored
+      testResults = error.partialResults || {
+        request,
+        envVariables: envVars,
+        runtimeVariables,
+        globalEnvironmentVariables: request?.globalEnvironmentVariables || {},
+        results: [],
+        nextRequestName: null
+      };
+    }
+
+    sendEvent('main:run-request-event', {
+      type: 'test-results',
+      results: testResults.results,
+      requestUid,
+      itemUid,
+      collectionUid: collection.uid
+    });
+
+    sendEvent('main:run-request-event', {
+      type: 'test-script-execution',
+      requestUid,
+      itemUid,
+      collectionUid: collection.uid,
+      errorMessage: testError ? (testError.message || 'An error occurred while executing the test script') : null,
+      errorContext: testError
+        ? formatErrorWithContextV2(testError, 'test', request?.testsMetadata, collection.pathname)
+        : null
+    });
+
+    propagateScriptEnvUpdates(testResults, request, collection);
+
+    return { testResults, testError };
+  };
+
   ipcMain.handle('connections-changed', (event) => {
     sendEvent('grpc:connections-changed', event);
   });
@@ -416,13 +495,23 @@ const registerGrpcEventHandlers = (window) => {
           }
         : undefined;
 
-      // 3. After Response — script.res (fires once on terminal event).
+      // 3. After Response — script.res then tests (fire once on terminal event).
       // `responses` is the full list of received messages, collected by the gRPC client.
-      const onAfterResponse = preparedRequest?.script?.res?.length
+      const hasAfterResponseScript = !!preparedRequest?.script?.res?.length;
+      const afterResponseTests = get(preparedRequest, 'tests');
+      const hasTests = typeof afterResponseTests === 'string' && afterResponseTests.length > 0;
+      const onAfterResponse = (hasAfterResponseScript || hasTests)
         ? (responses) => {
             if (onMessageErrored) return;
-            runAfterResponseScript({ ...scriptContext, responses }).catch((err) => {
-              console.error('Error running gRPC after-response script:', err);
+            (async () => {
+              if (hasAfterResponseScript) {
+                await runAfterResponseScript({ ...scriptContext, responses });
+              }
+              if (hasTests) {
+                await runResponseTests({ ...scriptContext, responses });
+              }
+            })().catch((err) => {
+              console.error('Error running gRPC after-response script/tests:', err);
             });
           }
         : undefined;

packages/bruno-electron/src/ipc/network/prepare-grpc-request.js

@@ -161,6 +161,8 @@ const prepareGrpcRequest = async (item, collection, environment, runtimeVariable
     body: request.body,
     protoPath: request.protoPath,
     script: request.script,
+    tests: request.tests,
+    testsMetadata: request.testsMetadata,
     // Add variable properties for interpolation
     vars: request.vars,
     collectionVariables: request.collectionVariables,