fix: Nested Requests aborting execution on error in scripts (#1526)

Author: deve-sh

CHANGELOG.yaml

@@ -1,3 +1,7 @@
+unreleased:
+  fixed bugs:
+    - GH-1526 Fixed a bug where nested requests were not aborting the run on failure in assertions
+
 7.46.0:
   date: 2025-09-08
   new features:

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,

test/integration/runner-spec/run-collection-request.test.js

@@ -726,4 +726,83 @@ 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);
+                    }
+                });
+            });
+    });
 });