test(node/fs): add fs.Dir tests (denoland#18463)

Co-authored-by: Yoshiya Hinosawa <[email protected]>

cli/tests/unit_node/_fs/_fs_dir_test.ts

@@ -0,0 +1,209 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import {
+ assert,
+ assertEquals,
+ fail,
+} from "../../../../test_util/std/testing/asserts.ts";
+import { assertCallbackErrorUncaught } from "../_test_utils.ts";
+import { Dir as DirOrig, type Dirent } from "node:fs";
+
+// deno-lint-ignore no-explicit-any
+const Dir = DirOrig as any;
+
+Deno.test({
+ name: "Closing current directory with callback is successful",
+ fn() {
+ let calledBack = false;
+ // deno-lint-ignore no-explicit-any
+ new Dir(".").close((valOrErr: any) => {
+ assert(!valOrErr);
+ calledBack = true;
+ });
+ assert(calledBack);
+ },
+});
+
+Deno.test({
+ name: "Closing current directory without callback returns void Promise",
+ async fn() {
+ await new Dir(".").close();
+ },
+});
+
+Deno.test({
+ name: "Closing current directory synchronously works",
+ fn() {
+ new Dir(".").closeSync();
+ },
+});
+
+Deno.test({
+ name: "Path is correctly returned",
+ fn() {
+ assertEquals(new Dir("std/node").path, "std/node");
+
+ const enc: Uint8Array = new TextEncoder().encode("std/node");
+ assertEquals(new Dir(enc).path, "std/node");
+ },
+});
+
+Deno.test({
+ name: "read returns null for empty directory",
+ async fn() {
+ const testDir: string = Deno.makeTempDirSync();
+ try {
+ const file: Dirent | null = await new Dir(testDir).read();
+ assert(file === null);
+
+ let calledBack = false;
+ const fileFromCallback: Dirent | null = await new Dir(
+ testDir,
+ // deno-lint-ignore no-explicit-any
+ ).read((err: any, res: Dirent) => {
+ assert(res === null);
+ assert(err === null);
+ calledBack = true;
+ });
+ assert(fileFromCallback === null);
+ assert(calledBack);
+
+ assertEquals(new Dir(testDir).readSync(), null);
+ } finally {
+ Deno.removeSync(testDir);
+ }
+ },
+});
+
+Deno.test({
+ name: "Async read returns one file at a time",
+ async fn() {
+ const testDir: string = Deno.makeTempDirSync();
+ const f1 = Deno.createSync(testDir + "/foo.txt");
+ f1.close();
+ const f2 = Deno.createSync(testDir + "/bar.txt");
+ f2.close();
+
+ try {
+ let secondCallback = false;
+ const dir = new Dir(testDir);
+ const firstRead: Dirent | null = await dir.read();
+ const secondRead: Dirent | null = await dir.read(
+ // deno-lint-ignore no-explicit-any
+ (_err: any, secondResult: Dirent) => {
+ assert(
+ secondResult.name === "bar.txt" || secondResult.name === "foo.txt",
+ );
+ secondCallback = true;
+ },
+ );
+ const thirdRead: Dirent | null = await dir.read();
+ const fourthRead: Dirent | null = await dir.read();
+
+ if (firstRead?.name === "foo.txt") {
+ assertEquals(secondRead?.name, "bar.txt");
+ } else if (firstRead?.name === "bar.txt") {
+ assertEquals(secondRead?.name, "foo.txt");
+ } else {
+ fail("File not found during read");
+ }
+ assert(secondCallback);
+ assert(thirdRead === null);
+ assert(fourthRead === null);
+ } finally {
+ Deno.removeSync(testDir, { recursive: true });
+ }
+ },
+});
+
+Deno.test({
+ name: "Sync read returns one file at a time",
+ fn() {
+ const testDir: string = Deno.makeTempDirSync();
+ const f1 = Deno.createSync(testDir + "/foo.txt");
+ f1.close();
+ const f2 = Deno.createSync(testDir + "/bar.txt");
+ f2.close();
+
+ try {
+ const dir = new Dir(testDir);
+ const firstRead: Dirent | null = dir.readSync();
+ const secondRead: Dirent | null = dir.readSync();
+ const thirdRead: Dirent | null = dir.readSync();
+ const fourthRead: Dirent | null = dir.readSync();
+
+ if (firstRead?.name === "foo.txt") {
+ assertEquals(secondRead?.name, "bar.txt");
+ } else if (firstRead?.name === "bar.txt") {
+ assertEquals(secondRead?.name, "foo.txt");
+ } else {
+ fail("File not found during read");
+ }
+ assert(thirdRead === null);
+ assert(fourthRead === null);
+ } finally {
+ Deno.removeSync(testDir, { recursive: true });
+ }
+ },
+});
+
+Deno.test({
+ name: "Async iteration over existing directory",
+ async fn() {
+ const testDir: string = Deno.makeTempDirSync();
+ const f1 = Deno.createSync(testDir + "/foo.txt");
+ f1.close();
+ const f2 = Deno.createSync(testDir + "/bar.txt");
+ f2.close();
+
+ try {
+ const dir = new Dir(testDir);
+ const results: Array<string | null> = [];
+
+ for await (const file of dir[Symbol.asyncIterator]()) {
+ results.push(file.name);
+ }
+
+ assert(results.length === 2);
+ assert(results.includes("foo.txt"));
+ assert(results.includes("bar.txt"));
+ } finally {
+ Deno.removeSync(testDir, { recursive: true });
+ }
+ },
+});
+
+Deno.test(
+ "[std/node/fs] Dir.close callback isn't called twice if error is thrown",
+ async () => {
+ const tempDir = await Deno.makeTempDir();
+ await assertCallbackErrorUncaught({
+ prelude: `
+ import { Dir } from "node:fs";
+
+ const dir = new Dir(${JSON.stringify(tempDir)});
+ `,
+ invocation: "dir.close(",
+ async cleanup() {
+ await Deno.remove(tempDir);
+ },
+ });
+ },
+);
+
+Deno.test(
+ "[std/node/fs] Dir.read callback isn't called twice if error is thrown",
+ async () => {
+ const tempDir = await Deno.makeTempDir();
+ await assertCallbackErrorUncaught({
+ prelude: `
+ import { Dir } from "node:fs";
+
+ const dir = new Dir(${JSON.stringify(tempDir)});
+ `,
+ invocation: "dir.read(",
+ async cleanup() {
+ await Deno.remove(tempDir);
+ },
+ });
+ },
+);