reduce unnecessary output on tests (#4148)

std/examples/colors.ts

@@ -1,4 +1,6 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 import { bgBlue, red, bold, italic } from "../fmt/colors.ts";
 
-console.log(bgBlue(italic(red(bold("Hello world!")))));
+if (import.meta.main) {
+  console.log(bgBlue(italic(red(bold("Hello world!")))));
+}

std/fs/empty_dir_test.ts

@@ -125,119 +125,119 @@ Deno.test(function emptyDirSyncIfItExist(): void {
   }
 });
 
-Deno.test(async function emptyDirPermission(): Promise<void> {
+interface Scenes {
-  interface Scenes {
+  read: boolean; // --allow-read
-    read: boolean; // --allow-read
+  write: boolean; // --allow-write
-    write: boolean; // --allow-write
+  async: boolean;
-    async: boolean;
+  output: string;
-    output: string;
+}
+const scenes: Scenes[] = [
+  // 1
+  {
+    read: false,
+    write: false,
+    async: true,
+    output: "run again with the --allow-read flag"
+  },
+  {
+    read: false,
+    write: false,
+    async: false,
+    output: "run again with the --allow-read flag"
+  },
+  // 2
+  {
+    read: true,
+    write: false,
+    async: true,
+    output: "run again with the --allow-write flag"
+  },
+  {
+    read: true,
+    write: false,
+    async: false,
+    output: "run again with the --allow-write flag"
+  },
+  // 3
+  {
+    read: false,
+    write: true,
+    async: true,
+    output: "run again with the --allow-read flag"
+  },
+  {
+    read: false,
+    write: true,
+    async: false,
+    output: "run again with the --allow-read flag"
+  },
+  // 4
+  {
+    read: true,
+    write: true,
+    async: true,
+    output: "success"
+  },
+  {
+    read: true,
+    write: true,
+    async: false,
+    output: "success"
   }
+];
+for (const s of scenes) {
+  let title = `test ${s.async ? "emptyDir" : "emptyDirSync"}`;
+  title += `("testdata/testfolder") ${s.read ? "with" : "without"}`;
+  title += ` --allow-read & ${s.write ? "with" : "without"} --allow-write`;
+  Deno.test(`[fs] emptyDirPermission ${title}`, async function(): Promise<
+    void
+  > {
+    const testfolder = path.join(testdataDir, "testfolder");
 
-  const testfolder = path.join(testdataDir, "testfolder");
+    try {
+      await Deno.mkdir(testfolder);
 
-  await Deno.mkdir(testfolder);
+      await Deno.writeFile(
-
+        path.join(testfolder, "child.txt"),
-  await Deno.writeFile(
+        new TextEncoder().encode("hello world")
-    path.join(testfolder, "child.txt"),
-    new TextEncoder().encode("hello world")
-  );
-
-  const scenes: Scenes[] = [
-    // 1
-    {
-      read: false,
-      write: false,
-      async: true,
-      output: "run again with the --allow-read flag"
-    },
-    {
-      read: false,
-      write: false,
-      async: false,
-      output: "run again with the --allow-read flag"
-    },
-    // 2
-    {
-      read: true,
-      write: false,
-      async: true,
-      output: "run again with the --allow-write flag"
-    },
-    {
-      read: true,
-      write: false,
-      async: false,
-      output: "run again with the --allow-write flag"
-    },
-    // 3
-    {
-      read: false,
-      write: true,
-      async: true,
-      output: "run again with the --allow-read flag"
-    },
-    {
-      read: false,
-      write: true,
-      async: false,
-      output: "run again with the --allow-read flag"
-    },
-    // 4
-    {
-      read: true,
-      write: true,
-      async: true,
-      output: "success"
-    },
-    {
-      read: true,
-      write: true,
-      async: false,
-      output: "success"
-    }
-  ];
-
-  try {
-    for (const s of scenes) {
-      console.log(
-        `test ${s.async ? "emptyDir" : "emptyDirSync"}("testdata/testfolder") ${
-          s.read ? "with" : "without"
-        } --allow-read & ${s.write ? "with" : "without"} --allow-write`
       );
 
-      const args = [Deno.execPath(), "run"];
+      try {
+        const args = [Deno.execPath(), "run"];
 
-      if (s.read) {
+        if (s.read) {
-        args.push("--allow-read");
+          args.push("--allow-read");
+        }
+
+        if (s.write) {
+          args.push("--allow-write");
+        }
+
+        args.push(
+          path.join(testdataDir, s.async ? "empty_dir.ts" : "empty_dir_sync.ts")
+        );
+        args.push("testfolder");
+
+        const { stdout } = Deno.run({
+          stdout: "piped",
+          cwd: testdataDir,
+          args: args
+        });
+
+        assert(stdout);
+
+        const output = await Deno.readAll(stdout);
+
+        assertStrContains(new TextDecoder().decode(output), s.output);
+      } catch (err) {
+        await Deno.remove(testfolder, { recursive: true });
+        throw err;
       }
-
+    } finally {
-      if (s.write) {
+      // Make the test rerunnable
-        args.push("--allow-write");
+      // Otherwise would throw error due to mkdir fail.
-      }
+      await Deno.remove(testfolder, { recursive: true });
-
+      // done
-      args.push(
-        path.join(testdataDir, s.async ? "empty_dir.ts" : "empty_dir_sync.ts")
-      );
-      args.push("testfolder");
-
-      const { stdout } = Deno.run({
-        stdout: "piped",
-        cwd: testdataDir,
-        args: args
-      });
-
-      assert(stdout);
-
-      const output = await Deno.readAll(stdout);
-
-      assertStrContains(new TextDecoder().decode(output), s.output);
     }
-  } catch (err) {
+  });
-    await Deno.remove(testfolder, { recursive: true });
+}
-    throw err;
-  }
-  // Make the test rerunnable
-  // Otherwise would throw error due to mkdir fail.
-  await Deno.remove(testfolder, { recursive: true });
-  // done
-});

std/fs/exists_test.ts

@@ -5,7 +5,7 @@ import { exists, existsSync } from "./exists.ts";
 
 const testdataDir = path.resolve("fs", "testdata");
 
-Deno.test(async function existsFile(): Promise<void> {
+Deno.test("[fs] existsFile", async function(): Promise<void> {
   assertEquals(
     await exists(path.join(testdataDir, "not_exist_file.ts")),
     false
@@ -13,12 +13,12 @@ Deno.test(async function existsFile(): Promise<void> {
   assertEquals(await existsSync(path.join(testdataDir, "0.ts")), true);
 });
 
-Deno.test(function existsFileSync(): void {
+Deno.test("[fs] existsFileSync", function(): void {
   assertEquals(existsSync(path.join(testdataDir, "not_exist_file.ts")), false);
   assertEquals(existsSync(path.join(testdataDir, "0.ts")), true);
 });
 
-Deno.test(async function existsDirectory(): Promise<void> {
+Deno.test("[fs] existsDirectory", async function(): Promise<void> {
   assertEquals(
     await exists(path.join(testdataDir, "not_exist_directory")),
     false
@@ -26,7 +26,7 @@ Deno.test(async function existsDirectory(): Promise<void> {
   assertEquals(existsSync(testdataDir), true);
 });
 
-Deno.test(function existsDirectorySync(): void {
+Deno.test("[fs] existsDirectorySync", function(): void {
   assertEquals(
     existsSync(path.join(testdataDir, "not_exist_directory")),
     false
@@ -34,88 +34,84 @@ Deno.test(function existsDirectorySync(): void {
   assertEquals(existsSync(testdataDir), true);
 });
 
-Deno.test(function existsLinkSync(): void {
+Deno.test("[fs] existsLinkSync", function(): void {
   // TODO(axetroy): generate link file use Deno api instead of set a link file
   // in repository
   assertEquals(existsSync(path.join(testdataDir, "0-link.ts")), true);
 });
 
-Deno.test(async function existsLink(): Promise<void> {
+Deno.test("[fs] existsLink", async function(): Promise<void> {
   // TODO(axetroy): generate link file use Deno api instead of set a link file
   // in repository
   assertEquals(await exists(path.join(testdataDir, "0-link.ts")), true);
 });
 
-Deno.test(async function existsPermission(): Promise<void> {
+interface Scenes {
-  interface Scenes {
+  read: boolean; // --allow-read
-    read: boolean; // --allow-read
+  async: boolean;
-    async: boolean;
+  output: string;
-    output: string;
+  file: string; // target file to run
-    file: string; // target file to run
+}
+
+const scenes: Scenes[] = [
+  // 1
+  {
+    read: false,
+    async: true,
+    output: "run again with the --allow-read flag",
+    file: "0.ts"
+  },
+  {
+    read: false,
+    async: false,
+    output: "run again with the --allow-read flag",
+    file: "0.ts"
+  },
+  // 2
+  {
+    read: true,
+    async: true,
+    output: "exist",
+    file: "0.ts"
+  },
+  {
+    read: true,
+    async: false,
+    output: "exist",
+    file: "0.ts"
+  },
+  // 3
+  {
+    read: false,
+    async: true,
+    output: "run again with the --allow-read flag",
+    file: "no_exist_file_for_test.ts"
+  },
+  {
+    read: false,
+    async: false,
+    output: "run again with the --allow-read flag",
+    file: "no_exist_file_for_test.ts"
+  },
+  // 4
+  {
+    read: true,
+    async: true,
+    output: "not exist",
+    file: "no_exist_file_for_test.ts"
+  },
+  {
+    read: true,
+    async: false,
+    output: "not exist",
+    file: "no_exist_file_for_test.ts"
   }
+];
 
-  const scenes: Scenes[] = [
+for (const s of scenes) {
-    // 1
+  let title = `test ${s.async ? "exists" : "existsSync"}("testdata/${s.file}")`;
-    {
+  title += ` ${s.read ? "with" : "without"} --allow-read`;
-      read: false,
+  Deno.test(`[fs] existsPermission ${title}`, async function(): Promise<void> {
-      async: true,
-      output: "run again with the --allow-read flag",
-      file: "0.ts"
-    },
-    {
-      read: false,
-      async: false,
-      output: "run again with the --allow-read flag",
-      file: "0.ts"
-    },
-    // 2
-    {
-      read: true,
-      async: true,
-      output: "exist",
-      file: "0.ts"
-    },
-    {
-      read: true,
-      async: false,
-      output: "exist",
-      file: "0.ts"
-    },
-    // 3
-    {
-      read: false,
-      async: true,
-      output: "run again with the --allow-read flag",
-      file: "no_exist_file_for_test.ts"
-    },
-    {
-      read: false,
-      async: false,
-      output: "run again with the --allow-read flag",
-      file: "no_exist_file_for_test.ts"
-    },
-    // 4
-    {
-      read: true,
-      async: true,
-      output: "not exist",
-      file: "no_exist_file_for_test.ts"
-    },
-    {
-      read: true,
-      async: false,
-      output: "not exist",
-      file: "no_exist_file_for_test.ts"
-    }
-  ];
-
-  for (const s of scenes) {
-    console.log(
-      `test ${s.async ? "exists" : "existsSync"}("testdata/${s.file}") ${
-        s.read ? "with" : "without"
-      } --allow-read`
-    );
-
     const args = [Deno.execPath(), "run"];
 
     if (s.read) {
@@ -134,7 +130,6 @@ Deno.test(async function existsPermission(): Promise<void> {
     const output = await Deno.readAll(stdout!);
 
     assertStrContains(new TextDecoder().decode(output), s.output);
-  }
+  });
-
   // done
-});
+}

std/http/file_server_test.ts

@@ -16,7 +16,8 @@ async function startFileServer(): Promise<void> {
       ".",
       "--cors"
     ],
-    stdout: "piped"
+    stdout: "piped",
+    stderr: "null"
   });
   // Once fileServer is ready it will write to its stdout.
   assert(fileServer.stdout != null);

std/io/util_test.ts

@@ -4,7 +4,7 @@ import { assert, assertEquals } from "../testing/asserts.ts";
 import * as path from "../path/mod.ts";
 import { copyBytes, tempFile } from "./util.ts";
 
-test(function testCopyBytes(): void {
+test("[io/tuil] copyBytes", function(): void {
   const dst = new Uint8Array(4);
 
   dst.fill(0);
@@ -38,12 +38,11 @@ test(function testCopyBytes(): void {
   assertEquals(dst, Uint8Array.of(3, 4, 0, 0));
 });
 
-test(async function ioTempfile(): Promise<void> {
+test("[io/util] tempfile", async function(): Promise<void> {
   const f = await tempFile(".", {
     prefix: "prefix-",
     postfix: "-postfix"
   });
-  console.log(f.file, f.filepath);
   const base = path.basename(f.filepath);
   assert(!!base.match(/^prefix-.+?-postfix$/));
   await remove(f.filepath);

std/uuid/tests/isNil.ts

@@ -11,6 +11,5 @@ test({
     const u = "582cbcff-dad6-4f28-888a-e062ae36bafc";
     assert(isNil(nil));
     assert(!isNil(u));
-    console.log("");
   }
 });