First pass at running subprocesses (#1156)

1 files changed, 178 insertions, 0 deletions

diff --git a/js/process_test.ts b/js/process_test.ts
new file mode 100644
index 000000000..6cba1a1b7
--- /dev/null
+++ b/js/process_test.ts
@@ -0,0 +1,178 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+import { test, testPerm, assert, assertEqual } from "./test_util.ts";
+import { run, DenoError, ErrorKind } from "deno";
+import * as deno from "deno";
+
+test(async function runPermissions() {
+  let caughtError = false;
+  try {
+    deno.run({ args: ["python", "-c", "print('hello world')"] });
+  } catch (e) {
+    caughtError = true;
+    assertEqual(e.kind, deno.ErrorKind.PermissionDenied);
+    assertEqual(e.name, "PermissionDenied");
+  }
+  assert(caughtError);
+});
+
+testPerm({ run: true }, async function runSuccess() {
+  const p = run({
+    args: ["python", "-c", "print('hello world')"]
+  });
+  const status = await p.status();
+  console.log("status", status);
+  assertEqual(status.success, true);
+  assertEqual(status.code, 0);
+  assertEqual(status.signal, undefined);
+  p.close();
+});
+
+testPerm({ run: true }, async function runCommandFailedWithCode() {
+  let p = run({
+    args: ["python", "-c", "import sys;sys.exit(41 + 1)"]
+  });
+  let status = await p.status();
+  assertEqual(status.success, false);
+  assertEqual(status.code, 42);
+  assertEqual(status.signal, undefined);
+  p.close();
+});
+
+testPerm({ run: true }, async function runCommandFailedWithSignal() {
+  if (deno.platform.os === "win") {
+    return; // No signals on windows.
+  }
+  const p = run({
+    args: ["python", "-c", "import os;os.kill(os.getpid(), 9)"]
+  });
+  const status = await p.status();
+  assertEqual(status.success, false);
+  assertEqual(status.code, undefined);
+  assertEqual(status.signal, 9);
+  p.close();
+});
+
+testPerm({ run: true }, async function runNotFound() {
+  let error;
+  try {
+    run({ args: ["this file hopefully doesn't exist"] });
+  } catch (e) {
+    error = e;
+  }
+  assert(error !== undefined);
+  assert(error instanceof DenoError);
+  assertEqual(error.kind, ErrorKind.NotFound);
+});
+
+testPerm({ write: true, run: true }, async function runWithCwdIsAsync() {
+  const enc = new TextEncoder();
+  const cwd = deno.makeTempDirSync({ prefix: "deno_command_test" });
+
+  const exitCodeFile = "deno_was_here";
+  const pyProgramFile = "poll_exit.py";
+  const pyProgram = `
+from sys import exit
+from time import sleep
+
+while True:
+  try:
+    with open("${exitCodeFile}", "r") as f:
+      line = f.readline()
+    code = int(line)
+    exit(code)
+  except IOError:
+    # Retry if we got here before deno wrote the file.
+    sleep(0.01)
+    pass
+`;
+
+  deno.writeFileSync(`${cwd}/${pyProgramFile}.py`, enc.encode(pyProgram));
+  const p = run({
+    cwd,
+    args: ["python", `${pyProgramFile}.py`]
+  });
+
+  // Write the expected exit code *after* starting python.
+  // This is how we verify that `run()` is actually asynchronous.
+  const code = 84;
+  deno.writeFileSync(`${cwd}/${exitCodeFile}`, enc.encode(`${code}`));
+
+  const status = await p.status();
+  assertEqual(status.success, false);
+  assertEqual(status.code, code);
+  assertEqual(status.signal, undefined);
+  p.close();
+});
+
+testPerm({ run: true }, async function runStdinPiped() {
+  const p = run({
+    args: ["python", "-c", "import sys; assert 'hello' == sys.stdin.read();"],
+    stdin: "piped"
+  });
+  assert(!p.stdout);
+  assert(!p.stderr);
+
+  let msg = new TextEncoder().encode("hello");
+  let n = await p.stdin.write(msg);
+  assertEqual(n, msg.byteLength);
+
+  p.stdin.close();
+
+  const status = await p.status();
+  assertEqual(status.success, true);
+  assertEqual(status.code, 0);
+  assertEqual(status.signal, undefined);
+  p.close();
+});
+
+testPerm({ run: true }, async function runStdoutPiped() {
+  const p = run({
+    args: ["python", "-c", "import sys; sys.stdout.write('hello')"],
+    stdout: "piped"
+  });
+  assert(!p.stdin);
+  assert(!p.stderr);
+
+  const data = new Uint8Array(10);
+  let r = await p.stdout.read(data);
+  assertEqual(r.nread, 5);
+  assertEqual(r.eof, false);
+  const s = new TextDecoder().decode(data.subarray(0, r.nread));
+  assertEqual(s, "hello");
+  r = await p.stdout.read(data);
+  assertEqual(r.nread, 0);
+  assertEqual(r.eof, true);
+  p.stdout.close();
+
+  const status = await p.status();
+  assertEqual(status.success, true);
+  assertEqual(status.code, 0);
+  assertEqual(status.signal, undefined);
+  p.close();
+});
+
+testPerm({ run: true }, async function runStderrPiped() {
+  const p = run({
+    args: ["python", "-c", "import sys; sys.stderr.write('hello')"],
+    stderr: "piped"
+  });
+  assert(!p.stdin);
+  assert(!p.stdout);
+
+  const data = new Uint8Array(10);
+  let r = await p.stderr.read(data);
+  assertEqual(r.nread, 5);
+  assertEqual(r.eof, false);
+  const s = new TextDecoder().decode(data.subarray(0, r.nread));
+  assertEqual(s, "hello");
+  r = await p.stderr.read(data);
+  assertEqual(r.nread, 0);
+  assertEqual(r.eof, true);
+  p.stderr.close();
+
+  const status = await p.status();
+  assertEqual(status.success, true);
+  assertEqual(status.code, 0);
+  assertEqual(status.signal, undefined);
+  p.close();
+});