test(ext/node): add tty_test and util_test (#17868)

cli/tests/unit_node/tty_test.ts

@@ -0,0 +1,31 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// deno-lint-ignore-file no-explicit-any
+
+import { assert } from "../../../test_util/std/testing/asserts.ts";
+import { isatty } from "node:tty";
+
+Deno.test("[node/tty isatty] returns true when fd is a tty, false otherwise", () => {
+  assert(Deno.isatty(Deno.stdin.rid) === isatty(Deno.stdin.rid));
+  assert(Deno.isatty(Deno.stdout.rid) === isatty(Deno.stdout.rid));
+  assert(Deno.isatty(Deno.stderr.rid) === isatty(Deno.stderr.rid));
+
+  const file = Deno.openSync("README.md");
+  assert(!isatty(file.rid));
+  Deno.close(file.rid);
+});
+
+Deno.test("[node/tty isatty] returns false for irrelevant values", () => {
+  // invalid numeric fd
+  assert(!isatty(1234567));
+
+  // TODO(kt3k): Enable this test when the below issue resolved
+  // https://github.com/denoland/deno/issues/14398
+  // assert(!isatty(-1));
+
+  // invalid type fd
+  assert(!isatty("abc" as any));
+  assert(!isatty({} as any));
+  assert(!isatty([] as any));
+  assert(!isatty(null as any));
+  assert(!isatty(undefined as any));
+});

cli/tests/unit_node/util_test.ts

@@ -0,0 +1,256 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import {
+  assert,
+  assertEquals,
+  assertStrictEquals,
+  assertThrows,
+} from "../../../test_util/std/testing/asserts.ts";
+import { stripColor } from "../../../test_util/std/fmt/colors.ts";
+import * as util from "node:util";
+
+Deno.test({
+  name: "[util] format",
+  fn() {
+    assertEquals(util.format("%o", [10, 11]), "[ 10, 11, [length]: 2 ]");
+  },
+});
+
+Deno.test({
+  name: "[util] inspect.custom",
+  fn() {
+    assertEquals(util.inspect.custom, Symbol.for("nodejs.util.inspect.custom"));
+  },
+});
+
+Deno.test({
+  name: "[util] inspect",
+  fn() {
+    assertEquals(stripColor(util.inspect({ foo: 123 })), "{ foo: 123 }");
+    assertEquals(stripColor(util.inspect("foo")), "'foo'");
+    assertEquals(
+      stripColor(util.inspect("Deno's logo is so cute.")),
+      `"Deno's logo is so cute."`,
+    );
+    assertEquals(
+      stripColor(util.inspect([1, 2, 3, 4, 5, 6, 7])),
+      `[
+  1, 2, 3, 4,
+  5, 6, 7
+]`,
+    );
+  },
+});
+
+Deno.test({
+  name: "[util] isBoolean",
+  fn() {
+    assert(util.isBoolean(true));
+    assert(util.isBoolean(new Boolean()));
+    assert(util.isBoolean(new Boolean(true)));
+    assert(util.isBoolean(false));
+    assert(!util.isBoolean("deno"));
+    assert(!util.isBoolean("true"));
+  },
+});
+
+Deno.test({
+  name: "[util] isNull",
+  fn() {
+    let n;
+    assert(util.isNull(null));
+    assert(!util.isNull(n));
+    assert(!util.isNull(0));
+    assert(!util.isNull({}));
+  },
+});
+
+Deno.test({
+  name: "[util] isNullOrUndefined",
+  fn() {
+    let n;
+    assert(util.isNullOrUndefined(null));
+    assert(util.isNullOrUndefined(n));
+    assert(!util.isNullOrUndefined({}));
+    assert(!util.isNullOrUndefined("undefined"));
+  },
+});
+
+Deno.test({
+  name: "[util] isNumber",
+  fn() {
+    assert(util.isNumber(666));
+    assert(util.isNumber(new Number(666)));
+    assert(!util.isNumber("999"));
+    assert(!util.isNumber(null));
+  },
+});
+
+Deno.test({
+  name: "[util] isString",
+  fn() {
+    assert(util.isString("deno"));
+    assert(util.isString(new String("DIO")));
+    assert(!util.isString(1337));
+  },
+});
+
+Deno.test({
+  name: "[util] isSymbol",
+  fn() {
+    assert(util.isSymbol(Symbol()));
+    assert(!util.isSymbol(123));
+    assert(!util.isSymbol("string"));
+  },
+});
+
+Deno.test({
+  name: "[util] isUndefined",
+  fn() {
+    let t;
+    assert(util.isUndefined(t));
+    assert(!util.isUndefined("undefined"));
+    assert(!util.isUndefined({}));
+  },
+});
+
+Deno.test({
+  name: "[util] isObject",
+  fn() {
+    const dio = { stand: "Za Warudo" };
+    assert(util.isObject(dio));
+    assert(util.isObject(new RegExp(/Toki Wo Tomare/)));
+    assert(!util.isObject("Jotaro"));
+  },
+});
+
+Deno.test({
+  name: "[util] isError",
+  fn() {
+    const java = new Error();
+    const nodejs = new TypeError();
+    const deno = "Future";
+    assert(util.isError(java));
+    assert(util.isError(nodejs));
+    assert(!util.isError(deno));
+  },
+});
+
+Deno.test({
+  name: "[util] isFunction",
+  fn() {
+    const f = function () {};
+    assert(util.isFunction(f));
+    assert(!util.isFunction({}));
+    assert(!util.isFunction(new RegExp(/f/)));
+  },
+});
+
+Deno.test({
+  name: "[util] isRegExp",
+  fn() {
+    assert(util.isRegExp(new RegExp(/f/)));
+    assert(util.isRegExp(/fuManchu/));
+    assert(!util.isRegExp({ evil: "eye" }));
+    assert(!util.isRegExp(null));
+  },
+});
+
+Deno.test({
+  name: "[util] isArray",
+  fn() {
+    assert(util.isArray([]));
+    assert(!util.isArray({ yaNo: "array" }));
+    assert(!util.isArray(null));
+  },
+});
+
+Deno.test({
+  name: "[util] isPrimitive",
+  fn() {
+    const stringType = "hasti";
+    const booleanType = true;
+    const integerType = 2;
+    const symbolType = Symbol("anything");
+
+    const functionType = function doBest() {};
+    const objectType = { name: "ali" };
+    const arrayType = [1, 2, 3];
+
+    assert(util.isPrimitive(stringType));
+    assert(util.isPrimitive(booleanType));
+    assert(util.isPrimitive(integerType));
+    assert(util.isPrimitive(symbolType));
+    assert(util.isPrimitive(null));
+    assert(util.isPrimitive(undefined));
+    assert(!util.isPrimitive(functionType));
+    assert(!util.isPrimitive(arrayType));
+    assert(!util.isPrimitive(objectType));
+  },
+});
+
+Deno.test({
+  name: "[util] TextDecoder",
+  fn() {
+    assert(util.TextDecoder === TextDecoder);
+    const td: util.TextDecoder = new util.TextDecoder();
+    assert(td instanceof TextDecoder);
+  },
+});
+
+Deno.test({
+  name: "[util] TextEncoder",
+  fn() {
+    assert(util.TextEncoder === TextEncoder);
+    const te: util.TextEncoder = new util.TextEncoder();
+    assert(te instanceof TextEncoder);
+  },
+});
+
+Deno.test({
+  name: "[util] isDate",
+  fn() {
+    // Test verifies the method is exposed. See _util/_util_types_test for details
+    assert(util.types.isDate(new Date()));
+  },
+});
+
+Deno.test({
+  name: "[util] getSystemErrorName()",
+  fn() {
+    type FnTestInvalidArg = (code?: unknown) => void;
+
+    assertThrows(
+      () => (util.getSystemErrorName as FnTestInvalidArg)(),
+      TypeError,
+    );
+    assertThrows(
+      () => (util.getSystemErrorName as FnTestInvalidArg)(1),
+      RangeError,
+    );
+
+    assertStrictEquals(util.getSystemErrorName(-424242), undefined);
+
+    switch (Deno.build.os) {
+      case "windows":
+        assertStrictEquals(util.getSystemErrorName(-4091), "EADDRINUSE");
+        break;
+
+      case "darwin":
+        assertStrictEquals(util.getSystemErrorName(-48), "EADDRINUSE");
+        break;
+
+      case "linux":
+        assertStrictEquals(util.getSystemErrorName(-98), "EADDRINUSE");
+        break;
+    }
+  },
+});
+
+Deno.test({
+  name: "[util] deprecate() works",
+  fn() {
+    const fn = util.deprecate(() => {}, "foo");
+    fn();
+  },
+});