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

diff --git a/cli/tests/unit_node/_fs/_fs_read_test.ts b/cli/tests/unit_node/_fs/_fs_read_test.ts
deleted file mode 100644
index de741e377..000000000
--- a/cli/tests/unit_node/_fs/_fs_read_test.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import {
-  assertEquals,
-  assertFalse,
-  assertMatch,
-  assertStrictEquals,
-} from "@test_util/std/assert/mod.ts";
-import { read, readSync } from "node:fs";
-import { open, openSync } from "node:fs";
-import { Buffer } from "node:buffer";
-import * as path from "@test_util/std/path/mod.ts";
-import { closeSync } from "node:fs";
-
-async function readTest(
-  testData: string,
-  buffer: Buffer,
-  offset: number,
-  length: number,
-  position: number | null = null,
-  expected: (
-    fd: number,
-    bytesRead: number | null,
-    data: Buffer | undefined,
-  ) => void,
-) {
-  let fd1 = 0;
-  await new Promise<{
-    fd: number;
-    bytesRead: number | null;
-    data: Buffer | undefined;
-  }>((resolve, reject) => {
-    open(testData, "r", (err, fd) => {
-      if (err) reject(err);
-      read(fd, buffer, offset, length, position, (err, bytesRead, data) => {
-        if (err) reject(err);
-        resolve({ fd, bytesRead, data });
-      });
-    });
-  })
-    .then(({ fd, bytesRead, data }) => {
-      fd1 = fd;
-      expected(fd, bytesRead, data);
-    })
-    .finally(() => closeSync(fd1));
-}
-
-Deno.test({
-  name: "readSuccess",
-  async fn() {
-    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
-    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
-    const buf = Buffer.alloc(1024);
-    await readTest(
-      testData,
-      buf,
-      buf.byteOffset,
-      buf.byteLength,
-      null,
-      (_fd, bytesRead, data) => {
-        assertStrictEquals(bytesRead, 11);
-        assertEquals(data instanceof Buffer, true);
-        assertMatch((data as Buffer).toString(), /hello world/);
-      },
-    );
-  },
-});
-
-Deno.test({
-  name:
-    "[std/node/fs] Read only five bytes, so that the position moves to five",
-  async fn() {
-    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
-    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
-    const buf = Buffer.alloc(5);
-    await readTest(
-      testData,
-      buf,
-      buf.byteOffset,
-      5,
-      null,
-      (_fd, bytesRead, data) => {
-        assertStrictEquals(bytesRead, 5);
-        assertEquals(data instanceof Buffer, true);
-        assertEquals((data as Buffer).toString(), "hello");
-      },
-    );
-  },
-});
-
-Deno.test({
-  name:
-    "[std/node/fs] position option of fs.read() specifies where to begin reading from in the file",
-  async fn() {
-    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
-    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
-    const fd = openSync(testData, "r");
-    const buf = Buffer.alloc(5);
-    const positions = [6, 0, -1, null];
-    const expected = [
-      [119, 111, 114, 108, 100],
-      [104, 101, 108, 108, 111],
-      [104, 101, 108, 108, 111],
-      [32, 119, 111, 114, 108],
-    ];
-    for (const [i, position] of positions.entries()) {
-      await new Promise((resolve) => {
-        read(
-          fd,
-          {
-            buffer: buf,
-            offset: buf.byteOffset,
-            length: buf.byteLength,
-            position,
-          },
-          (err, bytesRead, data) => {
-            assertEquals(err, null);
-            assertStrictEquals(bytesRead, 5);
-            assertEquals(
-              data,
-              Buffer.from(expected[i]),
-            );
-            return resolve(true);
-          },
-        );
-      });
-    }
-    closeSync(fd);
-  },
-});
-
-Deno.test({
-  name: "[std/node/fs] Read fs.read(fd, options, cb) signature",
-  async fn() {
-    const { promise, reject, resolve } = Promise.withResolvers<void>();
-    const file = Deno.makeTempFileSync();
-    Deno.writeTextFileSync(file, "hi there");
-    const fd = openSync(file, "r+");
-    const buf = Buffer.alloc(11);
-    read(
-      fd,
-      {
-        buffer: buf,
-        offset: buf.byteOffset,
-        length: buf.byteLength,
-        position: null,
-      },
-      (err, bytesRead, data) => {
-        try {
-          assertEquals(err, null);
-          assertStrictEquals(bytesRead, 8);
-          assertEquals(
-            data,
-            Buffer.from([104, 105, 32, 116, 104, 101, 114, 101, 0, 0, 0]),
-          );
-        } catch (e) {
-          reject(e);
-          return;
-        }
-        resolve();
-      },
-    );
-    closeSync(fd);
-    await promise;
-  },
-});
-
-Deno.test({
-  name: "[std/node/fs] Read fs.read(fd, cb) signature",
-  async fn() {
-    const { promise, resolve, reject } = Promise.withResolvers<void>();
-    const file = Deno.makeTempFileSync();
-    Deno.writeTextFileSync(file, "hi deno");
-    const fd = openSync(file, "r+");
-    read(fd, (err, bytesRead, data) => {
-      try {
-        assertEquals(err, null);
-        assertStrictEquals(bytesRead, 7);
-        assertStrictEquals(data?.byteLength, 16384);
-      } catch (e) {
-        reject(e);
-        return;
-      }
-      resolve();
-    });
-    closeSync(fd);
-    await promise;
-  },
-});
-
-Deno.test({
-  name: "SYNC: readSuccess",
-  fn() {
-    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
-    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
-    const buffer = Buffer.alloc(1024);
-    const fd = openSync(testData, "r");
-    const bytesRead = readSync(
-      fd,
-      buffer,
-      buffer.byteOffset,
-      buffer.byteLength,
-      null,
-    );
-    assertStrictEquals(bytesRead, 11);
-    closeSync(fd);
-  },
-});
-
-Deno.test({
-  name: "[std/node/fs] Read only two bytes, so that the position moves to two",
-  fn() {
-    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
-    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
-    const buffer = Buffer.alloc(2);
-    const fd = openSync(testData, "r");
-    const bytesRead = readSync(fd, buffer, buffer.byteOffset, 2, null);
-    assertStrictEquals(bytesRead, 2);
-    closeSync(fd);
-  },
-});
-
-Deno.test({
-  name:
-    "[std/node/fs] position option of fs.readSync() specifies where to begin reading from in the file",
-  fn() {
-    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
-    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
-    const fd = openSync(testData, "r");
-    const buf = Buffer.alloc(5);
-    const positions = [6, 0, -1, null];
-    const expected = [
-      [119, 111, 114, 108, 100],
-      [104, 101, 108, 108, 111],
-      [104, 101, 108, 108, 111],
-      [32, 119, 111, 114, 108],
-    ];
-    for (const [i, position] of positions.entries()) {
-      const bytesRead = readSync(
-        fd,
-        buf,
-        buf.byteOffset,
-        buf.byteLength,
-        position,
-      );
-      assertStrictEquals(bytesRead, 5);
-      assertEquals(
-        buf,
-        Buffer.from(expected[i]),
-      );
-    }
-    closeSync(fd);
-  },
-});
-
-Deno.test({
-  name: "[std/node/fs] Read fs.readSync(fd, buffer[, options]) signature",
-  fn() {
-    const file = Deno.makeTempFileSync();
-    Deno.writeTextFileSync(file, "hello deno");
-    const buffer = Buffer.alloc(1024);
-    const fd = openSync(file, "r+");
-    const bytesRead = readSync(fd, buffer, {
-      length: buffer.byteLength,
-      offset: buffer.byteOffset,
-      position: null,
-    });
-    assertStrictEquals(bytesRead, 10);
-    closeSync(fd);
-  },
-});
-
-Deno.test({
-  name: "[std/node/fs] fs.read is async",
-  async fn(t) {
-    const file = await Deno.makeTempFile();
-    await Deno.writeTextFile(file, "abc");
-
-    await t.step("without position option", async () => {
-      const { promise, resolve } = Promise.withResolvers<void>();
-      let called = false;
-      const fd = openSync(file, "r");
-      read(fd, () => {
-        called = true;
-        closeSync(fd);
-        resolve();
-      });
-      assertFalse(called);
-      await promise;
-    });
-
-    await t.step("with position option", async () => {
-      const { promise, resolve } = Promise.withResolvers<void>();
-      let called = false;
-      const buffer = Buffer.alloc(2);
-      const fd = openSync(file, "r");
-      read(fd, { position: 1, buffer, offset: 0, length: 2 }, () => {
-        called = true;
-        closeSync(fd);
-        resolve();
-      });
-      assertFalse(called);
-      await promise;
-    });
-
-    await Deno.remove(file);
-  },
-});
-
-Deno.test({
-  name: "SYNC: read with no offsetOropts argument",
-  fn() {
-    const moduleDir = path.dirname(path.fromFileUrl(import.meta.url));
-    const testData = path.resolve(moduleDir, "testdata", "hello.txt");
-    const buffer = Buffer.alloc(1024);
-    const fd = openSync(testData, "r");
-    const _bytesRead = readSync(
-      fd,
-      buffer,
-    );
-    closeSync(fd);
-  },
-});