@usebruno/js 0.51.0 → 0.52.0

package/src/grpc/grpc-script-runtime.js

@@ -0,0 +1,302 @@
+const chai = require('chai');
+const Bru = require('../bru');
+const BrunoGrpcRequest = require('./bruno-grpc-request');
+const BrunoGrpcResponse = require('./bruno-grpc-response');
+const { cleanJson } = require('../utils');
+const { createBruTestResultMethods } = require('../utils/results');
+const { runScriptInNodeVm } = require('../sandbox/node-vm');
+const { executeQuickJsVmAsync } = require('../sandbox/quickjs');
+const { SANDBOX } = require('../utils/sandbox');
+const { createScopeSetter } = require('../runtime/scripted-entries');
+
+/**
+ * Runs the gRPC lifecycle hooks
+ *
+ * All four hooks share one body (`#runHook`) and differ only in what they put on `bru.grpc` and
+ * what their result object carries — `buildGrpc` and `baseResult` below.
+ *
+ * The shared body mirrors `ScriptRuntime`'s `runRequestScript` / `runResponseScript` step for step,
+ * substituting the gRPC request/response models. Two intentional differences, not oversights:
+ * - `bru.runRequest` rejects instead of running anything.
+ * - The models live under `bru.grpc` rather than as the `req` / `res` globals HTTP scripts get.
+ */
+class GrpcScriptRuntime {
+  constructor(props) {
+    this.runtime = props?.runtime || 'quickjs';
+  }
+
+  /**
+   * @param {object} params
+   * @param {string} params.script - The hook body, already decommented by the caller
+   * @param {object} params.request - The prepared gRPC request
+   * @param {Function} params.buildGrpc - Returns the `bru.grpc` object for this hook
+   * @param {object} [params.baseResult] - Hook-specific fields the shared result is built on top of
+   */
+  async #runHook({
+    script,
+    request,
+    buildGrpc,
+    baseResult = {},
+    envVariables,
+    runtimeVariables,
+    secretVariables,
+    collectionPath,
+    onConsoleLog,
+    processEnvVars,
+    scriptingConfig,
+    collectionName
+  }) {
+    const globalEnvironmentVariables = request?.globalEnvironmentVariables || {};
+    const oauth2CredentialVariables = request?.oauth2CredentialVariables || {};
+    const collectionVariables = request?.collectionVariables || {};
+    const folderVariables = request?.folderVariables || {};
+    const requestVariables = request?.requestVariables || {};
+    const promptVariables = request?.promptVariables || {};
+    const assertionResults = request?.assertionResults || [];
+    const certsAndProxyConfig = request?.certsAndProxyConfig;
+    const scriptPath = request?.pathname;
+    const bru = new Bru({
+      runtime: this.runtime,
+      envVariables,
+      runtimeVariables,
+      processEnvVars,
+      secretVariables,
+      collectionPath,
+      collectionVariables,
+      folderVariables,
+      requestVariables,
+      globalEnvironmentVariables,
+      oauth2CredentialVariables,
+      collectionName,
+      promptVariables,
+      certsAndProxyConfig,
+      requestUrl: request?.url
+    });
+
+    bru.grpc = buildGrpc();
+
+    // extend bru with result getter methods
+    const { __brunoTestResults, test } = createBruTestResultMethods(bru, assertionResults, chai);
+
+    const context = {
+      bru,
+      test,
+      expect: chai.expect,
+      assert: chai.assert,
+      __brunoTestResults: __brunoTestResults,
+      __bruSetScope: createScopeSetter(bru)
+    };
+
+    if (onConsoleLog && typeof onConsoleLog === 'function') {
+      const customLogger = (type) => {
+        return (...args) => {
+          onConsoleLog(type, cleanJson(args));
+        };
+      };
+      context.console = {
+        log: customLogger('log'),
+        debug: customLogger('debug'),
+        info: customLogger('info'),
+        warn: customLogger('warn'),
+        error: customLogger('error')
+      };
+    }
+
+    // A gRPC request can't run another request yet, so there is no `runRequestByItemPathname` to bind.
+    bru.runRequest = () => Promise.reject(new Error('bru.runRequest is not supported in gRPC scripts'));
+
+    const buildScriptResult = () => ({
+      ...baseResult,
+      envVariables: bru._envDirty ? cleanJson(envVariables) : null,
+      runtimeVariables: bru._runtimeVarsDirty ? cleanJson(runtimeVariables) : null,
+      collectionVariables: bru._collVarsDirty ? cleanJson(collectionVariables) : null,
+      globalEnvironmentVariables: bru._globalEnvDirty ? cleanJson(globalEnvironmentVariables) : null,
+      oauth2CredentialsToReset: bru.oauth2CredentialsToReset,
+      results: cleanJson(__brunoTestResults.getResults()),
+      nextRequestName: bru.nextRequest,
+      skipRequest: bru.skipRequest,
+      stopExecution: bru.stopExecution,
+      scriptedRequestEntries: cleanJson(bru.scriptedRequestEntries || [])
+    });
+
+    // Track script errors to attach partial results before re-throwing, so the variables the hook
+    // set before it threw still reach the caller
+    let scriptError = null;
+
+    try {
+      if (this.runtime === SANDBOX.NODEVM) {
+        await runScriptInNodeVm({
+          script,
+          context,
+          collectionPath,
+          scriptingConfig,
+          scriptPath
+        });
+      } else {
+        // default runtime is `quickjs`
+        await executeQuickJsVmAsync({
+          script,
+          context,
+          collectionPath,
+          scriptPath
+        });
+      }
+    } catch (error) {
+      scriptError = error;
+    }
+
+    if (scriptError) {
+      scriptError.partialResults = buildScriptResult();
+      throw scriptError;
+    }
+
+    return buildScriptResult();
+  }
+
+  async runGrpcRequestScript({
+    script,
+    request,
+    envVariables,
+    runtimeVariables,
+    secretVariables,
+    collectionPath,
+    onConsoleLog,
+    processEnvVars,
+    scriptingConfig,
+    collectionName
+  }) {
+    return this.#runHook({
+      script,
+      request,
+      // Initial scope - `request.messages` reports what the call sent, so it is still empty here.
+      buildGrpc: () => ({ request: new BrunoGrpcRequest(request, { metadataWritable: true }) }),
+      baseResult: { request },
+      envVariables,
+      runtimeVariables,
+      secretVariables,
+      collectionPath,
+      onConsoleLog,
+      processEnvVars,
+      scriptingConfig,
+      collectionName
+    });
+  }
+
+  async runGrpcResponseScript({
+    script,
+    request,
+    response,
+    envVariables,
+    runtimeVariables,
+    secretVariables,
+    collectionPath,
+    onConsoleLog,
+    processEnvVars,
+    scriptingConfig,
+    collectionName,
+    sentMessages = []
+  }) {
+    return this.#runHook({
+      script,
+      request,
+      // Passing sentMessages so only messages sent by client is accessible
+      buildGrpc: () => ({
+        request: new BrunoGrpcRequest(request, { sentMessages, metadataWritable: false }),
+        response: new BrunoGrpcResponse(response)
+      }),
+      baseResult: { response },
+      envVariables,
+      runtimeVariables,
+      secretVariables,
+      collectionPath,
+      onConsoleLog,
+      processEnvVars,
+      scriptingConfig,
+      collectionName
+    });
+  }
+
+  /**
+   * `before-message-send`. `message` is the message about to be transmitted; it joins
+   * `request.messages` only once the send succeeds, so the two never overlap.
+   *
+   * `bru.grpc.response` is deliberately absent, matching `beforeCallStart` — even on a bidi stream
+   * where messages have already been received.
+   */
+  async runGrpcBeforeMessageSendScript({
+    script,
+    request,
+    message,
+    envVariables,
+    runtimeVariables,
+    secretVariables,
+    collectionPath,
+    onConsoleLog,
+    processEnvVars,
+    scriptingConfig,
+    collectionName,
+    sentMessages = []
+  }) {
+    return this.#runHook({
+      script,
+      request,
+      buildGrpc: () => ({
+        request: new BrunoGrpcRequest(request, { metadataWritable: false, sentMessages, message })
+      }),
+      // `message` is carried on the result for the planned `message.set`; discarded by callers today.
+      baseResult: { request, message },
+      envVariables,
+      runtimeVariables,
+      secretVariables,
+      collectionPath,
+      onConsoleLog,
+      processEnvVars,
+      scriptingConfig,
+      collectionName
+    });
+  }
+
+  /**
+   * `after-message-receive`. `message` is the message just received, and is also the last entry of
+   * `response.messages` — the call folds it in before the hook runs.
+   *
+   * The `response` here is *partial*: the call is still open, so `statusCode`, `statusText`,
+   * `duration` and `trailers` are not yet known and read as `undefined` / empty. `metadata` is
+   * usually populated, since headers precede the first message.
+   */
+  async runGrpcAfterMessageReceiveScript({
+    script,
+    request,
+    response,
+    message,
+    envVariables,
+    runtimeVariables,
+    secretVariables,
+    collectionPath,
+    onConsoleLog,
+    processEnvVars,
+    scriptingConfig,
+    collectionName,
+    sentMessages = []
+  }) {
+    return this.#runHook({
+      script,
+      request,
+      buildGrpc: () => ({
+        request: new BrunoGrpcRequest(request, { metadataWritable: false, sentMessages }),
+        response: new BrunoGrpcResponse(response, { message })
+      }),
+      baseResult: { response, message },
+      envVariables,
+      runtimeVariables,
+      secretVariables,
+      collectionPath,
+      onConsoleLog,
+      processEnvVars,
+      scriptingConfig,
+      collectionName
+    });
+  }
+}
+
+module.exports = GrpcScriptRuntime;

package/src/index.js

@@ -1,4 +1,5 @@
 const ScriptRuntime = require('./runtime/script-runtime');
+const GrpcScriptRuntime = require('./grpc/grpc-script-runtime');
 const TestRuntime = require('./runtime/test-runtime');
 const VarsRuntime = require('./runtime/vars-runtime');
 const AssertRuntime = require('./runtime/assert-runtime');
@@ -21,6 +22,7 @@ const {
 
 module.exports = {
   ScriptRuntime,
+  GrpcScriptRuntime,
   TestRuntime,
   VarsRuntime,
   AssertRuntime,

package/src/interpolate-string.js

@@ -2,7 +2,7 @@ const { interpolate } = require('@usebruno/common');
 
 const interpolateString = (
   str,
-  { envVariables = {}, runtimeVariables = {}, processEnvVars = {}, collectionVariables = {}, folderVariables = {}, requestVariables = {}, globalEnvironmentVariables = {} }
+  { envVariables = {}, runtimeVariables = {}, iterationData = {}, processEnvVars = {}, collectionVariables = {}, folderVariables = {}, requestVariables = {}, globalEnvironmentVariables = {} }
 ) => {
   if (!str || !str.length || typeof str !== 'string') {
     return str;
@@ -15,6 +15,7 @@ const interpolateString = (
     ...folderVariables,
     ...requestVariables,
     ...runtimeVariables,
+    ...iterationData,
     process: {
       env: {
         ...processEnvVars

package/src/runtime/assert-runtime.js

@@ -362,6 +362,7 @@ const evaluateRhsOperand = (rhsOperand, operator, context, runtime) => {
     folderVariables: context.bru.folderVariables,
     requestVariables: context.bru.requestVariables,
     runtimeVariables: context.bru.runtimeVariables,
+    iterationData: context.bru.runner.iterationData.get(),
     envVariables: context.bru.envVariables,
     processEnvVars: context.bru.processEnvVars
   };

package/src/runtime/script-runtime.js

@@ -73,7 +73,7 @@ class ScriptRuntime {
     const req = new BrunoRequest(request, historyLogger);
 
     // extend bru with result getter methods
-    const { __brunoTestResults, test } = createBruTestResultMethods(bru, assertionResults, chai);
+    const { __brunoTestResults, test, waitForPendingTests } = createBruTestResultMethods(bru, assertionResults, chai);
 
     const context = {
       bru,
@@ -119,6 +119,18 @@ class ScriptRuntime {
       scriptedRequestEntries: cleanJson(bru.scriptedRequestEntries || [])
     });
 
+    const attachScriptResultToOnFailHandler = () => {
+      if (typeof request.onFailHandler !== 'function') {
+        return;
+      }
+
+      const onFailHandler = request.onFailHandler;
+      request.onFailHandler = async (error) => {
+        await onFailHandler(error);
+        return buildRequestScriptResult();
+      };
+    };
+
     // Track script errors to attach partial results before re-throwing
     // This ensures that any test() calls that passed before the error are preserved
     // Similar pattern to test-runtime.js which already handles this correctly
@@ -136,6 +148,7 @@ class ScriptRuntime {
       } catch (error) {
         scriptError = error;
       }
+      await waitForPendingTests();
 
       // If script errored, attach partial results so callers can display passed tests
       // before the error occurred (e.g., 2 tests pass, then script throws)
@@ -144,6 +157,7 @@ class ScriptRuntime {
         throw scriptError;
       }
 
+      attachScriptResultToOnFailHandler();
       return buildRequestScriptResult();
     }
 
@@ -164,6 +178,7 @@ class ScriptRuntime {
       throw scriptError;
     }
 
+    attachScriptResultToOnFailHandler();
     return buildRequestScriptResult();
   }
 
@@ -225,7 +240,7 @@ class ScriptRuntime {
     const res = new BrunoResponse(response);
 
     // extend bru with result getter methods
-    const { __brunoTestResults, test } = createBruTestResultMethods(bru, assertionResults, chai);
+    const { __brunoTestResults, test, waitForPendingTests } = createBruTestResultMethods(bru, assertionResults, chai);
 
     const context = {
       bru,
@@ -289,6 +304,7 @@ class ScriptRuntime {
       } catch (error) {
         scriptError = error;
       }
+      await waitForPendingTests();
 
       // If script errored, attach partial results so callers can display passed tests
       // before the error occurred (e.g., 2 tests pass, then script throws)

package/src/runtime/test-runtime.js

@@ -64,7 +64,7 @@ class TestRuntime {
     const res = new BrunoResponse(response);
 
     // extend bru with result getter methods
-    const { __brunoTestResults, test } = createBruTestResultMethods(bru, assertionResults, chai);
+    const { __brunoTestResults, test, waitForPendingTests } = createBruTestResultMethods(bru, assertionResults, chai);
 
     if (!testsFile || !testsFile.length) {
       return {
@@ -110,8 +110,8 @@ class TestRuntime {
 
     let scriptError = null;
 
-    try {
-      if (this.runtime === SANDBOX.NODEVM) {
+    if (this.runtime === SANDBOX.NODEVM) {
+      try {
         await runScriptInNodeVm({
           script: testsFile,
           context,
@@ -119,17 +119,22 @@ class TestRuntime {
           scriptingConfig,
           scriptPath
         });
-      } else {
-        // default runtime is `quickjs`
+      } catch (error) {
+        scriptError = error;
+      }
+      await waitForPendingTests();
+    } else {
+      // default runtime is `quickjs`
+      try {
         await executeQuickJsVmAsync({
           script: testsFile,
           context: context,
           collectionPath,
           scriptPath
         });
+      } catch (error) {
+        scriptError = error;
       }
-    } catch (error) {
-      scriptError = error;
     }
 
     if (historyLogger) {