test: refactor test-fs-error-messages.js

* group tests by error type
* improve error validation for all messages
* use assert.throws instead of try and catch
* use arrow functions
* add missing test for readdir
* add missing test for readFileSync
* remove unnecessary variables

PR-URL: https://github.com/nodejs/node/pull/11096
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Italo A. Casas <me@italoacasas.com>

test/parallel/test-fs-error-messages.js

@@ -9,202 +9,156 @@ const existingFile2 = path.join(common.fixturesDir, 'create-file.js');
 const existingDir = path.join(common.fixturesDir, 'empty');
 const existingDir2 = path.join(common.fixturesDir, 'keys');
 
-// ASYNC_CALL
+// Test all operations failing with ENOENT errors
+function testEnoentError(file, endMessage, syscal, err) {
+  const sufix = (endMessage) ? endMessage : '';
 
-fs.stat(fn, function(err) {
+  assert(err instanceof Error);
   assert.strictEqual(fn, err.path);
-  assert.ok(0 <= err.message.indexOf(fn));
+  assert.strictEqual(
-});
+    err.message,
+    `ENOENT: no such file or directory, ${syscal} '${file}'${sufix}`
+  );
 
-fs.lstat(fn, function(err) {
+  return true;
-  assert.ok(0 <= err.message.indexOf(fn));
+}
-});
 
-fs.readlink(fn, function(err) {
+// Test all operations failing with EEXIST errors
-  assert.ok(0 <= err.message.indexOf(fn));
+function testEexistError(source, dest, syscal, err) {
-});
+  const sufix = (dest) ? ` -> '${dest}'` : '';
 
-fs.link(fn, 'foo', function(err) {
+  assert(err instanceof Error);
-  assert.ok(0 <= err.message.indexOf(fn));
+  assert.strictEqual(source, err.path);
-});
+  assert.strictEqual(
+    err.message,
+    `EEXIST: file already exists, ${syscal} '${source}'${sufix}`
+  );
 
-fs.link(existingFile, existingFile2, function(err) {
+  return true;
-  assert.ok(0 <= err.message.indexOf(existingFile));
+}
-  assert.ok(0 <= err.message.indexOf(existingFile2));
-});
 
-fs.symlink(existingFile, existingFile2, function(err) {
+// Test all operations failing with ENOTEMPTY errors
-  assert.ok(0 <= err.message.indexOf(existingFile));
+function testEnoemptyError(source, dest, err) {
-  assert.ok(0 <= err.message.indexOf(existingFile2));
+  assert(err instanceof Error);
-});
+  assert.strictEqual(source, err.path);
+  assert.strictEqual(
+    err.message,
+    `ENOTEMPTY: directory not empty, rename '${source}' ` +
+    `-> '${dest}'`
+  );
+
+  return true;
+}
 
-fs.unlink(fn, function(err) {
+// Test all operations failing with ENOTDIR errors
-  assert.ok(0 <= err.message.indexOf(fn));
+function testEnotdirError(dir, err) {
-});
+  assert(err instanceof Error);
+  assert.strictEqual(dir, err.path);
+  assert.strictEqual(
+    err.message,
+    `ENOTDIR: not a directory, rmdir '${dir}'`
+  );
 
-fs.rename(fn, 'foo', function(err) {
+  return true;
-  assert.ok(0 <= err.message.indexOf(fn));
+}
-});
 
-fs.rename(existingDir, existingDir2, function(err) {
+// Generating ENOENTS errors
-  assert.ok(0 <= err.message.indexOf(existingDir));
+fs.stat(fn, (err) => testEnoentError(fn, '', 'stat', err));
-  assert.ok(0 <= err.message.indexOf(existingDir2));
+fs.lstat(fn, (err) => testEnoentError(fn, '', 'lstat', err));
-});
+fs.readlink(fn, (err) => testEnoentError(fn, '', 'readlink', err));
+fs.link(fn, 'foo', (err) => testEnoentError(fn, ' -> \'foo\'', 'link', err));
+fs.unlink(fn, (err) => testEnoentError(fn, '', 'unlink', err));
+fs.rmdir(fn, (err) => testEnoentError(fn, '', 'rmdir', err));
+fs.chmod(fn, 0o666, (err) => testEnoentError(fn, '', 'chmod', err));
+fs.open(fn, 'r', 0o666, (err) => testEnoentError(fn, '', 'open', err));
+fs.readFile(fn, (err) => testEnoentError(fn, '', 'open', err));
+fs.readdir(fn, (err) => testEnoentError(fn, '', 'scandir', err));
 
-fs.rmdir(fn, function(err) {
+fs.rename(fn, 'foo', (err) => {
-  assert.ok(0 <= err.message.indexOf(fn));
+  testEnoentError(fn, ' -> \'foo\'', 'rename', err);
 });
 
-fs.mkdir(existingFile, 0o666, function(err) {
+assert.throws(() => {
-  assert.ok(0 <= err.message.indexOf(existingFile));
+  fs.statSync(fn);
-});
+}, (err) => testEnoentError(fn, '', 'stat', err));
 
-fs.rmdir(existingFile, function(err) {
+assert.throws(() => {
-  assert.ok(0 <= err.message.indexOf(existingFile));
+  fs.lstatSync(fn);
-});
+}, (err) => testEnoentError(fn, '', 'lstat', err));
 
-fs.chmod(fn, 0o666, function(err) {
+assert.throws(() => {
-  assert.ok(0 <= err.message.indexOf(fn));
+  fs.readlinkSync(fn);
-});
+}, (err) => testEnoentError(fn, '', 'readlink', err));
 
-fs.open(fn, 'r', 0o666, function(err) {
+assert.throws(() => {
-  assert.ok(0 <= err.message.indexOf(fn));
+  fs.linkSync(fn, 'foo');
-});
+}, (err) => testEnoentError(fn, ' -> \'foo\'', 'link', err));
 
-fs.readFile(fn, function(err) {
+assert.throws(() => {
-  assert.ok(0 <= err.message.indexOf(fn));
+  fs.unlinkSync(fn);
-});
+}, (err) => testEnoentError(fn, '', 'unlink', err));
 
-// Sync
+assert.throws(() => {
+  fs.rmdirSync(fn);
+}, (err) => testEnoentError(fn, '', 'rmdir', err));
 
-const errors = [];
+assert.throws(() => {
-let expected = 0;
+  fs.chmodSync(fn, 0o666);
+}, (err) => testEnoentError(fn, '', 'chmod', err));
 
-try {
+assert.throws(() => {
-  ++expected;
+  fs.openSync(fn, 'r');
-  fs.statSync(fn);
+}, (err) => testEnoentError(fn, '', 'open', err));
-} catch (err) {
-  errors.push('stat');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
 
-try {
+assert.throws(() => {
-  ++expected;
+  fs.readFileSync(fn);
-  fs.mkdirSync(existingFile, 0o666);
+}, (err) => testEnoentError(fn, '', 'open', err));
-} catch (err) {
-  errors.push('mkdir');
-  assert.ok(0 <= err.message.indexOf(existingFile));
-}
 
-try {
+assert.throws(() => {
-  ++expected;
+  fs.readdirSync(fn);
-  fs.chmodSync(fn, 0o666);
+}, (err) => testEnoentError(fn, '', 'scandir', err));
-} catch (err) {
-  errors.push('chmod');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
 
-try {
+assert.throws(() => {
-  ++expected;
+  fs.renameSync(fn, 'foo');
-  fs.lstatSync(fn);
+}, (err) => testEnoentError(fn, ' -> \'foo\'', 'rename', err));
-} catch (err) {
-  errors.push('lstat');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
 
-try {
+// Generating EEXIST errors
-  ++expected;
+fs.link(existingFile, existingFile2, (err) => {
-  fs.readlinkSync(fn);
+  testEexistError(existingFile, existingFile2, 'link', err);
-} catch (err) {
+});
-  errors.push('readlink');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
 
-try {
+fs.symlink(existingFile, existingFile2, (err) => {
-  ++expected;
+  testEexistError(existingFile, existingFile2, 'symlink', err);
-  fs.linkSync(fn, 'foo');
+});
-} catch (err) {
-  errors.push('link');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
 
-try {
+fs.mkdir(existingFile, 0o666, (err) => {
-  ++expected;
+  testEexistError(existingFile, null, 'mkdir', err);
+});
+
+assert.throws(() => {
   fs.linkSync(existingFile, existingFile2);
-} catch (err) {
+}, (err) => testEexistError(existingFile, existingFile2, 'link', err));
-  errors.push('link');
-  assert.ok(0 <= err.message.indexOf(existingFile));
-  assert.ok(0 <= err.message.indexOf(existingFile2));
-}
 
-try {
+assert.throws(() => {
-  ++expected;
   fs.symlinkSync(existingFile, existingFile2);
-} catch (err) {
+}, (err) => testEexistError(existingFile, existingFile2, 'symlink', err));
-  errors.push('symlink');
-  assert.ok(0 <= err.message.indexOf(existingFile));
-  assert.ok(0 <= err.message.indexOf(existingFile2));
-}
 
-try {
+assert.throws(() => {
-  ++expected;
+  fs.mkdirSync(existingFile, 0o666);
-  fs.unlinkSync(fn);
+}, (err) => testEexistError(existingFile, null, 'mkdir', err));
-} catch (err) {
-  errors.push('unlink');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
-
-try {
-  ++expected;
-  fs.rmdirSync(fn);
-} catch (err) {
-  errors.push('rmdir');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
-
-try {
-  ++expected;
-  fs.rmdirSync(existingFile);
-} catch (err) {
-  errors.push('rmdir');
-  assert.ok(0 <= err.message.indexOf(existingFile));
-}
-
-try {
-  ++expected;
-  fs.openSync(fn, 'r');
-} catch (err) {
-  errors.push('opens');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
 
-try {
+// Generating ENOTEMPTY errors
-  ++expected;
+fs.rename(existingDir, existingDir2, (err) => {
-  fs.renameSync(fn, 'foo');
+  testEnoemptyError(existingDir, existingDir2, err);
-} catch (err) {
+});
-  errors.push('rename');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
 
-try {
+assert.throws(() => {
-  ++expected;
   fs.renameSync(existingDir, existingDir2);
-} catch (err) {
+}, (err) => testEnoemptyError(existingDir, existingDir2, err));
-  errors.push('rename');
-  assert.ok(0 <= err.message.indexOf(existingDir));
-  assert.ok(0 <= err.message.indexOf(existingDir2));
-}
 
-try {
+// Generating ENOTDIR errors
-  ++expected;
+fs.rmdir(existingFile, (err) => testEnotdirError(existingFile, err));
-  fs.readdirSync(fn);
-} catch (err) {
-  errors.push('readdir');
-  assert.ok(0 <= err.message.indexOf(fn));
-}
 
-process.on('exit', function() {
+assert.throws(() => {
-  assert.strictEqual(expected, errors.length,
+  fs.rmdirSync(existingFile);
-                     'Test fs sync exceptions raised, got ' + errors.length +
+}, (err) => testEnotdirError(existingFile, err));
-               ' expected ' + expected);
-});