Add remove(), removeAll().

and removeSync(), removeAllSync().

1 files changed, 336 insertions, 0 deletions

diff --git a/js/remove_test.ts b/js/remove_test.ts
new file mode 100644
index 000000000..eb31f1ba3
--- /dev/null
+++ b/js/remove_test.ts
@@ -0,0 +1,336 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+import { testPerm, assert, assertEqual } from "./test_util.ts";
+import * as deno from "deno";
+
+// SYNC
+
+testPerm({ write: true }, function removeSyncDirSuccess() {
+  // REMOVE EMPTY DIRECTORY
+  const path = deno.makeTempDirSync() + "/dir/subdir";
+  deno.mkdirSync(path);
+  const pathInfo = deno.statSync(path);
+  assert(pathInfo.isDirectory()); // check exist first
+  deno.removeSync(path); // remove
+  // We then check again after remove
+  let err;
+  try {
+    deno.statSync(path);
+  } catch (e) {
+    err = e;
+  }
+  // Directory is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: true }, function removeSyncFileSuccess() {
+  // REMOVE FILE
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = deno.makeTempDirSync() + "/test.txt";
+  deno.writeFileSync(filename, data, 0o666);
+  const fileInfo = deno.statSync(filename);
+  assert(fileInfo.isFile()); // check exist first
+  deno.removeSync(filename); // remove
+  // We then check again after remove
+  let err;
+  try {
+    deno.statSync(filename);
+  } catch (e) {
+    err = e;
+  }
+  // File is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: true }, function removeSyncFail() {
+  // NON-EMPTY DIRECTORY
+  const path = deno.makeTempDirSync() + "/dir/subdir";
+  const subPath = path + "/subsubdir";
+  deno.mkdirSync(path);
+  deno.mkdirSync(subPath);
+  const pathInfo = deno.statSync(path);
+  assert(pathInfo.isDirectory()); // check exist first
+  const subPathInfo = deno.statSync(subPath);
+  assert(subPathInfo.isDirectory()); // check exist first
+  let err;
+  try {
+    // Should not be able to recursively remove
+    deno.removeSync(path);
+  } catch (e) {
+    err = e;
+  }
+  // TODO(ry) Is Other really the error we should get here? What would Go do?
+  assertEqual(err.kind, deno.ErrorKind.Other);
+  assertEqual(err.name, "Other");
+  // NON-EXISTENT DIRECTORY/FILE
+  try {
+    // Non-existent
+    deno.removeSync("/baddir");
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: false }, function removeSyncPerm() {
+  let err;
+  try {
+    deno.removeSync("/baddir");
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.PermissionDenied);
+  assertEqual(err.name, "PermissionDenied");
+});
+
+testPerm({ write: true }, function removeAllSyncDirSuccess() {
+  // REMOVE EMPTY DIRECTORY
+  let path = deno.makeTempDirSync() + "/dir/subdir";
+  deno.mkdirSync(path);
+  let pathInfo = deno.statSync(path);
+  assert(pathInfo.isDirectory()); // check exist first
+  deno.removeAllSync(path); // remove
+  // We then check again after remove
+  let err;
+  try {
+    deno.statSync(path);
+  } catch (e) {
+    err = e;
+  }
+  // Directory is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+  // REMOVE NON-EMPTY DIRECTORY
+  path = deno.makeTempDirSync() + "/dir/subdir";
+  const subPath = path + "/subsubdir";
+  deno.mkdirSync(path);
+  deno.mkdirSync(subPath);
+  pathInfo = deno.statSync(path);
+  assert(pathInfo.isDirectory()); // check exist first
+  const subPathInfo = deno.statSync(subPath);
+  assert(subPathInfo.isDirectory()); // check exist first
+  deno.removeAllSync(path); // remove
+  // We then check parent directory again after remove
+  try {
+    deno.statSync(path);
+  } catch (e) {
+    err = e;
+  }
+  // Directory is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: true }, function removeAllSyncFileSuccess() {
+  // REMOVE FILE
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = deno.makeTempDirSync() + "/test.txt";
+  deno.writeFileSync(filename, data, 0o666);
+  const fileInfo = deno.statSync(filename);
+  assert(fileInfo.isFile()); // check exist first
+  deno.removeAllSync(filename); // remove
+  // We then check again after remove
+  let err;
+  try {
+    deno.statSync(filename);
+  } catch (e) {
+    err = e;
+  }
+  // File is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: true }, function removeAllSyncFail() {
+  // NON-EXISTENT DIRECTORY/FILE
+  let err;
+  try {
+    // Non-existent
+    deno.removeAllSync("/baddir");
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: false }, function removeAllSyncPerm() {
+  let err;
+  try {
+    deno.removeAllSync("/baddir");
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.PermissionDenied);
+  assertEqual(err.name, "PermissionDenied");
+});
+
+// ASYNC
+
+testPerm({ write: true }, async function removeDirSuccess() {
+  // REMOVE EMPTY DIRECTORY
+  const path = deno.makeTempDirSync() + "/dir/subdir";
+  deno.mkdirSync(path);
+  const pathInfo = deno.statSync(path);
+  assert(pathInfo.isDirectory()); // check exist first
+  await deno.remove(path); // remove
+  // We then check again after remove
+  let err;
+  try {
+    deno.statSync(path);
+  } catch (e) {
+    err = e;
+  }
+  // Directory is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: true }, async function removeFileSuccess() {
+  // REMOVE FILE
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = deno.makeTempDirSync() + "/test.txt";
+  deno.writeFileSync(filename, data, 0o666);
+  const fileInfo = deno.statSync(filename);
+  assert(fileInfo.isFile()); // check exist first
+  await deno.remove(filename); // remove
+  // We then check again after remove
+  let err;
+  try {
+    deno.statSync(filename);
+  } catch (e) {
+    err = e;
+  }
+  // File is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: true }, async function removeFail() {
+  // NON-EMPTY DIRECTORY
+  const path = deno.makeTempDirSync() + "/dir/subdir";
+  const subPath = path + "/subsubdir";
+  deno.mkdirSync(path);
+  deno.mkdirSync(subPath);
+  const pathInfo = deno.statSync(path);
+  assert(pathInfo.isDirectory()); // check exist first
+  const subPathInfo = deno.statSync(subPath);
+  assert(subPathInfo.isDirectory()); // check exist first
+  let err;
+  try {
+    // Should not be able to recursively remove
+    await deno.remove(path);
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.Other);
+  assertEqual(err.name, "Other");
+  // NON-EXISTENT DIRECTORY/FILE
+  try {
+    // Non-existent
+    await deno.remove("/baddir");
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: false }, async function removePerm() {
+  let err;
+  try {
+    await deno.remove("/baddir");
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.PermissionDenied);
+  assertEqual(err.name, "PermissionDenied");
+});
+
+testPerm({ write: true }, async function removeAllDirSuccess() {
+  // REMOVE EMPTY DIRECTORY
+  let path = deno.makeTempDirSync() + "/dir/subdir";
+  deno.mkdirSync(path);
+  let pathInfo = deno.statSync(path);
+  assert(pathInfo.isDirectory()); // check exist first
+  await deno.removeAll(path); // remove
+  // We then check again after remove
+  let err;
+  try {
+    deno.statSync(path);
+  } catch (e) {
+    err = e;
+  }
+  // Directory is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+  // REMOVE NON-EMPTY DIRECTORY
+  path = deno.makeTempDirSync() + "/dir/subdir";
+  const subPath = path + "/subsubdir";
+  deno.mkdirSync(path);
+  deno.mkdirSync(subPath);
+  pathInfo = deno.statSync(path);
+  assert(pathInfo.isDirectory()); // check exist first
+  const subPathInfo = deno.statSync(subPath);
+  assert(subPathInfo.isDirectory()); // check exist first
+  await deno.removeAll(path); // remove
+  // We then check parent directory again after remove
+  try {
+    deno.statSync(path);
+  } catch (e) {
+    err = e;
+  }
+  // Directory is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: true }, async function removeAllFileSuccess() {
+  // REMOVE FILE
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = deno.makeTempDirSync() + "/test.txt";
+  deno.writeFileSync(filename, data, 0o666);
+  const fileInfo = deno.statSync(filename);
+  assert(fileInfo.isFile()); // check exist first
+  await deno.removeAll(filename); // remove
+  // We then check again after remove
+  let err;
+  try {
+    deno.statSync(filename);
+  } catch (e) {
+    err = e;
+  }
+  // File is gone
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: true }, async function removeAllFail() {
+  // NON-EXISTENT DIRECTORY/FILE
+  let err;
+  try {
+    // Non-existent
+    await deno.removeAll("/baddir");
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.NotFound);
+  assertEqual(err.name, "NotFound");
+});
+
+testPerm({ write: false }, async function removeAllPerm() {
+  let err;
+  try {
+    await deno.removeAll("/baddir");
+  } catch (e) {
+    err = e;
+  }
+  assertEqual(err.kind, deno.ErrorKind.PermissionDenied);
+  assertEqual(err.name, "PermissionDenied");
+});