fs: implement mkdir recursive (mkdirp)

Implements mkdirp functionality in node_file.cc. The Benefit
of implementing in C++ layer is that the logic is more easily
shared between the Promise and callback implementation and
there are notable performance improvements.

This commit is part of the Tooling Group Initiative.

Refs: https://github.com/nodejs/user-feedback/pull/70

PR-URL: https://github.com/nodejs/node/pull/21875
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Ron Korving <ron@ronkorving.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Sam Ruby <rubys@intertwingly.net>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>

1 files changed, 104 insertions, 3 deletions

diff --git a/test/parallel/test-fs-mkdir.js b/test/parallel/test-fs-mkdir.js
index 18e9e973f1..024fdced9c 100644
--- a/test/parallel/test-fs-mkdir.js
+++ b/test/parallel/test-fs-mkdir.js
@@ -23,12 +23,18 @@
 const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
+const path = require('path');
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
+let dirc = 0;
+function nextdir() {
+  return `test${++dirc}`;
+}
+
 {
-  const pathname = `${tmpdir.path}/test1`;
+  const pathname = path.join(tmpdir.path, nextdir());
 
   fs.mkdir(pathname, common.mustCall(function(err) {
     assert.strictEqual(err, null);
@@ -37,7 +43,7 @@ tmpdir.refresh();
 }
 
 {
-  const pathname = `${tmpdir.path}/test2`;
+  const pathname = path.join(tmpdir.path, nextdir());
 
   fs.mkdir(pathname, 0o777, common.mustCall(function(err) {
     assert.strictEqual(err, null);
@@ -46,7 +52,7 @@ tmpdir.refresh();
 }
 
 {
-  const pathname = `${tmpdir.path}/test3`;
+  const pathname = path.join(tmpdir.path, nextdir());
 
   fs.mkdirSync(pathname);
 
@@ -71,6 +77,101 @@ tmpdir.refresh();
   );
 });
 
+// mkdirpSync when both top-level, and sub-folders do not exist.
+{
+  const pathname = path.join(tmpdir.path, nextdir(), nextdir());
+
+  fs.mkdirSync(pathname, { recursive: true });
+
+  const exists = fs.existsSync(pathname);
+  assert.strictEqual(exists, true);
+  assert.strictEqual(fs.statSync(pathname).isDirectory(), true);
+}
+
+// mkdirpSync when folder already exists.
+{
+  const pathname = path.join(tmpdir.path, nextdir(), nextdir());
+
+  fs.mkdirSync(pathname, { recursive: true });
+  // should not cause an error.
+  fs.mkdirSync(pathname, { recursive: true });
+
+  const exists = fs.existsSync(pathname);
+  assert.strictEqual(exists, true);
+  assert.strictEqual(fs.statSync(pathname).isDirectory(), true);
+}
+
+// mkdirpSync ../
+{
+  const pathname = `${tmpdir.path}/${nextdir()}/../${nextdir()}/${nextdir()}`;
+  fs.mkdirSync(pathname, { recursive: true });
+  const exists = fs.existsSync(pathname);
+  assert.strictEqual(exists, true);
+  assert.strictEqual(fs.statSync(pathname).isDirectory(), true);
+}
+
+// mkdirpSync when path is a file.
+{
+  const pathname = path.join(tmpdir.path, nextdir(), nextdir());
+
+  fs.mkdirSync(path.dirname(pathname));
+  fs.writeFileSync(pathname, '', 'utf8');
+
+  try {
+    fs.mkdirSync(pathname, { recursive: true });
+    throw new Error('unreachable');
+  } catch (err) {
+    assert.notStrictEqual(err.message, 'unreachable');
+    assert.strictEqual(err.code, 'EEXIST');
+    assert.strictEqual(err.syscall, 'mkdir');
+  }
+}
+
+// mkdirp when folder does not yet exist.
+{
+  const pathname = path.join(tmpdir.path, nextdir(), nextdir());
+
+  fs.mkdir(pathname, { recursive: true }, common.mustCall(function(err) {
+    assert.strictEqual(err, null);
+    assert.strictEqual(fs.existsSync(pathname), true);
+    assert.strictEqual(fs.statSync(pathname).isDirectory(), true);
+  }));
+}
+
+// mkdirp when path is a file.
+{
+  const pathname = path.join(tmpdir.path, nextdir(), nextdir());
+
+  fs.mkdirSync(path.dirname(pathname));
+  fs.writeFileSync(pathname, '', 'utf8');
+  fs.mkdir(pathname, { recursive: true }, (err) => {
+    assert.strictEqual(err.code, 'EEXIST');
+    assert.strictEqual(err.syscall, 'mkdir');
+    assert.strictEqual(fs.statSync(pathname).isDirectory(), false);
+  });
+}
+
+// mkdirpSync dirname loop
+// XXX: windows and smartos have issues removing a directory that you're in.
+if (common.isMainThread && (common.isLinux || common.isOSX)) {
+  const pathname = path.join(tmpdir.path, nextdir());
+  fs.mkdirSync(pathname);
+  process.chdir(pathname);
+  fs.rmdirSync(pathname);
+  try {
+    fs.mkdirSync('X', { recursive: true });
+    throw new Error('unreachable');
+  } catch (err) {
+    assert.notStrictEqual(err.message, 'unreachable');
+    assert.strictEqual(err.code, 'ENOENT');
+    assert.strictEqual(err.syscall, 'mkdir');
+  }
+  fs.mkdir('X', { recursive: true }, (err) => {
+    assert.strictEqual(err.code, 'ENOENT');
+    assert.strictEqual(err.syscall, 'mkdir');
+  });
+}
+
 // Keep the event loop alive so the async mkdir() requests
 // have a chance to run (since they don't ref the event loop).
 process.nextTick(() => {});