Skip to content

Commit

Permalink
test: cleanup parallel/test-fs-realpath.js
Browse files Browse the repository at this point in the history 
Replaced .indexOf() with .includes() for more clarity as to
what it is doing.

Many of the instances of var changed to const.

Instances of assert.equal() refactored to assert.strictEqual() or
assert.ifError()

Removed the unlinkSync() call in the exit event handler because it
probably only handles files in the testing tmp directory so there is
no need to unlink them.

PR-URL: #8769
Reviewed-By: Rich Trott <[email protected]>
Reviewed-By: Ilkka Myller <[email protected]>
  • Loading branch information
@mpmckenna8 @imyller
mpmckenna8 authored and imyller committed Sep 27, 2016
1 parent 52b6cfb commit 73ae2d1
Showing 1 changed file with 61 additions and 60 deletions.
121 changes: 61 additions & 60 deletions test/parallel/test-fs-realpath.js
View file
Original file line number Diff line number Diff line change
@@ -1,28 +1,29 @@
'use strict';
var common = require('../common');
var assert = require('assert');
var fs = require('fs');
var path = require('path');
var exec = require('child_process').exec;
const common = require('../common');
const assert = require('assert');
const fs = require('fs');
const path = require('path');
const exec = require('child_process').exec;
var async_completed = 0, async_expected = 0, unlink = [];
var skipSymlinks = false;

common.refreshTmpDir();

var root = '/';
var assertEqualPath = assert.equal;
var assertEqualPath = assert.strictEqual;
if (common.isWindows) {
// something like "C:\\"
root = process.cwd().substr(0, 3);
assertEqualPath = function(path_left, path_right, message) {
assert.equal(path_left.toLowerCase(), path_right.toLowerCase(), message);
assert
.strictEqual(path_left.toLowerCase(), path_right.toLowerCase(), message);
};

// On Windows, creating symlinks requires admin privileges.
// We'll only try to run symlink test if we have enough privileges.
try {
exec('whoami /priv', function(err, o) {
if (err || o.indexOf('SeCreateSymbolicLinkPrivilege') == -1) {
if (err || !o.includes('SeCreateSymbolicLinkPrivilege')) {
skipSymlinks = true;
}
runTest();
Expand All @@ -41,8 +42,8 @@ function tmp(p) {
return path.join(common.tmpDir, p);
}

var targetsAbsDir = path.join(common.tmpDir, 'targets');
var tmpAbsDir = common.tmpDir;
const targetsAbsDir = path.join(common.tmpDir, 'targets');
const tmpAbsDir = common.tmpDir;

// Set up targetsAbsDir and expected subdirectories
fs.mkdirSync(targetsAbsDir);
Expand Down Expand Up @@ -91,7 +92,7 @@ function test_simple_relative_symlink(callback) {
fs.symlinkSync(t[1], t[0], 'file');
unlink.push(t[0]);
});
var result = fs.realpathSync(entry);
const result = fs.realpathSync(entry);
assertEqualPath(result, path.resolve(expected));
asynctest(fs.realpath, [entry], callback, function(err, result) {
assertEqualPath(result, path.resolve(expected));
Expand All @@ -103,7 +104,7 @@ function test_simple_absolute_symlink(callback) {

// this one should still run, even if skipSymlinks is set,
// because it uses a junction.
var type = skipSymlinks ? 'junction' : 'dir';
const type = skipSymlinks ? 'junction' : 'dir';

console.log('using type=%s', type);

Expand All @@ -117,7 +118,7 @@ function test_simple_absolute_symlink(callback) {
fs.symlinkSync(t[1], t[0], type);
unlink.push(t[0]);
});
var result = fs.realpathSync(entry);
const result = fs.realpathSync(entry);
assertEqualPath(result, path.resolve(expected));
asynctest(fs.realpath, [entry], callback, function(err, result) {
assertEqualPath(result, path.resolve(expected));
Expand All @@ -131,16 +132,17 @@ function test_deep_relative_file_symlink(callback) {
return runNextTest();
}

var expected = path.join(common.fixturesDir, 'cycles', 'root.js');
var linkData1 = path.relative(path.join(targetsAbsDir, 'nested-index', 'one'),
expected);
var linkPath1 = path.join(targetsAbsDir,
const expected = path.join(common.fixturesDir, 'cycles', 'root.js');
const linkData1 = path
.relative(path.join(targetsAbsDir, 'nested-index', 'one'),
expected);
const linkPath1 = path.join(targetsAbsDir,
'nested-index', 'one', 'symlink1.js');
try {fs.unlinkSync(linkPath1);} catch (e) {}
fs.symlinkSync(linkData1, linkPath1, 'file');

var linkData2 = '../one/symlink1.js';
var entry = path.join(targetsAbsDir,
const linkData2 = '../one/symlink1.js';
const entry = path.join(targetsAbsDir,
'nested-index', 'two', 'symlink1-b.js');
try {fs.unlinkSync(entry);} catch (e) {}
fs.symlinkSync(linkData2, entry, 'file');
Expand All @@ -159,15 +161,15 @@ function test_deep_relative_dir_symlink(callback) {
common.skip('symlink test (no privs)');
return runNextTest();
}
var expected = path.join(common.fixturesDir, 'cycles', 'folder');
var path1b = path.join(targetsAbsDir, 'nested-index', 'one');
var linkPath1b = path.join(path1b, 'symlink1-dir');
var linkData1b = path.relative(path1b, expected);
const expected = path.join(common.fixturesDir, 'cycles', 'folder');
const path1b = path.join(targetsAbsDir, 'nested-index', 'one');
const linkPath1b = path.join(path1b, 'symlink1-dir');
const linkData1b = path.relative(path1b, expected);
try {fs.unlinkSync(linkPath1b);} catch (e) {}
fs.symlinkSync(linkData1b, linkPath1b, 'dir');

var linkData2b = '../one/symlink1-dir';
var entry = path.join(targetsAbsDir,
const linkData2b = '../one/symlink1-dir';
const entry = path.join(targetsAbsDir,
'nested-index', 'two', 'symlink12-dir');
try {fs.unlinkSync(entry);} catch (e) {}
fs.symlinkSync(linkData2b, entry, 'dir');
Expand All @@ -187,7 +189,7 @@ function test_cyclic_link_protection(callback) {
common.skip('symlink test (no privs)');
return runNextTest();
}
var entry = common.tmpDir + '/cycles/realpath-3a';
const entry = common.tmpDir + '/cycles/realpath-3a';
[
[entry, '../cycles/realpath-3b'],
[common.tmpDir + '/cycles/realpath-3b', '../cycles/realpath-3c'],
Expand All @@ -210,10 +212,10 @@ function test_cyclic_link_overprotection(callback) {
common.skip('symlink test (no privs)');
return runNextTest();
}
var cycles = common.tmpDir + '/cycles';
var expected = fs.realpathSync(cycles);
var folder = cycles + '/folder';
var link = folder + '/cycles';
const cycles = common.tmpDir + '/cycles';
const expected = fs.realpathSync(cycles);
const folder = cycles + '/folder';
const link = folder + '/cycles';
var testPath = cycles;
testPath += '/folder/cycles'.repeat(10);
try {fs.unlinkSync(link);} catch (ex) {}
Expand All @@ -233,26 +235,26 @@ function test_relative_input_cwd(callback) {
}

// we need to calculate the relative path to the tmp dir from cwd
var entrydir = process.cwd();
var entry = path.relative(entrydir,
const entrydir = process.cwd();
const entry = path.relative(entrydir,
path.join(common.tmpDir + '/cycles/realpath-3a'));
var expected = common.tmpDir + '/cycles/root.js';
const expected = common.tmpDir + '/cycles/root.js';
[
[entry, '../cycles/realpath-3b'],
[common.tmpDir + '/cycles/realpath-3b', '../cycles/realpath-3c'],
[common.tmpDir + '/cycles/realpath-3c', 'root.js']
].forEach(function(t) {
var fn = t[0];
const fn = t[0];
console.error('fn=%j', fn);
try {fs.unlinkSync(fn);} catch (e) {}
var b = path.basename(t[1]);
var type = (b === 'root.js' ? 'file' : 'dir');
const b = path.basename(t[1]);
const type = (b === 'root.js' ? 'file' : 'dir');
console.log('fs.symlinkSync(%j, %j, %j)', t[1], fn, type);
fs.symlinkSync(t[1], fn, 'file');
unlink.push(fn);
});

var origcwd = process.cwd();
const origcwd = process.cwd();
process.chdir(entrydir);
assertEqualPath(fs.realpathSync(entry), path.resolve(expected));
asynctest(fs.realpath, [entry], callback, function(err, result) {
Expand Down Expand Up @@ -282,7 +284,7 @@ function test_deep_symlink_mix(callback) {
$tmpDir/targets/nested-index/two/realpath-c -> $tmpDir/cycles/root.js
$tmpDir/targets/cycles/root.js (hard)
*/
var entry = tmp('node-test-realpath-f1');
const entry = tmp('node-test-realpath-f1');
try { fs.unlinkSync(tmp('node-test-realpath-d2/foo')); } catch (e) {}
try { fs.rmdirSync(tmp('node-test-realpath-d2')); } catch (e) {}
fs.mkdirSync(tmp('node-test-realpath-d2'), 0o700);
Expand All @@ -306,7 +308,7 @@ function test_deep_symlink_mix(callback) {
} finally {
unlink.push(tmp('node-test-realpath-d2'));
}
var expected = tmpAbsDir + '/cycles/root.js';
const expected = tmpAbsDir + '/cycles/root.js';
assertEqualPath(fs.realpathSync(entry), path.resolve(expected));
asynctest(fs.realpath, [entry], callback, function(err, result) {
assertEqualPath(result, path.resolve(expected));
Expand All @@ -316,10 +318,10 @@ function test_deep_symlink_mix(callback) {

function test_non_symlinks(callback) {
console.log('test_non_symlinks');
var entrydir = path.dirname(tmpAbsDir);
var entry = tmpAbsDir.substr(entrydir.length + 1) + '/cycles/root.js';
var expected = tmpAbsDir + '/cycles/root.js';
var origcwd = process.cwd();
const entrydir = path.dirname(tmpAbsDir);
const entry = tmpAbsDir.substr(entrydir.length + 1) + '/cycles/root.js';
const expected = tmpAbsDir + '/cycles/root.js';
const origcwd = process.cwd();
process.chdir(entrydir);
assertEqualPath(fs.realpathSync(entry), path.resolve(expected));
asynctest(fs.realpath, [entry], callback, function(err, result) {
Expand All @@ -329,7 +331,7 @@ function test_non_symlinks(callback) {
});
}

var upone = path.join(process.cwd(), '..');
const upone = path.join(process.cwd(), '..');
function test_escape_cwd(cb) {
console.log('test_escape_cwd');
asynctest(fs.realpath, ['..'], cb, function(er, uponeActual) {
Expand All @@ -338,7 +340,7 @@ function test_escape_cwd(cb) {
' actual:' + uponeActual);
});
}
var uponeActual = fs.realpathSync('..');
const uponeActual = fs.realpathSync('..');
assertEqualPath(upone, uponeActual,
'realpathSync("..") expected: ' + path.resolve(upone) +
' actual:' + uponeActual);
Expand Down Expand Up @@ -375,11 +377,11 @@ function test_up_multiple(cb) {
fs.symlinkSync('..', tmp('a/b/e'), 'dir');
unlink.push(tmp('a/b/e'));

var abedabed = tmp('abedabed'.split('').join('/'));
var abedabed_real = tmp('');
const abedabed = tmp('abedabed'.split('').join('/'));
const abedabed_real = tmp('');

var abedabeda = tmp('abedabeda'.split('').join('/'));
var abedabeda_real = tmp('a');
const abedabeda = tmp('abedabeda'.split('').join('/'));
const abedabeda_real = tmp('a');

assertEqualPath(fs.realpathSync(abedabeda), abedabeda_real);
assertEqualPath(fs.realpathSync(abedabed), abedabed_real);
Expand Down Expand Up @@ -409,11 +411,11 @@ function test_abs_with_kids(cb) {

// this one should still run, even if skipSymlinks is set,
// because it uses a junction.
var type = skipSymlinks ? 'junction' : 'dir';
const type = skipSymlinks ? 'junction' : 'dir';

console.log('using type=%s', type);

var root = tmpAbsDir + '/node-test-realpath-abs-kids';
const root = tmpAbsDir + '/node-test-realpath-abs-kids';
function cleanup() {
['/a/b/c/x.txt',
'/a/link'
Expand Down Expand Up @@ -442,9 +444,9 @@ function test_abs_with_kids(cb) {
fs.symlinkSync(root + '/a/b', root + '/a/link', type);
}
setup();
var linkPath = root + '/a/link/c/x.txt';
var expectPath = root + '/a/b/c/x.txt';
var actual = fs.realpathSync(linkPath);
const linkPath = root + '/a/link/c/x.txt';
const expectPath = root + '/a/b/c/x.txt';
const actual = fs.realpathSync(linkPath);
// console.log({link:linkPath,expect:expectPath,actual:actual},'sync');
assertEqualPath(actual, path.resolve(expectPath));
asynctest(fs.realpath, [linkPath], cb, function(er, actual) {
Expand All @@ -456,7 +458,7 @@ function test_abs_with_kids(cb) {

// ----------------------------------------------------------------------------

var tests = [
const tests = [
test_simple_error_callback,
test_simple_relative_symlink,
test_simple_absolute_symlink,
Expand All @@ -471,11 +473,11 @@ var tests = [
test_abs_with_kids,
test_up_multiple
];
var numtests = tests.length;
const numtests = tests.length;
var testsRun = 0;
function runNextTest(err) {
if (err) throw err;
var test = tests.shift();
const test = tests.shift();
if (!test) {
return console.log(numtests +
' subtests completed OK for fs.realpath');
Expand All @@ -487,13 +489,13 @@ function runNextTest(err) {

assertEqualPath(root, fs.realpathSync('/'));
fs.realpath('/', function(err, result) {
assert.equal(null, err);
assert.ifError(err);
assertEqualPath(root, result);
});


function runTest() {
var tmpDirs = ['cycles', 'cycles/folder'];
const tmpDirs = ['cycles', 'cycles/folder'];
tmpDirs.forEach(function(t) {
t = tmp(t);
fs.mkdirSync(t, 0o700);
Expand All @@ -506,6 +508,5 @@ function runTest() {

process.on('exit', function() {
assert.equal(numtests, testsRun);
unlink.forEach(function(path) { try {fs.unlinkSync(path);} catch (e) {} });
assert.equal(async_completed, async_expected);
});

0 comments on commit 73ae2d1

Please sign in to comment.