test_runner: support test plans

cjihrig · cjihrig · commit 89d9a7e6584f · 2024-03-19T11:01:33.000-04:00
diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
@@ -85,6 +85,7 @@ const {
   testOnlyFlag,
 } = parseCommandLine();
 let kResistStopPropagation;
+let assertObj;
 let findSourceMap;
 
 function lazyFindSourceMap(file) {
@@ -95,6 +96,34 @@ function lazyFindSourceMap(file) {
   return findSourceMap(file);
 }
 
+function lazyAssertObject() {
+  if (assertObj === undefined) {
+    const assert = require('assert');
+
+    assertObj = new SafeMap([
+      ['deepEqual', assert.deepEqual],
+      ['deepStrictEqual', assert.deepStrictEqual],
+      ['doesNotMatch', assert.doesNotMatch],
+      ['doesNotReject', assert.doesNotReject],
+      ['doesNotThrow', assert.doesNotThrow],
+      ['equal', assert.equal],
+      ['fail', assert.fail],
+      ['ifError', assert.ifError],
+      ['match', assert.match],
+      ['notDeepEqual', assert.notDeepEqual],
+      ['notDeepStrictEqual', assert.notDeepStrictEqual],
+      ['notEqual', assert.notEqual],
+      ['notStrictEqual', assert.notStrictEqual],
+      ['ok', assert.ok],
+      ['rejects', assert.rejects],
+      ['strictEqual', assert.strictEqual],
+      ['throws', assert.throws],
+    ]);
+  }
+
+  return assertObj;
+}
+
 function stopTest(timeout, signal) {
   const deferred = createDeferredPromise();
   const abortListener = addAbortListener(signal, deferred.resolve);
@@ -134,7 +163,25 @@ function stopTest(timeout, signal) {
   return deferred.promise;
 }
 
+class TestPlan {
+  constructor(count) {
+    validateUint32(count, 'count', 0);
+    this.expected = count;
+    this.actual = 0;
+  }
+
+  check() {
+    if (this.actual !== this.expected) {
+      throw new ERR_TEST_FAILURE(
+        `plan expected ${this.expected} assertions but received ${this.actual}`,
+        kTestCodeFailure,
+      );
+    }
+  }
+}
+
 class TestContext {
+  #assert;
   #test;
 
   constructor(test) {
@@ -161,6 +208,38 @@ class TestContext {
     this.#test.diagnostic(message);
   }
 
+  plan(count) {
+    if (this.#test.plan !== null) {
+      throw new ERR_TEST_FAILURE(
+        'cannot set plan more than once',
+        kTestCodeFailure,
+      );
+    }
+
+    this.#test.plan = new TestPlan(count);
+  }
+
+  get assert() {
+    if (this.#assert === undefined) {
+      const { plan } = this.#test;
+      const map = lazyAssertObject();
+      const assert = { __proto__: null };
+
+      this.#assert = assert;
+      map.forEach((method, name) => {
+        assert[name] = function(...args) {
+          if (plan !== null) {
+            plan.actual++;
+          }
+
+          return ReflectApply(method, assert, args);
+        };
+      });
+    }
+
+    return this.#assert;
+  }
+
   get mock() {
     this.#test.mock ??= new MockTracker();
     return this.#test.mock;
@@ -347,6 +426,7 @@ class Test extends AsyncResource {
     this.fn = fn;
     this.harness = null; // Configured on the root test by the test harness.
     this.mock = null;
+    this.plan = null;
     this.cancelled = false;
     this.skipped = skip !== undefined && skip !== false;
     this.isTodo = todo !== undefined && todo !== false;
@@ -708,6 +788,7 @@ class Test extends AsyncResource {
         return;
       }
 
+      this.plan?.check();
       this.pass();
       try {
         await afterEach();
