test_runner: expose describe and it

Author: MoLow

lib/internal/test_runner/harness.js

@@ -4,14 +4,18 @@ const {
   createHook,
   executionAsyncId,
 } = require('async_hooks');
+const console = require('console');
 const {
   codes: {
     ERR_TEST_FAILURE,
   },
 } = require('internal/errors');
 const { Test } = require('internal/test_runner/test');
 
-function createProcessEventHandler(eventName, rootTest, testResources) {
+
+const testResources = new SafeMap();
+
+function createProcessEventHandler(eventName, rootTest) {
   return (err) => {
     // Check if this error is coming from a test. If it is, fail the test.
     const test = testResources.get(executionAsyncId());
@@ -31,12 +35,13 @@ function createProcessEventHandler(eventName, rootTest, testResources) {
 
       test.fail(new ERR_TEST_FAILURE(err, eventName));
       test.postRun();
+    } else {
+      console.error(err);
     }
   };
 }
 
 function setup(root) {
-  const testResources = new SafeMap();
   const hook = createHook({
     init(asyncId, type, triggerAsyncId, resource) {
       if (resource instanceof Test) {
@@ -58,9 +63,9 @@ function setup(root) {
   hook.enable();
 
   const exceptionHandler =
-    createProcessEventHandler('uncaughtException', root, testResources);
+    createProcessEventHandler('uncaughtException', root);
   const rejectionHandler =
-    createProcessEventHandler('unhandledRejection', root, testResources);
+    createProcessEventHandler('unhandledRejection', root);
 
   process.on('uncaughtException', exceptionHandler);
   process.on('unhandledRejection', rejectionHandler);
@@ -113,19 +118,31 @@ function setup(root) {
 
   root.reporter.pipe(process.stdout);
   root.reporter.version();
+  return root;
 }
 
-function test(name, options, fn) {
-  // If this is the first test encountered, bootstrap the test harness.
-  if (this.subtests.length === 0) {
-    setup(this);
-  }
+const root = setup(new Test({ name: '<root>' }));
 
+function test(name, options, fn) {
   const subtest = this.createSubtest(name, options, fn);
-
   return subtest.start();
 }
 
-const root = new Test({ name: '<root>' });
+function describe(name, options, fn) {
+  const parent = testResources.get(executionAsyncId()) || root;
+  const suite = parent.createSubSuite(name, options, fn);
+  if (parent === root) {
+    suite.run();
+  }
+}
+
+function it(name, options, fn) {
+  const parent = testResources.get(executionAsyncId()) || root;
+  parent.createSubtest(name, options, fn);
+}
 
-module.exports = FunctionPrototypeBind(test, root);
+module.exports = {
+  test: FunctionPrototypeBind(test, root),
+  describe,
+  it,
+};

lib/internal/test_runner/test.js

@@ -36,6 +36,32 @@ const testOnlyFlag = !isTestRunner && getOptionValue('--test-only');
 // TODO(cjihrig): Use uv_available_parallelism() once it lands.
 const rootConcurrency = isTestRunner ? cpus().length : 1;
 
+
+function parseTestProps(parent, name, options, fn, overrides) {
+  if (typeof name === 'function') {
+    fn = name;
+  } else if (name !== null && typeof name === 'object') {
+    fn = options;
+    options = name;
+  } else if (typeof options === 'function') {
+    fn = options;
+  }
+
+  if (options === null || typeof options !== 'object') {
+    options = kEmptyObject;
+  }
+
+  // If this test has already ended, attach this test to the root test so
+  // that the error can be properly reported.
+  if (parent.finished) {
+    while (parent.parent !== null) {
+      parent = parent.parent;
+    }
+  }
+
+  return { fn, name, parent, ...options, ...overrides };
+}
+
 class TestContext {
   #test;
 
@@ -189,34 +215,11 @@ class Test extends AsyncResource {
     }
   }
 
-  createSubtest(name, options, fn) {
-    if (typeof name === 'function') {
-      fn = name;
-    } else if (name !== null && typeof name === 'object') {
-      fn = options;
-      options = name;
-    } else if (typeof options === 'function') {
-      fn = options;
-    }
+  createSubtest(...props) {
+    const test = new Test(parseTestProps(this, ...props));
 
-    if (options === null || typeof options !== 'object') {
-      options = kEmptyObject;
-    }
-
-    let parent = this;
-
-    // If this test has already ended, attach this test to the root test so
-    // that the error can be properly reported.
-    if (this.finished) {
-      while (parent.parent !== null) {
-        parent = parent.parent;
-      }
-    }
-
-    const test = new Test({ fn, name, parent, ...options });
-
-    if (parent.waitingOn === 0) {
-      parent.waitingOn = test.testNumber;
+    if (test.parent.waitingOn === 0) {
+      test.parent.waitingOn = test.testNumber;
     }
 
     if (this.finished) {
@@ -228,10 +231,22 @@ class Test extends AsyncResource {
       );
     }
 
-    ArrayPrototypePush(parent.subtests, test);
+    ArrayPrototypePush(test.parent.subtests, test);
     return test;
   }
 
+  createSubSuite(...props) {
+    // eslint-disable-next-line no-use-before-define
+    const suite = new Suite(parseTestProps(this, ...props));
+
+    if (suite.parent.waitingOn === 0) {
+      suite.parent.waitingOn = suite.testNumber;
+    }
+
+    ArrayPrototypePush(suite.parent.subtests, suite);
+    return suite;
+  }
+
   cancel() {
     if (this.endTime !== null) {
       return;
@@ -448,5 +463,19 @@ class Test extends AsyncResource {
     }
   }
 }
+class Suite extends Test {
+  constructor(options) {
+    super(options);
+
+    this.runInAsyncScope(this.fn);
+    this.fn = () => {};
+  }
+  async run() {
+    for (const subtest of this.subtests) {
+      await subtest.run();
+    }
+    await super.run();
+  }
+}
 
 module.exports = { kDefaultIndent, kSubtestsFailed, kTestCodeFailure, Test };

lib/test.js

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