fix(node/test): basic support for t.skip and t.todo (#29222)

Adds basic support for `t.skip` and `t.todo`

Author: dsherret

ext/node/polyfills/testing.ts

@@ -7,8 +7,9 @@ const {
   ArrayPrototypeForEach,
   SafePromiseAll,
   SafePromisePrototypeFinally,
+  Symbol,
 } = primordials;
-import { notImplemented, warnNotImplemented } from "ext:deno_node/_utils.ts";
+import { notImplemented } from "ext:deno_node/_utils.ts";
 import assert from "node:assert";
 
 const methodsToCopy = [
@@ -49,11 +50,20 @@ export function run() {
 
 function noop() {}
 
+const skippedSymbol = Symbol("skipped");
+
 class NodeTestContext {
   #denoContext: Deno.TestContext;
+  #parent: NodeTestContext | undefined;
+  #skipped = false;
 
-  constructor(t: Deno.TestContext) {
+  constructor(t: Deno.TestContext, parent: NodeTestContext | undefined) {
     this.#denoContext = t;
+    this.#parent = parent;
+  }
+
+  get [skippedSymbol]() {
+    return this.#skipped || (this.#parent?.[skippedSymbol] ?? false);
   }
 
   get assert() {
@@ -86,23 +96,34 @@ class NodeTestContext {
   }
 
   skip() {
-    warnNotImplemented("test.TestContext.skip");
+    this.#skipped = true;
     return null;
   }
 
   todo() {
-    warnNotImplemented("test.TestContext.todo");
+    this.#skipped = true;
     return null;
   }
 
   test(name, options, fn) {
     const prepared = prepareOptions(name, options, fn, {});
+    // deno-lint-ignore no-this-alias
+    const parentContext = this;
     return PromisePrototypeThen(
       this.#denoContext.step({
         name: prepared.name,
         fn: async (denoTestContext) => {
-          const newNodeTextContext = new NodeTestContext(denoTestContext);
-          await prepared.fn(newNodeTextContext);
+          const newNodeTextContext = new NodeTestContext(
+            denoTestContext,
+            parentContext,
+          );
+          try {
+            await prepared.fn(newNodeTextContext);
+          } catch (err) {
+            if (!newNodeTextContext[skippedSymbol]) {
+              throw err;
+            }
+          }
         },
         ignore: prepared.options.todo || prepared.options.skip,
         sanitizeExit: false,
@@ -144,9 +165,20 @@ class TestSuite {
     const prepared = prepareOptions(name, options, fn, overrides);
     const step = this.#denoTestContext.step({
       name: prepared.name,
-      fn: (denoTestContext) => {
-        const newNodeTextContext = new NodeTestContext(denoTestContext);
-        return prepared.fn(newNodeTextContext);
+      fn: async (denoTestContext) => {
+        const newNodeTextContext = new NodeTestContext(
+          denoTestContext,
+          undefined,
+        );
+        try {
+          return await prepared.fn(newNodeTextContext);
+        } catch (err) {
+          if (newNodeTextContext[skippedSymbol]) {
+            return undefined;
+          } else {
+            throw err;
+          }
+        }
       },
       ignore: prepared.options.todo || prepared.options.skip,
       sanitizeExit: false,
@@ -204,9 +236,13 @@ function prepareOptions(name, options, fn, overrides) {
 
 function wrapTestFn(fn, resolve) {
   return async function (t) {
-    const nodeTestContext = new NodeTestContext(t);
+    const nodeTestContext = new NodeTestContext(t, undefined);
     try {
       await fn(nodeTestContext);
+    } catch (err) {
+      if (!nodeTestContext[skippedSymbol]) {
+        throw err;
+      }
     } finally {
       resolve();
     }

tests/specs/node/node_test_module/test.js

@@ -22,6 +22,13 @@ test("sync fail todo", (t) => {
   throw new Error("thrown from sync fail todo");
 });
 
+test("todo thrown sub test", async (t) => {
+  t.todo("this is a todo test and is not treated as a failure");
+  await t.test("test", () => {
+    throw new Error("this does not fail the test");
+  });
+});
+
 test("sync fail todo with message", (t) => {
   t.todo("this is a failing todo");
   throw new Error("thrown from sync fail todo with message");
@@ -35,6 +42,13 @@ test("sync skip pass with message", (t) => {
   t.skip("this is skipped");
 });
 
+test("skip thrown sub test", async (t) => {
+  t.skip("this is a skip test and is not treated as a failure");
+  await t.test("test", () => {
+    throw new Error("this does not fail the test");
+  });
+});
+
 test("sync pass", (t) => {
   t.diagnostic("this test should pass");
 });