From e14cb2fdc4ba4e89fb16d76e4d2bc502d6453b27 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 3 Feb 2021 20:18:50 +0100
Subject: [PATCH] fs: remove permissive rmdir recursive

---
 doc/api/deprecations.md                       | 14 ++--
 doc/api/fs.md                                 | 66 +++++++++++++------
 lib/fs.js                                     | 20 ++++--
 lib/internal/fs/promises.js                   |  5 +-
 lib/internal/fs/utils.js                      | 40 ++++-------
 ...fs-rmdir-recursive-sync-warns-not-found.js | 19 ------
 ...t-fs-rmdir-recursive-sync-warns-on-file.js | 21 ------
 ...est-fs-rmdir-recursive-throws-not-found.js | 36 ++++++++++
 .../test-fs-rmdir-recursive-throws-on-file.js | 30 +++++++++
 ...test-fs-rmdir-recursive-warns-not-found.js | 23 -------
 .../test-fs-rmdir-recursive-warns-on-file.js  | 21 ------
 test/parallel/test-fs-rmdir-recursive.js      | 15 +++--
 12 files changed, 159 insertions(+), 151 deletions(-)
 delete mode 100644 test/parallel/test-fs-rmdir-recursive-sync-warns-not-found.js
 delete mode 100644 test/parallel/test-fs-rmdir-recursive-sync-warns-on-file.js
 create mode 100644 test/parallel/test-fs-rmdir-recursive-throws-not-found.js
 create mode 100644 test/parallel/test-fs-rmdir-recursive-throws-on-file.js
 delete mode 100644 test/parallel/test-fs-rmdir-recursive-warns-not-found.js
 delete mode 100644 test/parallel/test-fs-rmdir-recursive-warns-on-file.js

diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 09f05df5b44906..76a2ee19e93ee5 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -2668,19 +2668,25 @@ The [`crypto.Certificate()` constructor][] is deprecated. Use
 ### DEP0147: `fs.rmdir(path, { recursive: true })`
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37216
+    description: Permissive behavior was removed, the option is still deprecated.
   - version: v15.0.0
     pr-url: https://github.com/nodejs/node/pull/35562
-    description: Runtime deprecation.
+    description: Runtime deprecation for permissive behavior.
   - version: v14.14.0
     pr-url: https://github.com/nodejs/node/pull/35579
     description: Documentation-only deprecation.
 -->
 
-Type: Runtime
+Type: Documentation-only
 
-In future versions of Node.js, `fs.rmdir(path, { recursive: true })` will throw
+`fs.rmdir(path, { recursive: true })`, `fs.rmdirSync(path, { recursive:true })`
+and `fs.promises.rmdir(path, { recursive:true })` throws
 if `path` does not exist or is a file.
-Use `fs.rm(path, { recursive: true, force: true })` instead.
+Use `fs.rm(path, { recursive: true, force: true })`,
+`fs.rmSync(path, { recursive: true, force: true })` or
+`fs.promises.rm(path, { recursive: true, force: true })` instead.
 
 ### DEP0148: Folder mappings in `"exports"` (trailing `"/"`)
 <!-- YAML
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 5e7521ce7c8e36..c15ee87b33e70b 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -1046,6 +1046,16 @@ Renames `oldPath` to `newPath`.
 <!-- YAML
 added: v10.0.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37216
+    description: "Using `fsPromises.rmdir(path, { recursive: true })` on a `path`
+                 that is a file is no longer permitted and results in an
+                 `ENOENT` error on Windows and an `ENOTDIR` error on POSIX."
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37216
+    description: "Using `fsPromises.rmdir(path, { recursive: true })` on a `path`
+                 that does not exist is no longer permitted and results in a
+                 `ENOENT` error."
   - version:
      - v13.3.0
      - v12.16.0
@@ -1069,8 +1079,8 @@ changes:
     represents the number of retries. This option is ignored if the `recursive`
     option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
-    recursive mode, errors are not reported if `path` does not exist, and
-    operations are retried on failure. **Default:** `false`.
+    recursive mode, operations are retried on failure. **Default:** `false`.
+    **Deprecated**.
   * `retryDelay` {integer} The amount of time in milliseconds to wait between
     retries. This option is ignored if the `recursive` option is not `true`.
     **Default:** `100`.
@@ -1082,11 +1092,8 @@ Using `fsPromises.rmdir()` on a file (not a directory) results in the
 promise being rejected with an `ENOENT` error on Windows and an `ENOTDIR`
 error on POSIX.
 
-Setting `recursive` to `true` results in behavior similar to the Unix command
-`rm -rf`: an error will not be raised for paths that do not exist, and paths
-that represent files will be deleted. The permissive behavior of the
-`recursive` option is deprecated, `ENOTDIR` and `ENOENT` will be thrown in
-the future.
+To get a behavior similar to the `rm -rf` Unix command, use
+[`fsPromises.rm()`][] with options `{ recursive: true, force: true }`.
 
 ### `fsPromises.rm(path[, options])`
 <!-- YAML
@@ -3131,6 +3138,16 @@ rename('oldFile.txt', 'newFile.txt', (err) => {
 <!-- YAML
 added: v0.0.2
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37216
+    description: "Using `fs.rmdir(path, { recursive: true })` on a `path` that is
+                 a file is no longer permitted and results in an `ENOENT` error
+                 on Windows and an `ENOTDIR` error on POSIX."
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37216
+    description: "Using `fs.rmdir(path, { recursive: true })` on a `path` that
+                 does not exist is no longer permitted and results in a `ENOENT`
+                 error."
   - version:
      - v13.3.0
      - v12.16.0
@@ -3166,8 +3183,8 @@ changes:
     represents the number of retries. This option is ignored if the `recursive`
     option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
-    recursive mode, errors are not reported if `path` does not exist, and
-    operations are retried on failure. **Default:** `false`.
+    recursive mode, operations are retried on failure. **Default:** `false`.
+    **Deprecated**.
   * `retryDelay` {integer} The amount of time in milliseconds to wait between
     retries. This option is ignored if the `recursive` option is not `true`.
     **Default:** `100`.
@@ -3180,11 +3197,8 @@ to the completion callback.
 Using `fs.rmdir()` on a file (not a directory) results in an `ENOENT` error on
 Windows and an `ENOTDIR` error on POSIX.
 
-Setting `recursive` to `true` results in behavior similar to the Unix command
-`rm -rf`: an error will not be raised for paths that do not exist, and paths
-that represent files will be deleted. The permissive behavior of the
-`recursive` option is deprecated, `ENOTDIR` and `ENOENT` will be thrown in
-the future.
+To get a behavior similar to the `rm -rf` Unix command, use [`fs.rm()`][]
+with options `{ recursive: true, force: true }`.
 
 ### `fs.rm(path[, options], callback)`
 <!-- YAML
@@ -4751,6 +4765,16 @@ See the POSIX rename(2) documentation for more details.
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37216
+    description: "Using `fs.rmdirSync(path, { recursive: true })` on a `path`
+                 that is a file is no longer permitted and results in an
+                 `ENOENT` error on Windows and an `ENOTDIR` error on POSIX."
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37216
+    description: "Using `fs.rmdirSync(path, { recursive: true })` on a `path`
+                 that does not exist is no longer permitted and results in a
+                 `ENOENT` error."
   - version:
      - v13.3.0
      - v12.16.0
@@ -4778,8 +4802,8 @@ changes:
     represents the number of retries. This option is ignored if the `recursive`
     option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
-    recursive mode, errors are not reported if `path` does not exist, and
-    operations are retried on failure. **Default:** `false`.
+    recursive mode, operations are retried on failure. **Default:** `false`.
+    **Deprecated**.
   * `retryDelay` {integer} The amount of time in milliseconds to wait between
     retries. This option is ignored if the `recursive` option is not `true`.
     **Default:** `100`.
@@ -4789,11 +4813,8 @@ Synchronous rmdir(2). Returns `undefined`.
 Using `fs.rmdirSync()` on a file (not a directory) results in an `ENOENT` error
 on Windows and an `ENOTDIR` error on POSIX.
 
-Setting `recursive` to `true` results in behavior similar to the Unix command
-`rm -rf`: an error will not be raised for paths that do not exist, and paths
-that represent files will be deleted. The permissive behavior of the
-`recursive` option is deprecated, `ENOTDIR` and `ENOENT` will be thrown in
-the future.
+To get a behavior similar to the `rm -rf` Unix command, use [`fs.rmSync()`][]
+with options `{ recursive: true, force: true }`.
 
 ### `fs.rmSync(path[, options])`
 <!-- YAML
@@ -6641,6 +6662,8 @@ the file contents.
 [`fs.readdirSync()`]: #fs_fs_readdirsync_path_options
 [`fs.readv()`]: #fs_fs_readv_fd_buffers_position_callback
 [`fs.realpath()`]: #fs_fs_realpath_path_options_callback
+[`fs.rm()`]: #fs_fs_rm_path_options_callback
+[`fs.rmSync()`]: #fs_fs_rmsync_path_options
 [`fs.rmdir()`]: #fs_fs_rmdir_path_options_callback
 [`fs.stat()`]: #fs_fs_stat_path_options_callback
 [`fs.symlink()`]: #fs_fs_symlink_target_path_type_callback
@@ -6652,6 +6675,7 @@ the file contents.
 [`fs.writev()`]: #fs_fs_writev_fd_buffers_position_callback
 [`fsPromises.open()`]: #fs_fspromises_open_path_flags_mode
 [`fsPromises.opendir()`]: #fs_fspromises_opendir_path_options
+[`fsPromises.rm()`]: #fs_fspromises_rm_path_options
 [`fsPromises.utimes()`]: #fs_fspromises_utimes_path_atime_mtime
 [`inotify(7)`]: https://man7.org/linux/man-pages/man7/inotify.7.html
 [`kqueue(2)`]: https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2
diff --git a/lib/fs.js b/lib/fs.js
index 2bb629d58af081..27f20640da97e8 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -886,15 +886,20 @@ function rmdir(path, options, callback) {
   if (options?.recursive) {
     validateRmOptions(
       path,
-      { ...options, force: true },
+      { ...options, force: false },
       true,
       (err, options) => {
+        if (err === false) {
+          const req = new FSReqCallback();
+          req.oncomplete = callback;
+          return binding.rmdir(path, req);
+        }
         if (err) {
           return callback(err);
         }
 
         lazyLoadRimraf();
-        return rimraf(path, options, callback);
+        rimraf(path, options, callback);
       });
   } else {
     validateRmdirOptions(options);
@@ -908,12 +913,15 @@ function rmdirSync(path, options) {
   path = getValidatedPath(path);
 
   if (options?.recursive) {
-    options = validateRmOptionsSync(path, { ...options, force: true }, true);
-    lazyLoadRimraf();
-    return rimrafSync(pathModule.toNamespacedPath(path), options);
+    options = validateRmOptionsSync(path, { ...options, force: false }, true);
+    if (options !== false) {
+      lazyLoadRimraf();
+      return rimrafSync(pathModule.toNamespacedPath(path), options);
+    }
+  } else {
+    validateRmdirOptions(options);
   }
 
-  validateRmdirOptions(options);
   const ctx = { path };
   binding.rmdir(pathModule.toNamespacedPath(path), undefined, ctx);
   return handleErrorFromBinding(ctx);
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 6c39a13349d27b..3118e9d50d68fc 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -489,7 +489,10 @@ async function rmdir(path, options) {
   options = validateRmdirOptions(options);
 
   if (options.recursive) {
-    return rimrafPromises(path, options);
+    const stats = await stat(path);
+    if (stats.isDirectory()) {
+      return rimrafPromises(path, options);
+    }
   }
 
   return binding.rmdir(path, kUsePromises);
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index 842c5266c6f677..aeaf257648fa48 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -697,27 +697,24 @@ const defaultRmdirOptions = {
   recursive: false,
 };
 
-const validateRmOptions = hideStackFrames((path, options, warn, callback) => {
+const validateRmOptions = hideStackFrames((path, options, expectDir, cb) => {
   options = validateRmdirOptions(options, defaultRmOptions);
   validateBoolean(options.force, 'options.force');
 
   lazyLoadFs().stat(path, (err, stats) => {
     if (err) {
       if (options.force && err.code === 'ENOENT') {
-        if (warn) {
-          emitPermissiveRmdirWarning();
-        }
-        return callback(null, options);
+        return cb(null, options);
       }
-      return callback(err, options);
+      return cb(err, options);
     }
 
-    if (warn && !stats.isDirectory()) {
-      emitPermissiveRmdirWarning();
+    if (expectDir && !stats.isDirectory()) {
+      return cb(false);
     }
 
     if (stats.isDirectory() && !options.recursive) {
-      return callback(new ERR_FS_EISDIR({
+      return cb(new ERR_FS_EISDIR({
         code: 'EISDIR',
         message: 'is a directory',
         path,
@@ -725,20 +722,20 @@ const validateRmOptions = hideStackFrames((path, options, warn, callback) => {
         errno: EISDIR
       }));
     }
-    return callback(null, options);
+    return cb(null, options);
   });
 });
 
-const validateRmOptionsSync = hideStackFrames((path, options, warn) => {
+const validateRmOptionsSync = hideStackFrames((path, options, expectDir) => {
   options = validateRmdirOptions(options, defaultRmOptions);
   validateBoolean(options.force, 'options.force');
 
-  if (!options.force || warn || !options.recursive) {
+  if (!options.force || expectDir || !options.recursive) {
     const isDirectory = lazyLoadFs()
       .statSync(path, { throwIfNoEntry: !options.force })?.isDirectory();
 
-    if (warn && !isDirectory) {
-      emitPermissiveRmdirWarning();
+    if (expectDir && !isDirectory) {
+      return false;
     }
 
     if (isDirectory && !options.recursive) {
@@ -755,21 +752,6 @@ const validateRmOptionsSync = hideStackFrames((path, options, warn) => {
   return options;
 });
 
-let permissiveRmdirWarned = false;
-
-function emitPermissiveRmdirWarning() {
-  if (!permissiveRmdirWarned) {
-    process.emitWarning(
-      'In future versions of Node.js, fs.rmdir(path, { recursive: true }) ' +
-      'will throw if path does not exist or is a file. Use fs.rm(path, ' +
-      '{ recursive: true, force: true }) instead',
-      'DeprecationWarning',
-      'DEP0147'
-    );
-    permissiveRmdirWarned = true;
-  }
-}
-
 const validateRmdirOptions = hideStackFrames(
   (options, defaults = defaultRmdirOptions) => {
     if (options === undefined)
diff --git a/test/parallel/test-fs-rmdir-recursive-sync-warns-not-found.js b/test/parallel/test-fs-rmdir-recursive-sync-warns-not-found.js
deleted file mode 100644
index 449ae0b448b353..00000000000000
--- a/test/parallel/test-fs-rmdir-recursive-sync-warns-not-found.js
+++ /dev/null
@@ -1,19 +0,0 @@
-'use strict';
-const common = require('../common');
-const tmpdir = require('../common/tmpdir');
-const fs = require('fs');
-const path = require('path');
-
-tmpdir.refresh();
-
-{
-  // Should warn when trying to delete a nonexistent path
-  common.expectWarning(
-    'DeprecationWarning',
-    'In future versions of Node.js, fs.rmdir(path, { recursive: true }) ' +
-    'will throw if path does not exist or is a file. Use fs.rm(path, ' +
-    '{ recursive: true, force: true }) instead',
-    'DEP0147'
-  );
-  fs.rmdirSync(path.join(tmpdir.path, 'noexist.txt'), { recursive: true });
-}
diff --git a/test/parallel/test-fs-rmdir-recursive-sync-warns-on-file.js b/test/parallel/test-fs-rmdir-recursive-sync-warns-on-file.js
deleted file mode 100644
index 96b9875416f962..00000000000000
--- a/test/parallel/test-fs-rmdir-recursive-sync-warns-on-file.js
+++ /dev/null
@@ -1,21 +0,0 @@
-'use strict';
-const common = require('../common');
-const tmpdir = require('../common/tmpdir');
-const fs = require('fs');
-const path = require('path');
-
-tmpdir.refresh();
-
-{
-  // Should warn when trying to delete a file
-  common.expectWarning(
-    'DeprecationWarning',
-    'In future versions of Node.js, fs.rmdir(path, { recursive: true }) ' +
-    'will throw if path does not exist or is a file. Use fs.rm(path, ' +
-    '{ recursive: true, force: true }) instead',
-    'DEP0147'
-  );
-  const filePath = path.join(tmpdir.path, 'rmdir-recursive.txt');
-  fs.writeFileSync(filePath, '');
-  fs.rmdirSync(filePath, { recursive: true });
-}
diff --git a/test/parallel/test-fs-rmdir-recursive-throws-not-found.js b/test/parallel/test-fs-rmdir-recursive-throws-not-found.js
new file mode 100644
index 00000000000000..530f561f131d33
--- /dev/null
+++ b/test/parallel/test-fs-rmdir-recursive-throws-not-found.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+tmpdir.refresh();
+
+{
+  assert.throws(
+    () =>
+      fs.rmdirSync(path.join(tmpdir.path, 'noexist.txt'), { recursive: true }),
+    {
+      code: 'ENOENT',
+    }
+  );
+}
+{
+  fs.rmdir(
+    path.join(tmpdir.path, 'noexist.txt'),
+    { recursive: true },
+    common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOENT');
+    })
+  );
+}
+{
+  assert.rejects(
+    () => fs.promises.rmdir(path.join(tmpdir.path, 'noexist.txt'),
+                            { recursive: true }),
+    {
+      code: 'ENOENT',
+    }
+  ).then(common.mustCall());
+}
diff --git a/test/parallel/test-fs-rmdir-recursive-throws-on-file.js b/test/parallel/test-fs-rmdir-recursive-throws-on-file.js
new file mode 100644
index 00000000000000..1edcaa4a5752db
--- /dev/null
+++ b/test/parallel/test-fs-rmdir-recursive-throws-on-file.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+tmpdir.refresh();
+
+{
+  const filePath = path.join(tmpdir.path, 'rmdir-recursive.txt');
+  fs.writeFileSync(filePath, '');
+  assert.throws(() => fs.rmdirSync(filePath, { recursive: true }), {
+    code: 'ENOTDIR',
+  });
+}
+{
+  const filePath = path.join(tmpdir.path, 'rmdir-recursive.txt');
+  fs.writeFileSync(filePath, '');
+  fs.rmdir(filePath, { recursive: true }, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ENOTDIR');
+  }));
+}
+{
+  const filePath = path.join(tmpdir.path, 'rmdir-recursive.txt');
+  fs.writeFileSync(filePath, '');
+  assert.rejects(() => fs.promises.rmdir(filePath, { recursive: true }), {
+    code: 'ENOTDIR',
+  }).then(common.mustCall());
+}
diff --git a/test/parallel/test-fs-rmdir-recursive-warns-not-found.js b/test/parallel/test-fs-rmdir-recursive-warns-not-found.js
deleted file mode 100644
index 9f733b47d156ba..00000000000000
--- a/test/parallel/test-fs-rmdir-recursive-warns-not-found.js
+++ /dev/null
@@ -1,23 +0,0 @@
-'use strict';
-const common = require('../common');
-const tmpdir = require('../common/tmpdir');
-const fs = require('fs');
-const path = require('path');
-
-tmpdir.refresh();
-
-{
-  // Should warn when trying to delete a nonexistent path
-  common.expectWarning(
-    'DeprecationWarning',
-    'In future versions of Node.js, fs.rmdir(path, { recursive: true }) ' +
-    'will throw if path does not exist or is a file. Use fs.rm(path, ' +
-    '{ recursive: true, force: true }) instead',
-    'DEP0147'
-  );
-  fs.rmdir(
-    path.join(tmpdir.path, 'noexist.txt'),
-    { recursive: true },
-    common.mustCall()
-  );
-}
diff --git a/test/parallel/test-fs-rmdir-recursive-warns-on-file.js b/test/parallel/test-fs-rmdir-recursive-warns-on-file.js
deleted file mode 100644
index 0d8e2e61bcbe85..00000000000000
--- a/test/parallel/test-fs-rmdir-recursive-warns-on-file.js
+++ /dev/null
@@ -1,21 +0,0 @@
-'use strict';
-const common = require('../common');
-const tmpdir = require('../common/tmpdir');
-const fs = require('fs');
-const path = require('path');
-
-tmpdir.refresh();
-
-{
-  // Should warn when trying to delete a file
-  common.expectWarning(
-    'DeprecationWarning',
-    'In future versions of Node.js, fs.rmdir(path, { recursive: true }) ' +
-    'will throw if path does not exist or is a file. Use fs.rm(path, ' +
-    '{ recursive: true, force: true }) instead',
-    'DEP0147'
-  );
-  const filePath = path.join(tmpdir.path, 'rmdir-recursive.txt');
-  fs.writeFileSync(filePath, '');
-  fs.rmdir(filePath, { recursive: true }, common.mustSucceed());
-}
diff --git a/test/parallel/test-fs-rmdir-recursive.js b/test/parallel/test-fs-rmdir-recursive.js
index 7375eeacb07177..2077c5dcce3dfc 100644
--- a/test/parallel/test-fs-rmdir-recursive.js
+++ b/test/parallel/test-fs-rmdir-recursive.js
@@ -73,8 +73,9 @@ function removeAsync(dir) {
 
       // Recursive removal should succeed.
       fs.rmdir(dir, { recursive: true }, common.mustSucceed(() => {
-        // No error should occur if recursive and the directory does not exist.
-        fs.rmdir(dir, { recursive: true }, common.mustSucceed(() => {
+        // An error should occur if recursive and the directory does not exist.
+        fs.rmdir(dir, { recursive: true }, common.mustCall((err) => {
+          assert.strictEqual(err.code, 'ENOENT');
           // Attempted removal should fail now because the directory is gone.
           fs.rmdir(dir, common.mustCall((err) => {
             assert.strictEqual(err.syscall, 'rmdir');
@@ -119,8 +120,9 @@ function removeAsync(dir) {
   // Recursive removal should succeed.
   fs.rmdirSync(dir, { recursive: true });
 
-  // No error should occur if recursive and the directory does not exist.
-  fs.rmdirSync(dir, { recursive: true });
+  // An error should occur if recursive and the directory does not exist.
+  assert.throws(() => fs.rmdirSync(dir, { recursive: true }),
+                { code: 'ENOENT' });
 
   // Attempted removal should fail now because the directory is gone.
   assert.throws(() => fs.rmdirSync(dir), { syscall: 'rmdir' });
@@ -140,8 +142,9 @@ function removeAsync(dir) {
   // Recursive removal should succeed.
   await fs.promises.rmdir(dir, { recursive: true });
 
-  // No error should occur if recursive and the directory does not exist.
-  await fs.promises.rmdir(dir, { recursive: true });
+  // An error should occur if recursive and the directory does not exist.
+  await assert.rejects(fs.promises.rmdir(dir, { recursive: true }),
+                       { code: 'ENOENT' });
 
   // Attempted removal should fail now because the directory is gone.
   assert.rejects(fs.promises.rmdir(dir), { syscall: 'rmdir' });