Merge branch 'release/7.46.1'

Author: appurva21

CHANGELOG.yaml

@@ -1,3 +1,13 @@
+7.46.1:
+  date: 2025-09-15
+  fixed bugs:
+    - >-
+      GH-1526 Fixed a bug where nested requests were aborting the run on
+      assertion failures
+    - >-
+      GH-1527 Add support for invoking parent request trigger from nested
+      requests
+
 7.46.0:
   date: 2025-09-08
   new features:

lib/runner/index.js

@@ -43,7 +43,7 @@ _.assign(Runner.prototype, {
             ['environment', 'globals', 'vaultSecrets', 'data']), this.options.run) || {};
 
         // Ensure we have a default value for max invokable nested requests
-        !runOptions.maxInvokableNestedRequests && (runOptions.maxInvokableNestedRequests = 5);
+        !runOptions.maxInvokableNestedRequests && (runOptions.maxInvokableNestedRequests = 10);
 
         // start timeout sanitization
         !runOptions.timeout && (runOptions.timeout = {});

lib/runner/nested-request.js

@@ -109,7 +109,7 @@ function runNestedRequest ({ executionId, isExecutionSkipped, vaultSecrets, item
                     environment: environment,
                     localVariables: localVariables,
                     vaultSecrets: clonedVaultSecrets,
-                    abortOnFailure: true,
+                    stopOnError: true,
                     host: {
                         // Reuse current run's sandbox host across nested executions
                         external: true,
@@ -155,6 +155,14 @@ function runNestedRequest ({ executionId, isExecutionSkipped, vaultSecrets, item
                                 }
                             }
                         },
+                        request (err, _cursor, ...rest) {
+                            // For nested requests, the request event should bubble up to the parent.
+                            // This event is merely used for notifying the consumer that a nested request was sent
+                            // similar to pm.sendRequest. So the consumer can work this into logs & any other logic.
+                            if (typeof self.triggers.request === 'function') {
+                                self.triggers.request(err, self.state.nestedRequest.rootCursor, ...rest);
+                            }
+                        },
                         exception (_, err) {
                             if (err) {
                                 exceptionForThisRequest = err;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "postman-runtime",
-  "version": "7.46.0",
+  "version": "7.46.1",
   "description": "Underlying library of executing Postman Collections",
   "author": "Postman Inc.",
   "license": "Apache-2.0",

package.json

@@ -726,4 +726,163 @@ describe('pm.execution.runRequest handling', function () {
                 });
             });
     });
+
+    it('should not abort execution on encountering failure in nested request assertions', function (done) {
+        const collection = new sdk.Collection({
+            item: [{
+                event: [{
+                    listen: 'prerequest',
+                    script: {
+                        exec: `
+                        await pm.execution.runRequest("nested-request-id");
+                        pm.test('[l0-prerequest] this test should have run', function () {
+                            pm.expect(true).to.equal(true);
+                        });
+                    `
+                    }
+                }, {
+                    listen: 'test',
+                    script: {
+                        exec: `
+                        pm.test('[l0-test] this test should also have run', function () {
+                            pm.expect(true).to.equal(false);
+                        });
+                    `
+                    }
+                }],
+                request: {
+                    url: 'https://postman-echo.com/get',
+                    method: 'GET'
+                }
+            }]
+        });
+
+        new collectionRunner().run(collection,
+            {
+                script: {
+                    requestResolver (_requestId, callback) {
+                        callback(null, {
+                            item: {
+                                id: 'nested-request-id',
+                                event: [
+                                    {
+                                        listen: 'prerequest',
+                                        script: {
+                                            exec: `
+                                            pm.test('[l1-failure-test] this test should have failed', function () {
+                                                pm.expect(true).to.equal(false);
+                                            });
+                                            `
+                                        }
+                                    }
+                                ],
+                                request: {
+                                    url: 'https://postman-echo.com/post',
+                                    method: 'POST'
+                                }
+                            }
+                        });
+                    }
+                }
+            },
+            function (_err, run) {
+                let assertionCount = 0,
+                    expectedOrder = [false, true, false],
+                    actualOrder = []; // Expected order of assertion results
+
+                run.start({
+                    assertion (_cursor, assertions) {
+                        assertions.forEach((assertion) => {
+                            assertionCount++;
+                            actualOrder.push(assertion.passed);
+                        });
+                    },
+                    done (err) {
+                        expect(assertionCount).to.eql(3); // All 3 assertions should have run
+                        expect(actualOrder).to.deep.eql(expectedOrder);
+                        done(err);
+                    }
+                });
+            });
+    });
+
+    it('should invoke passed-down request trigger callback', function (done) {
+        const collection = new sdk.Collection({
+            item: [{
+                event: [
+                    {
+                        listen: 'prerequest',
+                        script: {
+                            exec: `
+                            await pm.execution.runRequest(
+                                "nested-request-id",
+                                { variables: { method: "post" } }
+                            );
+                            `
+                        }
+                    }
+                ],
+                request: {
+                    url: 'https://postman-echo.com/{{parent_method}}',
+                    method: 'GET'
+                }
+            }]
+        });
+
+        new collectionRunner().run(collection,
+            {
+                script: {
+                    requestResolver (_requestId, callback) {
+                        callback(null, {
+                            item: {
+                                id: 'nested-request-id',
+                                event: [
+                                    {
+                                        listen: 'prerequest',
+                                        script: {
+                                            exec: 'pm.globals.set("parent_method", "get");'
+                                        }
+                                    }
+                                ],
+                                request: {
+                                    url: 'https://postman-echo.com/{{method}}',
+                                    method: 'POST'
+                                }
+                            }
+                        });
+                    }
+                }
+            },
+            function (_err, run) {
+                let requestConsoleInvocationCount = 0,
+                    invocationOrder = [];
+
+                run.start({
+                    request (_err, cursor, response, request, item, cookies, history) {
+                        requestConsoleInvocationCount++;
+                        invocationOrder.push(request.url.toString());
+
+                        expect(history.execution).to.be.ok;
+                        expect(response.status).to.be.ok;
+
+                        if (requestConsoleInvocationCount === 1) {
+                            // For nested request cursors: scriptId should be non-empty
+                            // Used by consumers to mark the log as an indirect request
+                            expect(cursor.scriptId).to.be.ok;
+                        }
+
+                        expect(request).to.be.ok;
+                        expect(item).to.be.ok;
+                        expect(cookies).to.be.ok;
+                    },
+                    done (err) {
+                        expect(requestConsoleInvocationCount).to.eql(2); // Nested request + Parent request
+                        expect(invocationOrder).to.deep.equal([
+                            'https://postman-echo.com/post', 'https://postman-echo.com/get'
+                        ]);
+                        done(err);
+                    }
+                });
+            });
+    });
 });