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

This reverts commit 907ce8dd6c.

PR-URL: https://github.com/nodejs/node/pull/11155
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>

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

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