nodejs
diff --git a/‎lib/internal/test_runner/test.js‎
Lines changed: 6 additions & 0 deletions b/‎lib/internal/test_runner/test.js‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎test/fixtures/test-runner/aborts/failed-test-still-call-abort.js‎
Lines changed: 25 additions & 0 deletions b/‎test/fixtures/test-runner/aborts/failed-test-still-call-abort.js‎
Lines changed: 25 additions & 0 deletions
diff --git a/‎test/fixtures/test-runner/aborts/successful-test-still-call-abort.js‎
Lines changed: 23 additions & 0 deletions b/‎test/fixtures/test-runner/aborts/successful-test-still-call-abort.js‎
Lines changed: 23 additions & 0 deletions
diff --git a/‎test/fixtures/test-runner/aborts/wait-for-abort-helper.js‎
Lines changed: 19 additions & 0 deletions b/‎test/fixtures/test-runner/aborts/wait-for-abort-helper.js‎
Lines changed: 19 additions & 0 deletions
diff --git a/‎test/parallel/test-runner-run.mjs‎
Lines changed: 93 additions & 18 deletions b/‎test/parallel/test-runner-run.mjs‎
Lines changed: 93 additions & 18 deletions
@@ -601,6 +601,12 @@ class Test extends AsyncResource {
       } else {
         this.fail(new ERR_TEST_FAILURE(err, kTestCodeFailure));
       }
+    } finally {
+      // Do not abort hooks and the root test as hooks instance are shared between tests suite so aborting them will
+      // cause them to not run for further tests.
+      if (this.parent !== null) {
+        this.#abortController.abort();
+      }
     }
 
     // Clean up the test. Then, try to report the results and execute any
 
@@ -0,0 +1,25 @@
+const {test, afterEach} = require('node:test');
+const assert = require('node:assert');
+const { waitForAbort } = require('./wait-for-abort-helper');
+
+let testCount = 0;
+let signal;
+
+afterEach(() => {
+  assert.equal(signal.aborted, false);
+
+  waitForAbort({ testNumber: ++testCount, signal });
+});
+
+test("sync", (t) => {
+  signal = t.signal;
+  assert.equal(signal.aborted, false);
+  throw new Error('failing the sync test');
+});
+
+test("async", async (t) => {
+  await null;
+  signal = t.signal;
+  assert.equal(signal.aborted, false);
+  throw new Error('failing the async test');
+});
@@ -0,0 +1,23 @@
+const {test, afterEach} = require('node:test');
+const assert = require('node:assert');
+const {waitForAbort} = require("./wait-for-abort-helper");
+
+let testCount = 0;
+let signal;
+
+afterEach(() => {
+  assert.equal(signal.aborted, false);
+
+  waitForAbort({ testNumber: ++testCount, signal });
+});
+
+test("sync", (t) => {
+  signal = t.signal;
+  assert.equal(signal.aborted, false);
+});
+
+test("async", async (t) => {
+  await null;
+  signal = t.signal;
+  assert.equal(signal.aborted, false);
+});
@@ -0,0 +1,19 @@
+module.exports = {
+  waitForAbort: function ({ testNumber, signal }) {
+    let retries = 0;
+
+    const interval = setInterval(() => {
+      retries++;
+      if(signal.aborted) {
+        console.log(`abort called for test ${testNumber}`);
+        clearInterval(interval);
+        return;
+      }
+
+      if(retries > 100) {
+        clearInterval(interval);
+        throw new Error(`abort was not called for test ${testNumber}`);
+      }
+    }, 10);
+  }
+}
@@ -118,29 +118,104 @@ describe('require(\'node:test\').run', { concurrency: true }, () => {
     assert.strictEqual(result[5], 'ok 2 - this should be executed\n');
   });
 
-  it('should stop watch mode when abortSignal aborts', async () => {
+  it('should emit "test:watch:drained" event on watch mode', async () => {
     const controller = new AbortController();
-    const result = await run({ files: [join(testFixtures, 'test/random.cjs')], watch: true, signal: controller.signal })
-      .compose(async function* (source) {
-        for await (const chunk of source) {
-          if (chunk.type === 'test:pass') {
-            controller.abort();
-            yield chunk.data.name;
-          }
-        }
-      })
-      .toArray();
-    assert.deepStrictEqual(result, ['this should pass']);
+    await run({
+      files: [join(testFixtures, 'test/random.cjs')],
+      watch: true,
+      signal: controller.signal,
+    }).on('data', function({ type }) {
+      if (type === 'test:watch:drained') {
+        controller.abort();
+      }
+    });
   });
 
-  it('should emit "test:watch:drained" event on watch mode', async () => {
-    const controller = new AbortController();
-    await run({ files: [join(testFixtures, 'test/random.cjs')], watch: true, signal: controller.signal })
-      .on('data', function({ type }) {
-        if (type === 'test:watch:drained') {
-          controller.abort();
+  describe('AbortSignal', () => {
+    it('should stop watch mode when abortSignal aborts', async () => {
+      const controller = new AbortController();
+      const result = await run({
+        files: [join(testFixtures, 'test/random.cjs')],
+        watch: true,
+        signal: controller.signal,
+      })
+        .compose(async function* (source) {
+          for await (const chunk of source) {
+            if (chunk.type === 'test:pass') {
+              controller.abort();
+              yield chunk.data.name;
+            }
+          }
+        })
+        .toArray();
+      assert.deepStrictEqual(result, ['this should pass']);
+    });
+
+    it('should abort when test succeeded', async () => {
+      const stream = run({
+        files: [
+          fixtures.path(
+            'test-runner',
+            'aborts',
+            'successful-test-still-call-abort.js'
+          ),
+        ],
+      });
+
+      let passedTestCount = 0;
+      let failedTestCount = 0;
+
+      let output = '';
+      for await (const data of stream) {
+        if (data.type === 'test:stdout') {
+          output += data.data.message.toString();
+        }
+        if (data.type === 'test:fail') {
+          failedTestCount++;
         }
+        if (data.type === 'test:pass') {
+          passedTestCount++;
+        }
+      }
+
+      assert.match(output, /abort called for test 1/);
+      assert.match(output, /abort called for test 2/);
+      assert.strictEqual(failedTestCount, 0, new Error('no tests should fail'));
+      assert.strictEqual(passedTestCount, 2);
+    });
+
+    it('should abort when test failed', async () => {
+      const stream = run({
+        files: [
+          fixtures.path(
+            'test-runner',
+            'aborts',
+            'failed-test-still-call-abort.js'
+          ),
+        ],
       });
+
+      let passedTestCount = 0;
+      let failedTestCount = 0;
+
+      let output = '';
+      for await (const data of stream) {
+        if (data.type === 'test:stdout') {
+          output += data.data.message.toString();
+        }
+        if (data.type === 'test:fail') {
+          failedTestCount++;
+        }
+        if (data.type === 'test:pass') {
+          passedTestCount++;
+        }
+      }
+
+      assert.match(output, /abort called for test 1/);
+      assert.match(output, /abort called for test 2/);
+      assert.strictEqual(passedTestCount, 0, new Error('no tests should pass'));
+      assert.strictEqual(failedTestCount, 2);
+    });
   });
 
   describe('sharding', () => {
Original file line number	Diff line number	Diff line change
@@ -601,6 +601,12 @@ class Test extends AsyncResource {
601	601	} else {
602	602	this.fail(new ERR_TEST_FAILURE(err, kTestCodeFailure));
603	603	}
	604	+ } finally {
	605	+ // Do not abort hooks and the root test as hooks instance are shared between tests suite so aborting them will
	606	+ // cause them to not run for further tests.
	607	+ if (this.parent !== null) {
	608	+ this.#abortController.abort();
	609	+ }
604	610	}
605	611
606	612	// Clean up the test. Then, try to report the results and execute any