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

diff --git a/tests/unit/fs_events_test.ts b/tests/unit/fs_events_test.ts
new file mode 100644
index 000000000..4f7cdc4d5
--- /dev/null
+++ b/tests/unit/fs_events_test.ts
@@ -0,0 +1,139 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+import { assert, assertEquals, assertThrows, delay } from "./test_util.ts";
+
+// TODO(ry) Add more tests to specify format.
+
+Deno.test({ permissions: { read: false } }, function watchFsPermissions() {
+  assertThrows(() => {
+    Deno.watchFs(".");
+  }, Deno.errors.PermissionDenied);
+});
+
+Deno.test({ permissions: { read: true } }, function watchFsInvalidPath() {
+  if (Deno.build.os === "windows") {
+    assertThrows(
+      () => {
+        Deno.watchFs("non-existent.file");
+      },
+      Error,
+      "Input watch path is neither a file nor a directory",
+    );
+  } else {
+    assertThrows(() => {
+      Deno.watchFs("non-existent.file");
+    }, Deno.errors.NotFound);
+  }
+});
+
+async function getTwoEvents(
+  iter: Deno.FsWatcher,
+): Promise<Deno.FsEvent[]> {
+  const events = [];
+  for await (const event of iter) {
+    events.push(event);
+    if (events.length > 2) break;
+  }
+  return events;
+}
+
+async function makeTempDir(): Promise<string> {
+  const testDir = await Deno.makeTempDir();
+  // The watcher sometimes witnesses the creation of it's own root
+  // directory. Delay a bit.
+  await delay(100);
+  return testDir;
+}
+
+Deno.test(
+  { permissions: { read: true, write: true } },
+  async function watchFsBasic() {
+    const testDir = await makeTempDir();
+    const iter = Deno.watchFs(testDir);
+
+    // Asynchronously capture two fs events.
+    const eventsPromise = getTwoEvents(iter);
+
+    // Make some random file system activity.
+    const file1 = testDir + "/file1.txt";
+    const file2 = testDir + "/file2.txt";
+    Deno.writeFileSync(file1, new Uint8Array([0, 1, 2]));
+    Deno.writeFileSync(file2, new Uint8Array([0, 1, 2]));
+
+    // We should have gotten two fs events.
+    const events = await eventsPromise;
+    assert(events.length >= 2);
+    assert(events[0].kind == "create");
+    assert(events[0].paths[0].includes(testDir));
+    assert(events[1].kind == "create" || events[1].kind == "modify");
+    assert(events[1].paths[0].includes(testDir));
+  },
+);
+
+// TODO(kt3k): This test is for the backward compatibility of `.return` method.
+// This should be removed at 2.0
+Deno.test(
+  { permissions: { read: true, write: true } },
+  async function watchFsReturn() {
+    const testDir = await makeTempDir();
+    const iter = Deno.watchFs(testDir);
+
+    // Asynchronously loop events.
+    const eventsPromise = getTwoEvents(iter);
+
+    // Close the watcher.
+    await iter.return!();
+
+    // Expect zero events.
+    const events = await eventsPromise;
+    assertEquals(events, []);
+  },
+);
+
+Deno.test(
+  { permissions: { read: true, write: true } },
+  async function watchFsClose() {
+    const testDir = await makeTempDir();
+    const iter = Deno.watchFs(testDir);
+
+    // Asynchronously loop events.
+    const eventsPromise = getTwoEvents(iter);
+
+    // Close the watcher.
+    iter.close();
+
+    // Expect zero events.
+    const events = await eventsPromise;
+    assertEquals(events, []);
+  },
+);
+
+Deno.test(
+  { permissions: { read: true, write: true } },
+  async function watchFsExplicitResourceManagement() {
+    let res;
+    {
+      const testDir = await makeTempDir();
+      using iter = Deno.watchFs(testDir);
+
+      res = iter[Symbol.asyncIterator]().next();
+    }
+
+    const { done } = await res;
+    assert(done);
+  },
+);
+
+Deno.test(
+  { permissions: { read: true, write: true } },
+  async function watchFsExplicitResourceManagementManualClose() {
+    const testDir = await makeTempDir();
+    using iter = Deno.watchFs(testDir);
+
+    const res = iter[Symbol.asyncIterator]().next();
+
+    iter.close();
+    const { done } = await res;
+    assert(done);
+  },
+);