chore: move cli/tests/ -> tests/ (#22369)

This looks like a massive PR, but it's only a move from cli/tests ->
tests, and updates of relative paths for files.

This is the first step towards aggregate all of the integration test
files under tests/, which will lead to a set of integration tests that
can run without the CLI binary being built.

While we could leave these tests under `cli`, it would require us to
keep a more complex directory structure for the various test runners. In
addition, we have a lot of complexity to ignore various test files in
the `cli` project itself (cargo publish exclusion rules, autotests =
false, etc).

And finally, the `tests/` folder will eventually house the `test_ffi`,
`test_napi` and other testing code, reducing the size of the root repo
directory.

For easier review, the extremely large and noisy "move" is in the first
commit (with no changes -- just a move), while the remainder of the
changes to actual files is in the second commit.

1 files changed, 146 insertions, 0 deletions

diff --git a/tests/unit_node/_fs/_fs_opendir_test.ts b/tests/unit_node/_fs/_fs_opendir_test.ts
new file mode 100644
index 000000000..d4abb349c
--- /dev/null
+++ b/tests/unit_node/_fs/_fs_opendir_test.ts
@@ -0,0 +1,146 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+import {
+  assert,
+  assertEquals,
+  assertFalse,
+  assertInstanceOf,
+  assertThrows,
+} from "@test_util/std/assert/mod.ts";
+import { opendir, opendirSync } from "node:fs";
+import { Buffer } from "node:buffer";
+import { assertCallbackErrorUncaught } from "../_test_utils.ts";
+
+Deno.test("[node/fs] opendir()", async (t) => {
+  const path = await Deno.makeTempDir();
+  const file = await Deno.makeTempFile();
+
+  await t.step(
+    "fails if encoding is invalid",
+    () =>
+      opendir(
+        path,
+        // @ts-expect-error Type '"invalid-encoding"' is not assignable to type 'BufferEncoding | undefined'
+        { encoding: "invalid-encoding" },
+        (err) => assertInstanceOf(err, TypeError),
+      ),
+  );
+
+  await t.step(
+    "fails if bufferSize is invalid",
+    () =>
+      opendir(
+        path,
+        { bufferSize: -1 },
+        (err) => assertInstanceOf(err, RangeError),
+      ),
+  );
+
+  await t.step(
+    "fails if directory does not exist",
+    () =>
+      opendir(
+        "directory-that-does-not-exist",
+        (err) => assertInstanceOf(err, Error),
+      ),
+  );
+
+  await t.step(
+    "fails if not a directory",
+    () =>
+      opendir(
+        file,
+        (err) => assertInstanceOf(err, Error),
+      ),
+  );
+
+  await t.step(
+    "passes if path is a string",
+    () =>
+      opendir(
+        path,
+        (err, dir) => {
+          assertEquals(err, null);
+          assert(dir);
+        },
+      ),
+  );
+
+  await t.step(
+    "passes if path is a Buffer",
+    () =>
+      opendir(
+        Buffer.from(path),
+        (err, dir) => {
+          assertFalse(err);
+          assert(dir);
+        },
+      ),
+  );
+
+  await t.step(
+    "passes if path is a URL",
+    () =>
+      opendir(
+        new URL(`file://` + path),
+        (err, dir) => {
+          assertFalse(err);
+          assert(dir);
+        },
+      ),
+  );
+
+  await t.step("passes if callback isn't called twice", async () => {
+    const importUrl = new URL("node:fs", import.meta.url);
+    await assertCallbackErrorUncaught({
+      prelude: `import { opendir } from ${JSON.stringify(importUrl)}`,
+      invocation: `opendir(${JSON.stringify(path)}, `,
+    });
+  });
+
+  await Deno.remove(path);
+  await Deno.remove(file);
+});
+
+Deno.test("[node/fs] opendirSync()", async (t) => {
+  const path = await Deno.makeTempDir();
+  const file = await Deno.makeTempFile();
+
+  await t.step("fails if encoding is invalid", () => {
+    assertThrows(
+      // @ts-expect-error Type '"invalid-encoding"' is not assignable to type 'BufferEncoding | undefined'
+      () => opendirSync(path, { encoding: "invalid-encoding" }),
+      TypeError,
+    );
+  });
+
+  await t.step("fails if bufferSize is invalid", () => {
+    assertThrows(
+      () => opendirSync(path, { bufferSize: -1 }),
+      RangeError,
+    );
+  });
+
+  await t.step("fails if directory does not exist", () => {
+    assertThrows(() => opendirSync("directory-that-does-not-exist"));
+  });
+
+  await t.step("fails if not a directory", () => {
+    assertThrows(() => opendirSync(file));
+  });
+
+  await t.step("passes if path is a string", () => {
+    assert(opendirSync(path));
+  });
+
+  await t.step("passes if path is a Buffer", () => {
+    assert(opendirSync(Buffer.from(path)));
+  });
+
+  await t.step("passes if path is a URL", () => {
+    assert(opendirSync(new URL(`file://` + path)));
+  });
+
+  await Deno.remove(path);
+  await Deno.remove(file);
+});