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, 112 insertions, 0 deletions

diff --git a/tests/unit_node/internal/_randomBytes_test.ts b/tests/unit_node/internal/_randomBytes_test.ts
new file mode 100644
index 000000000..13ee82566
--- /dev/null
+++ b/tests/unit_node/internal/_randomBytes_test.ts
@@ -0,0 +1,112 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+import {
+  assert,
+  assertEquals,
+  assertRejects,
+  assertThrows,
+} from "@test_util/std/assert/mod.ts";
+import { assertCallbackErrorUncaught } from "../_test_utils.ts";
+import { pseudoRandomBytes, randomBytes } from "node:crypto";
+
+const MAX_RANDOM_VALUES = 65536;
+const MAX_SIZE = 4294967295;
+
+Deno.test("randomBytes sync works correctly", function () {
+  assertEquals(randomBytes(0).length, 0, "len: " + 0);
+  assertEquals(randomBytes(3).length, 3, "len: " + 3);
+  assertEquals(randomBytes(30).length, 30, "len: " + 30);
+  assertEquals(randomBytes(300).length, 300, "len: " + 300);
+  assertEquals(
+    randomBytes(17 + MAX_RANDOM_VALUES).length,
+    17 + MAX_RANDOM_VALUES,
+    "len: " + 17 + MAX_RANDOM_VALUES,
+  );
+  assertEquals(
+    randomBytes(MAX_RANDOM_VALUES * 100).length,
+    MAX_RANDOM_VALUES * 100,
+    "len: " + MAX_RANDOM_VALUES * 100,
+  );
+  assertThrows(() => randomBytes(MAX_SIZE + 1));
+  assertThrows(() => randomBytes(-1));
+});
+
+Deno.test("randomBytes async works correctly", async function () {
+  randomBytes(0, function (err, resp) {
+    assert(!err);
+    assertEquals(resp?.length, 0, "len: " + 0);
+  });
+  randomBytes(3, function (err, resp) {
+    assert(!err);
+    assertEquals(resp?.length, 3, "len: " + 3);
+  });
+  randomBytes(30, function (err, resp) {
+    assert(!err);
+    assertEquals(resp?.length, 30, "len: " + 30);
+  });
+  randomBytes(300, function (err, resp) {
+    assert(!err);
+    assertEquals(resp?.length, 300, "len: " + 300);
+  });
+  randomBytes(17 + MAX_RANDOM_VALUES, function (err, resp) {
+    assert(!err);
+    assertEquals(
+      resp?.length,
+      17 + MAX_RANDOM_VALUES,
+      "len: " + 17 + MAX_RANDOM_VALUES,
+    );
+  });
+  randomBytes(MAX_RANDOM_VALUES * 100, function (err, resp) {
+    assert(!err);
+    assertEquals(
+      resp?.length,
+      MAX_RANDOM_VALUES * 100,
+      "len: " + MAX_RANDOM_VALUES * 100,
+    );
+  });
+  assertThrows(() =>
+    randomBytes(MAX_SIZE + 1, function (err) {
+      //Shouldn't throw async
+      assert(!err);
+    })
+  );
+  await assertRejects(() =>
+    new Promise((resolve, reject) => {
+      randomBytes(-1, function (err, res) {
+        //Shouldn't throw async
+        if (err) {
+          reject(err);
+        } else {
+          resolve(res);
+        }
+      });
+    })
+  );
+});
+
+Deno.test("[std/node/crypto] randomBytes callback isn't called twice if error is thrown", async () => {
+  const importUrl = new URL("node:crypto", import.meta.url);
+  await assertCallbackErrorUncaught({
+    prelude: `import { randomBytes } from ${JSON.stringify(importUrl)}`,
+    invocation: "randomBytes(0, ",
+  });
+});
+
+// https://github.com/denoland/deno/issues/21632
+Deno.test("pseudoRandomBytes works", function () {
+  assertEquals(pseudoRandomBytes(0).length, 0, "len: " + 0);
+  assertEquals(pseudoRandomBytes(3).length, 3, "len: " + 3);
+  assertEquals(pseudoRandomBytes(30).length, 30, "len: " + 30);
+  assertEquals(pseudoRandomBytes(300).length, 300, "len: " + 300);
+  assertEquals(
+    pseudoRandomBytes(17 + MAX_RANDOM_VALUES).length,
+    17 + MAX_RANDOM_VALUES,
+    "len: " + 17 + MAX_RANDOM_VALUES,
+  );
+  assertEquals(
+    pseudoRandomBytes(MAX_RANDOM_VALUES * 100).length,
+    MAX_RANDOM_VALUES * 100,
+    "len: " + MAX_RANDOM_VALUES * 100,
+  );
+  assertThrows(() => pseudoRandomBytes(MAX_SIZE + 1));
+  assertThrows(() => pseudoRandomBytes(-1));
+});