test_runner: before and after each hooks

Author: MoLow

lib/internal/test_runner/harness.js

@@ -170,8 +170,20 @@ function runInParentContext(Factory) {
   return cb;
 }
 
+function afterEach(fn, options) {
+  const parent = testResources.get(executionAsyncId()) || setup(root);
+  parent.createBeforeEachHook(fn, options);
+
+}
+function beforeEach(fn, options) {
+  const parent = testResources.get(executionAsyncId()) || setup(root);
+  parent.createBeforeEachHook(fn, options);
+}
+
 module.exports = {
   test: FunctionPrototypeBind(test, root),
   describe: runInParentContext(Suite),
   it: runInParentContext(ItTest),
+  afterEach,
+  beforeEach,
 };

lib/internal/test_runner/test.js

@@ -66,6 +66,10 @@ class TestContext {
     this.#test = test;
   }
 
+  get name() {
+    return this.#test.name;
+  }
+
   diagnostic(message) {
     this.#test.diagnostic(message);
   }
@@ -88,6 +92,14 @@ class TestContext {
 
     return subtest.start();
   }
+
+  beforeEach(fn, options) {
+    this.#test.createBeforeEachHook(fn, options);
+  }
+
+  afterEach(fn, options) {
+    this.#test.createAfterEachHook(fn, options);
+  }
 }
 
 class Test extends AsyncResource {
@@ -165,6 +177,8 @@ class Test extends AsyncResource {
     this.pendingSubtests = [];
     this.readySubtests = new SafeMap();
     this.subtests = [];
+    this.beforeEachHooks = [];
+    this.afterEachHooks = [];
     this.waitingOn = 0;
     this.finished = false;
   }
@@ -267,6 +281,18 @@ class Test extends AsyncResource {
     return test;
   }
 
+  createBeforeEachHook(fn, options) {
+    const hook = new TestHook(fn, options);
+    ArrayPrototypePush(this.beforeEachHooks, hook);
+    return hook;
+  }
+
+  createAfterEachHook(fn, options) {
+    const hook = new TestHook(fn, options);
+    ArrayPrototypePush(this.afterEachHooks, hook);
+    return hook;
+  }
+
   cancel() {
     if (this.endTime !== null) {
       return;
@@ -278,6 +304,7 @@ class Test extends AsyncResource {
         kCancelledByParent
       )
     );
+    this.startTime = this.startTime || this.endTime; // if a test was canceled before it was started, e.g inside a hook
     this.cancelled = true;
   }
 
@@ -334,12 +361,24 @@ class Test extends AsyncResource {
     return { ctx, args: [ctx] };
   }
 
-  async run() {
-    this.parent.activeSubtests++;
+  async #runHooks(hooks) {
+    await ArrayPrototypeReduce(hooks, async (prev, hook) => {
+      await prev;
+      await hook.run(this.getRunArgs());
+    }, PromiseResolve()); 
+  }
+
+  async run(...runArgs) {
+    if (this.parent !== null) {
+      this.parent.activeSubtests++;
+    }
+    if (this.parent?.beforeEachHooks.length > 0) {
+      await this.#runHooks(this.parent.beforeEachHooks);
+    }
     this.startTime = hrtime();
 
     try {
-      const { args, ctx } = this.getRunArgs();
+      const { args, ctx } = ReflectApply(this.getRunArgs, this, runArgs);
       ArrayPrototypeUnshift(args, this.fn, ctx); // Note that if it's not OK to mutate args, we need to first clone it.
 
       if (this.fn.length === args.length - 1) {
@@ -372,9 +411,13 @@ class Test extends AsyncResource {
       }
     }
 
+    if (this.parent?.afterEachHooks.length > 0) {
+      await this.#runHooks(this.parent.afterEachHooks);
+    }
+
     // Clean up the test. Then, try to report the results and execute any
     // tests that were pending due to available concurrency.
-    this.postRun();
+    await this.postRun();
   }
 
   postRun() {
@@ -413,7 +456,7 @@ class Test extends AsyncResource {
       this.parent.activeSubtests--;
       this.parent.addReadySubtest(this);
       this.parent.processReadySubtestRange(false);
-      this.parent.processPendingSubtests();
+      return this.parent.processPendingSubtests();
     }
   }
 
@@ -473,10 +516,23 @@ class Test extends AsyncResource {
   }
 }
 
+class TestHook extends Test {
+  constructor(fn, options) { 
+    if (options === null || typeof options !== 'object') {
+      options = kEmptyObject;
+    }
+    super({ fn, ...options }); 
+  }
+  getRunArgs(testContext) {
+    return testContext;
+  }
+}
+
 class ItTest extends Test {
   constructor(opt) { super(opt); } // eslint-disable-line no-useless-constructor
   getRunArgs() {
-    return { ctx: {}, args: [] };
+    const ctx = new TestContext(this);
+    return { ctx, args: [] };
   }
 }
 class Suite extends Test {

lib/test.js

@@ -1,5 +1,5 @@
 'use strict';
-const { test, describe, it } = require('internal/test_runner/harness');
+const { test, describe, it, afterEach, beforeEach } = require('internal/test_runner/harness');
 const { emitExperimentalWarning } = require('internal/util');
 
 emitExperimentalWarning('The test runner');
@@ -8,3 +8,5 @@ module.exports = test;
 module.exports.test = test;
 module.exports.describe = describe;
 module.exports.it = it;
+module.exports.afterEach = afterEach;
+module.exports.beforeEach = beforeEach;

test/message/test_runner_describe_it.js

@@ -224,19 +224,6 @@ it('callback fail', (done) => {
   });
 });
 
-it('sync t is this in test', function() {
-  assert.deepStrictEqual(this, {});
-});
-
-it('async t is this in test', async function() {
-  assert.deepStrictEqual(this, {});
-});
-
-it('callback t is this in test', function(done) {
-  assert.deepStrictEqual(this, {});
-  done();
-});
-
 it('callback also returns a Promise', async (done) => {
   throw new Error('thrown from callback also returns a Promise');
 });