Add setUp and tearDown to simplify tests.

examples/test.ts

@@ -13,7 +13,8 @@ test(function t2() {
 /** A more complicated test that runs a subprocess. */
 test(async function catSmoke() {
   const p = run({
-    args: ["deno", "examples/cat.ts", "README.md"]
+    args: ["deno", "examples/cat.ts", "README.md"],
+    stdout: "piped"
   });
   const s = await p.status();
   assertEqual(s.code, 0);

http/file_server_test.ts

@@ -1,51 +1,49 @@
-import { readFile } from "deno";
+import { readFile, run } from "deno";
 
-import { test, assert, assertEqual } from "../testing/mod.ts";
+import { test, assert, assertEqual, setUp, tearDown } from "../testing/mod.ts";
+import { BufReader } from "../io/bufio.ts";
+import { TextProtoReader } from "../textproto/mod.ts";
 
-// Promise to completeResolve when all tests completes
-let completeResolve;
-export const completePromise = new Promise(res => (completeResolve = res));
-let completedTestCount = 0;
-
-function maybeCompleteTests() {
-  completedTestCount++;
-  // Change this when adding more tests
-  if (completedTestCount === 3) {
-    completeResolve();
-  }
-}
-
-export function runTests(serverReadyPromise: Promise<any>) {
-  test(async function serveFile() {
-    await serverReadyPromise;
-    const res = await fetch("http://localhost:4500/azure-pipelines.yml");
-    assert(res.headers.has("access-control-allow-origin"));
-    assert(res.headers.has("access-control-allow-headers"));
-    assertEqual(res.headers.get("content-type"), "text/yaml; charset=utf-8");
-    const downloadedFile = await res.text();
-    const localFile = new TextDecoder().decode(
-      await readFile("./azure-pipelines.yml")
-    );
-    assertEqual(downloadedFile, localFile);
-    maybeCompleteTests();
+let fileServer;
+setUp(async function startFileServer() {
+  fileServer = run({
+    args: ["deno", "--allow-net", "http/file_server.ts", ".", "--cors"],
+    stdout: "piped"
   });
+  // Once fileServer is ready it will write to its stdout.
+  const r = new TextProtoReader(new BufReader(fileServer.stdout));
+  const [s, err] = await r.readLine();
+  assert(err == null);
+  assert(s.includes("server listening"));
+});
+tearDown(function killFileServer() {
+  fileServer.close();
+  fileServer.stdout.close();
+});
 
-  test(async function serveDirectory() {
-    await serverReadyPromise;
-    const res = await fetch("http://localhost:4500/");
-    assert(res.headers.has("access-control-allow-origin"));
-    assert(res.headers.has("access-control-allow-headers"));
-    const page = await res.text();
-    assert(page.includes("azure-pipelines.yml"));
-    maybeCompleteTests();
-  });
+test(async function serveFile() {
+  const res = await fetch("http://localhost:4500/azure-pipelines.yml");
+  assert(res.headers.has("access-control-allow-origin"));
+  assert(res.headers.has("access-control-allow-headers"));
+  assertEqual(res.headers.get("content-type"), "text/yaml; charset=utf-8");
+  const downloadedFile = await res.text();
+  const localFile = new TextDecoder().decode(
+    await readFile("./azure-pipelines.yml")
+  );
+  assertEqual(downloadedFile, localFile);
+});
 
-  test(async function serveFallback() {
-    await serverReadyPromise;
-    const res = await fetch("http://localhost:4500/badfile.txt");
-    assert(res.headers.has("access-control-allow-origin"));
-    assert(res.headers.has("access-control-allow-headers"));
-    assertEqual(res.status, 404);
-    maybeCompleteTests();
-  });
-}
+test(async function serveDirectory() {
+  const res = await fetch("http://localhost:4500/");
+  assert(res.headers.has("access-control-allow-origin"));
+  assert(res.headers.has("access-control-allow-headers"));
+  const page = await res.text();
+  assert(page.includes("azure-pipelines.yml"));
+});
+
+test(async function serveFallback() {
+  const res = await fetch("http://localhost:4500/badfile.txt");
+  assert(res.headers.has("access-control-allow-origin"));
+  assert(res.headers.has("access-control-allow-headers"));
+  assertEqual(res.status, 404);
+});

test.ts

@@ -17,20 +17,11 @@ import "fs/path/resolve_test.ts";
 import "fs/path/zero_length_strings_test.ts";
 import "io/bufio_test.ts";
 import "http/http_test.ts";
+import "http/file_server_test.ts";
 import "log/test.ts";
 import "media_types/test.ts";
 import "testing/test.ts";
 import "textproto/test.ts";
+import "ws/ioutil_test.ts";
+import "ws/sha1_test.ts";
 import "ws/test.ts";
-
-import { runTests, completePromise } from "http/file_server_test.ts";
-
-const fileServer = run({
-  args: ["deno", "--allow-net", "http/file_server.ts", ".", "--cors"]
-});
-
-runTests(new Promise(res => setTimeout(res, 5000)));
-(async () => {
-  await completePromise;
-  fileServer.close();
-})();

testing/main.ts

@@ -0,0 +1,20 @@
+import { args } from "deno";
+import { runTests, cancelTests, setFilter } from "./mod.ts";
+import { parse } from "../flags/mod.ts";
+import { resolve } from "../fs/path.ts";
+
+cancelTests();
+
+const a = parse(args);
+const filter = a.grep || ".*";
+// TODO support globs and recursive.
+const test_files = a._.slice(1).map(p => resolve(p));
+
+setFilter(filter);
+
+(async () => {
+  for (let fn of test_files) {
+    await import(fn);
+  }
+  await runTests();
+})();

testing/mod.ts

@@ -73,11 +73,20 @@ export const exitOnFail = true;
 
 let filterRegExp: RegExp | null;
 const tests: TestDefinition[] = [];
+const setUps: TestFunction[] = [];
+const tearDowns: TestFunction[] = [];
 
 let filtered = 0;
 const ignored = 0;
 const measured = 0;
 
+export function setUp(t: TestFunction): void {
+  setUps.push(t);
+}
+export function tearDown(t: TestFunction): void {
+  tearDowns.push(t);
+}
+
 // Must be called before any test() that needs to be filtered.
 export function setFilter(s: string): void {
   filterRegExp = new RegExp(s, "i");
@@ -117,13 +126,16 @@ function green_ok() {
   return FG_GREEN + "ok" + RESET;
 }
 
-async function runTests() {
+export async function runTests() {
   let passed = 0;
   let failed = 0;
 
+  for (let s of setUps) {
+    await s();
+  }
   console.log("running", tests.length, "tests");
-  for (let i = 0; i < tests.length; i++) {
-    const { fn, name } = tests[i];
+  for (let t of tests) {
+    const { fn, name } = t;
     let result = green_ok();
     // See https://github.com/denoland/deno/pull/1452
     // about this usage of groupCollapsed
@@ -144,6 +156,9 @@ async function runTests() {
       }
     }
   }
+  for (let t of tearDowns) {
+    await t();
+  }
 
   // Attempting to match the output of Rust's test runner.
   const result = failed > 0 ? red_failed() : green_ok();
@@ -163,4 +178,7 @@ async function runTests() {
   }
 }
 
-setTimeout(runTests, 0);
+const t = setTimeout(runTests, 0);
+export function cancelTests() {
+  clearTimeout(t);
+}

io/ioutil.ts → ws/ioutil.ts

@@ -1,5 +1,5 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { BufReader } from "./bufio.ts";
+import { BufReader } from "../io/bufio.ts";
 
 /* Read big endian 16bit short from BufReader */
 export async function readShort(buf: BufReader): Promise<number> {

io/ioutil_test.ts → ws/ioutil_test.ts

@@ -1,7 +1,7 @@
 import { Reader, ReadResult } from "deno";
 import { assertEqual, test } from "../testing/mod.ts";
 import { readInt, readLong, readShort, sliceLongToBytes } from "./ioutil.ts";
-import { BufReader } from "./bufio.ts";
+import { BufReader } from "../io/bufio.ts";
 
 class BinaryReader implements Reader {
   index = 0;

ws/mod.ts

@@ -1,8 +1,8 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
 import { Buffer, Writer, Conn } from "deno";
-import { ServerRequest } from "../http/http.ts";
+import { ServerRequest } from "../http/mod.ts";
 import { BufReader, BufWriter } from "../io/bufio.ts";
-import { readLong, readShort, sliceLongToBytes } from "../io/ioutil.ts";
+import { readLong, readShort, sliceLongToBytes } from "./ioutil.ts";
 import { Sha1 } from "./sha1.ts";
 
 export const OpCodeContinue = 0x0;

ws/test.ts

@@ -12,7 +12,7 @@ import {
   readFrame,
   unmask
 } from "./mod.ts";
-import { serve } from "../http/http.ts";
+import { serve } from "../http/mod.ts";
 
 test(async function testReadUnmaskedTextFrame() {
   // unmasked single text frame with payload "Hello"