chore(demo): add demo code of node --test

demo/node-test/index.test.js

@@ -0,0 +1,167 @@
+const test = require("node:test");
+const { describe, it } = require("node:test");
+// # Basic example
+test("synchronous passing test", (t) => {
+  // This test passes because it does not throw an exception.
+  assert.strictEqual(1, 1);
+});
+
+test("synchronous failing test", (t) => {
+  // This test fails because it throws an exception.
+  assert.strictEqual(1, 2);
+});
+
+test("asynchronous passing test", async (t) => {
+  // This test passes because the Promise returned by the async
+  // function is settled and not rejected.
+  assert.strictEqual(1, 1);
+});
+
+test("asynchronous failing test", async (t) => {
+  // This test fails because the Promise returned by the async
+  // function is rejected.
+  assert.strictEqual(1, 2);
+});
+
+test("failing test using Promises", (t) => {
+  // Promises can be used directly as well.
+  return new Promise((resolve, reject) => {
+    setImmediate(() => {
+      reject(new Error("this will cause the test to fail"));
+    });
+  });
+});
+
+test("callback passing test", (t, done) => {
+  // done() is the callback function. When the setImmediate() runs, it invokes
+  // done() with no arguments.
+  setImmediate(done);
+});
+
+test("callback failing test", (t, done) => {
+  // When the setImmediate() runs, done() is invoked with an Error object and
+  // the test fails.
+  setImmediate(() => {
+    done(new Error("callback failure"));
+  });
+});
+
+// # Subtests
+test("top level test", async (t) => {
+  await t.test("subtest 1", (t) => {
+    assert.strictEqual(1, 1);
+  });
+
+  await t.test("subtest 2", (t) => {
+    assert.strictEqual(2, 2);
+  });
+});
+
+// # Skipping tests
+// The skip option is used, but no message is provided.
+test("skip option", { skip: true }, (t) => {
+  // This code is never executed.
+});
+
+// The skip option is used, and a message is provided.
+test("skip option with message", { skip: "this is skipped" }, (t) => {
+  // This code is never executed.
+});
+
+test("skip() method", (t) => {
+  // Make sure to return here as well if the test contains additional logic.
+  t.skip();
+});
+
+test("skip() method with message", (t) => {
+  // Make sure to return here as well if the test contains additional logic.
+  t.skip("this is skipped");
+});
+
+// # TODO tests
+// The todo option is used, but no message is provided.
+test("todo option", { todo: true }, (t) => {
+  // This code is executed, but not treated as a failure.
+  throw new Error("this does not fail the test");
+});
+
+// The todo option is used, and a message is provided.
+test("todo option with message", { todo: "this is a todo test" }, (t) => {
+  // This code is executed.
+});
+
+test("todo() method", (t) => {
+  t.todo();
+});
+
+test("todo() method with message", (t) => {
+  t.todo("this is a todo test and is not treated as a failure");
+  throw new Error("this does not fail the test");
+});
+
+// # describe() and it() aliases
+describe("A thing", () => {
+  it("should work", () => {
+    assert.strictEqual(1, 1);
+  });
+
+  it("should be ok", () => {
+    assert.strictEqual(2, 2);
+  });
+
+  describe("a nested thing", () => {
+    it("should work", () => {
+      assert.strictEqual(3, 3);
+    });
+  });
+});
+
+// # only tests
+// Assume Node.js is run with the --test-only command-line option.
+// The suite's 'only' option is set, so these tests are run.
+test("this test is run", { only: true }, async (t) => {
+  // Within this test, all subtests are run by default.
+  await t.test("running subtest");
+
+  // The test context can be updated to run subtests with the 'only' option.
+  t.runOnly(true);
+  await t.test("this subtest is now skipped");
+  await t.test("this subtest is run", { only: true });
+
+  // Switch the context back to execute all tests.
+  t.runOnly(false);
+  await t.test("this subtest is now run");
+
+  // Explicitly do not run these tests.
+  await t.test("skipped subtest 3", { only: false });
+  await t.test("skipped subtest 4", { skip: true });
+});
+
+// The 'only' option is not set, so this test is skipped.
+test("this test is not run", () => {
+  // This code is not run.
+  throw new Error("fail");
+});
+
+describe("a suite", () => {
+  // The 'only' option is set, so this test is run.
+  it("this test is run", { only: true }, () => {
+    // This code is run.
+  });
+
+  it("this test is not run", () => {
+    // This code is not run.
+    throw new Error("fail");
+  });
+});
+
+describe.only("a suite", () => {
+  // The 'only' option is set, so this test is run.
+  it("this test is run", () => {
+    // This code is run.
+  });
+
+  it("this test is run", () => {
+    // This code is run.
+  });
+});