lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

test-fs-realpath: lint

v0.7.4-release
isaacs 14 years ago
committed by Ryan Dahl
parent
0ce9cbab29
commit
6525c04522
1 changed files with 148 additions and 116 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 264
      test/simple/test-fs-realpath.js

264
test/simple/test-fs-realpath.js
View File

@ -5,13 +5,13 @@ var path = require('path');
var exec = require('child_process').exec; var exec = require('child_process').exec;
var async_completed = 0, async_expected = 0, unlink = []; var async_completed = 0, async_expected = 0, unlink = [];
function tmp (p) { function tmp(p) {
return path.join(common.tmpDir, p); return path.join(common.tmpDir, p);
} }
function asynctest(testBlock, args, callback, assertBlock) { function asynctest(testBlock, args, callback, assertBlock) {
async_expected++; async_expected++;
testBlock.apply(testBlock, args.concat(function(err){ testBlock.apply(testBlock, args.concat(function(err) {
var ignoreError = false; var ignoreError = false;
if (assertBlock) { if (assertBlock) {
try { try {
@ -27,8 +27,7 @@ function asynctest(testBlock, args, callback, assertBlock) {
} }
function bashRealpath(path, callback) { function bashRealpath(path, callback) {
exec("cd '"+path.replace("'","\\'")+"' && pwd -P",function exec("cd '" + path.replace("'", "\\'") + "' && pwd -P", function(err, o) {
(err, o) {
callback(err, o.trim()); callback(err, o.trim());
}); });
} }
@ -36,158 +35,181 @@ function bashRealpath(path, callback) {
// sub-tests: // sub-tests:
function test_simple_relative_symlink(callback) { function test_simple_relative_symlink(callback) {
console.log("test_simple_relative_symlink"); console.log('test_simple_relative_symlink');
var entry = common.fixturesDir+'/cycles/symlink', var entry = common.fixturesDir + '/cycles/symlink',
expected = common.fixturesDir+'/cycles/root.js'; expected = common.fixturesDir + '/cycles/root.js';
[ [
[entry, 'root.js'], [entry, 'root.js']
].forEach(function(t) { ].forEach(function(t) {
try {fs.unlinkSync(t[0]);}catch(e){} try {fs.unlinkSync(t[0]);}catch (e) {}
fs.symlinkSync(t[1], t[0]); fs.symlinkSync(t[1], t[0]);
unlink.push(t[0]); unlink.push(t[0]);
}); });
var result = fs.realpathSync(entry); var result = fs.realpathSync(entry);
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' + common.inspect(result) + ' expected ' +
asynctest(fs.realpath, [entry], callback, function(err, result){ common.inspect(expected));
asynctest(fs.realpath, [entry], callback, function(err, result) {
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' +
common.inspect(result) +
' expected ' +
common.inspect(expected));
}); });
} }
function test_simple_absolute_symlink(callback) { function test_simple_absolute_symlink(callback) {
console.log("test_simple_absolute_symlink"); console.log('test_simple_absolute_symlink');
bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) { bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) {
if (err) return callback(err); if (err) return callback(err);
var entry = fixturesAbsDir+'/cycles/symlink', var entry = fixturesAbsDir + '/cycles/symlink',
expected = fixturesAbsDir+'/nested-index/one/index.js'; expected = fixturesAbsDir + '/nested-index/one/index.js';
[ [
[entry, expected], [entry, expected]
].forEach(function(t) { ].forEach(function(t) {
try {fs.unlinkSync(t[0]);}catch(e){} try {fs.unlinkSync(t[0]);} catch (e) {}
fs.symlinkSync(t[1], t[0]); fs.symlinkSync(t[1], t[0]);
unlink.push(t[0]); unlink.push(t[0]);
}); });
var result = fs.realpathSync(entry); var result = fs.realpathSync(entry);
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' +
asynctest(fs.realpath, [entry], callback, function(err, result){ common.inspect(result) +
' expected ' +
common.inspect(expected));
asynctest(fs.realpath, [entry], callback, function(err, result) {
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' +
common.inspect(result) +
' expected ' +
common.inspect(expected));
}); });
}); });
} }
function test_deep_relative_file_symlink(callback) { function test_deep_relative_file_symlink(callback) {
console.log("test_deep_relative_file_symlink"); console.log('test_deep_relative_file_symlink');
var expected = path.join(common.fixturesDir, 'cycles', 'root.js'); var expected = path.join(common.fixturesDir, 'cycles', 'root.js');
var linkData1 = "../../cycles/root.js"; var linkData1 = '../../cycles/root.js';
var linkPath1 = path.join(common.fixturesDir, "nested-index", 'one', 'symlink1.js'); var linkPath1 = path.join(common.fixturesDir,
try {fs.unlinkSync(linkPath1);}catch(e){} 'nested-index', 'one', 'symlink1.js');
try {fs.unlinkSync(linkPath1);} catch (e) {}
fs.symlinkSync(linkData1, linkPath1); fs.symlinkSync(linkData1, linkPath1);
var linkData2 = "../one/symlink1.js"; var linkData2 = '../one/symlink1.js';
var entry = path.join(common.fixturesDir, "nested-index", 'two', 'symlink1-b.js'); var entry = path.join(common.fixturesDir,
try {fs.unlinkSync(entry);}catch(e){} 'nested-index', 'two', 'symlink1-b.js');
try {fs.unlinkSync(entry);} catch (e) {}
fs.symlinkSync(linkData2, entry); fs.symlinkSync(linkData2, entry);
unlink.push(linkPath1); unlink.push(linkPath1);
unlink.push(entry); unlink.push(entry);
assert.equal(fs.realpathSync(entry), expected); assert.equal(fs.realpathSync(entry), expected);
asynctest(fs.realpath, [entry], callback, function(err, result){ asynctest(fs.realpath, [entry], callback, function(err, result) {
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' +
common.inspect(result) +
' expected ' +
common.inspect(expected));
}); });
} }
function test_deep_relative_dir_symlink(callback) { function test_deep_relative_dir_symlink(callback) {
console.log("test_deep_relative_dir_symlink"); console.log('test_deep_relative_dir_symlink');
var expected = path.join(common.fixturesDir, 'cycles', 'folder'); var expected = path.join(common.fixturesDir, 'cycles', 'folder');
var linkData1b = "../../cycles/folder"; var linkData1b = '../../cycles/folder';
var linkPath1b = path.join(common.fixturesDir, "nested-index", 'one', 'symlink1-dir'); var linkPath1b = path.join(common.fixturesDir,
try {fs.unlinkSync(linkPath1b);}catch(e){} 'nested-index', 'one', 'symlink1-dir');
try {fs.unlinkSync(linkPath1b);} catch (e) {}
fs.symlinkSync(linkData1b, linkPath1b); fs.symlinkSync(linkData1b, linkPath1b);
var linkData2b = "../one/symlink1-dir"; var linkData2b = '../one/symlink1-dir';
var entry = path.join(common.fixturesDir, "nested-index", 'two', 'symlink12-dir'); var entry = path.join(common.fixturesDir,
try {fs.unlinkSync(entry);}catch(e){} 'nested-index', 'two', 'symlink12-dir');
try {fs.unlinkSync(entry);} catch (e) {}
fs.symlinkSync(linkData2b, entry); fs.symlinkSync(linkData2b, entry);
unlink.push(linkPath1b); unlink.push(linkPath1b);
unlink.push(entry); unlink.push(entry);
assert.equal(fs.realpathSync(entry), expected); assert.equal(fs.realpathSync(entry), expected);
asynctest(fs.realpath, [entry], callback, function(err, result){ asynctest(fs.realpath, [entry], callback, function(err, result) {
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' +
common.inspect(result) +
' expected ' +
common.inspect(expected));
}); });
} }
function test_cyclic_link_protection(callback) { function test_cyclic_link_protection(callback) {
console.log("test_cyclic_link_protection"); console.log('test_cyclic_link_protection');
var entry = common.fixturesDir+'/cycles/realpath-3a'; var entry = common.fixturesDir + '/cycles/realpath-3a';
[ [
[entry, '../cycles/realpath-3b'], [entry, '../cycles/realpath-3b'],
[common.fixturesDir+'/cycles/realpath-3b', '../cycles/realpath-3c'], [common.fixturesDir + '/cycles/realpath-3b', '../cycles/realpath-3c'],
[common.fixturesDir+'/cycles/realpath-3c', '../cycles/realpath-3a'], [common.fixturesDir + '/cycles/realpath-3c', '../cycles/realpath-3a']
].forEach(function(t) { ].forEach(function(t) {
try {fs.unlinkSync(t[0]);}catch(e){} try {fs.unlinkSync(t[0]);} catch (e) {}
fs.symlinkSync(t[1], t[0]); fs.symlinkSync(t[1], t[0]);
unlink.push(t[0]); unlink.push(t[0]);
}); });
assert.throws(function(){ fs.realpathSync(entry); }); assert.throws(function() { fs.realpathSync(entry); });
asynctest(fs.realpath, [entry], callback, function(err, result){ asynctest(fs.realpath, [entry], callback, function(err, result) {
assert.ok(err && true); assert.ok(err && true);
return true; return true;
}); });
} }
function test_cyclic_link_overprotection (callback) { function test_cyclic_link_overprotection(callback) {
console.log("test_cyclic_link_overprotection"); console.log('test_cyclic_link_overprotection');
var cycles = common.fixturesDir+'/cycles'; var cycles = common.fixturesDir + '/cycles';
var expected = fs.realpathSync(cycles); var expected = fs.realpathSync(cycles);
var folder = cycles+'/folder'; var folder = cycles + '/folder';
var link = folder+'/cycles'; var link = folder + '/cycles';
var testPath = cycles; var testPath = cycles;
for (var i = 0; i < 10; i ++) testPath += '/folder/cycles'; for (var i = 0; i < 10; i++) testPath += '/folder/cycles';
try {fs.unlinkSync(link)} catch (ex) {} try {fs.unlinkSync(link)} catch (ex) {}
fs.symlinkSync(cycles, link); fs.symlinkSync(cycles, link);
assert.equal(fs.realpathSync(testPath), expected); assert.equal(fs.realpathSync(testPath), expected);
asynctest(fs.realpath, [testPath], callback, function (er, res) { asynctest(fs.realpath, [testPath], callback, function(er, res) {
assert.equal(res, expected); assert.equal(res, expected);
}); });
} }
function test_relative_input_cwd(callback) { function test_relative_input_cwd(callback) {
console.log("test_relative_input_cwd"); console.log('test_relative_input_cwd');
var p = common.fixturesDir.lastIndexOf('/'); var p = common.fixturesDir.lastIndexOf('/');
var entrydir = common.fixturesDir.substr(0, p); var entrydir = common.fixturesDir.substr(0, p);
var entry = common.fixturesDir.substr(p+1)+'/cycles/realpath-3a'; var entry = common.fixturesDir.substr(p + 1) + '/cycles/realpath-3a';
var expected = common.fixturesDir+'/cycles/root.js'; var expected = common.fixturesDir + '/cycles/root.js';
[ [
[entry, '../cycles/realpath-3b'], [entry, '../cycles/realpath-3b'],
[common.fixturesDir+'/cycles/realpath-3b', '../cycles/realpath-3c'], [common.fixturesDir + '/cycles/realpath-3b', '../cycles/realpath-3c'],
[common.fixturesDir+'/cycles/realpath-3c', 'root.js'], [common.fixturesDir + '/cycles/realpath-3c', 'root.js']
].forEach(function(t) { ].forEach(function(t) {
var fn = t[0]; var fn = t[0];
if (fn.charAt(0) !== '/') fn = entrydir + '/' + fn; if (fn.charAt(0) !== '/') fn = entrydir + '/' + fn;
try {fs.unlinkSync(fn);}catch(e){} try {fs.unlinkSync(fn);} catch (e) {}
fs.symlinkSync(t[1], fn); fs.symlinkSync(t[1], fn);
unlink.push(fn); unlink.push(fn);
}); });
var origcwd = process.cwd(); var origcwd = process.cwd();
process.chdir(entrydir); process.chdir(entrydir);
assert.equal(fs.realpathSync(entry), expected); assert.equal(fs.realpathSync(entry), expected);
asynctest(fs.realpath, [entry], callback, function(err, result){ asynctest(fs.realpath, [entry], callback, function(err, result) {
process.chdir(origcwd); process.chdir(origcwd);
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' +
common.inspect(result) +
' expected ' +
common.inspect(expected));
return true; return true;
}); });
} }
function test_deep_symlink_mix(callback) { function test_deep_symlink_mix(callback) {
console.log("test_deep_symlink_mix"); console.log('test_deep_symlink_mix');
// todo: check to see that common.fixturesDir is not rooted in the // todo: check to see that common.fixturesDir is not rooted in the
// same directory as our test symlink. // same directory as our test symlink.
// obtain our current realpath using bash (so we can test ourselves) // obtain our current realpath using bash (so we can test ourselves)
@ -206,66 +228,75 @@ function test_deep_symlink_mix(callback) {
*/ */
var entry = tmp('node-test-realpath-f1'); var entry = tmp('node-test-realpath-f1');
try { fs.unlinkSync(tmp('node-test-realpath-d2/foo')); } catch (e) {} try { fs.unlinkSync(tmp('node-test-realpath-d2/foo')); } catch (e) {}
try { fs.rmdirSync(tmp('node-test-realpath-d2')); } catch(e) {} try { fs.rmdirSync(tmp('node-test-realpath-d2')); } catch (e) {}
fs.mkdirSync(tmp('node-test-realpath-d2'), 0700); fs.mkdirSync(tmp('node-test-realpath-d2'), 0700);
try { try {
[ [
[entry, '../tmp/node-test-realpath-d1/foo'], [entry, '../tmp/node-test-realpath-d1/foo'],
[tmp('node-test-realpath-d1'), '../tmp/node-test-realpath-d2'], [tmp('node-test-realpath-d1'), '../tmp/node-test-realpath-d2'],
[tmp('node-test-realpath-d2/foo'), '../node-test-realpath-f2'], [tmp('node-test-realpath-d2/foo'), '../node-test-realpath-f2'],
[tmp('node-test-realpath-f2'), fixturesAbsDir+'/nested-index/one/realpath-c'], [tmp('node-test-realpath-f2'), fixturesAbsDir +
[fixturesAbsDir+'/nested-index/one/realpath-c', fixturesAbsDir+'/nested-index/two/realpath-c'], '/nested-index/one/realpath-c'],
[fixturesAbsDir+'/nested-index/two/realpath-c', '../../cycles/root.js'], [fixturesAbsDir + '/nested-index/one/realpath-c', fixturesAbsDir +
'/nested-index/two/realpath-c'],
[fixturesAbsDir + '/nested-index/two/realpath-c',
'../../cycles/root.js']
].forEach(function(t) { ].forEach(function(t) {
//common.debug('setting up '+t[0]+' -> '+t[1]); //common.debug('setting up '+t[0]+' -> '+t[1]);
try { fs.unlinkSync(t[0]); } catch(e) {} try { fs.unlinkSync(t[0]); } catch (e) {}
fs.symlinkSync(t[1], t[0]); fs.symlinkSync(t[1], t[0]);
unlink.push(t[0]); unlink.push(t[0]);
}); });
} finally { } finally {
unlink.push(tmp('node-test-realpath-d2')); unlink.push(tmp('node-test-realpath-d2'));
} }
var expected = fixturesAbsDir+'/cycles/root.js'; var expected = fixturesAbsDir + '/cycles/root.js';
assert.equal(fs.realpathSync(entry), expected); assert.equal(fs.realpathSync(entry), expected);
asynctest(fs.realpath, [entry], callback, function(err, result){ asynctest(fs.realpath, [entry], callback, function(err, result) {
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' +
common.inspect(result) +
' expected ' +
common.inspect(expected));
return true; return true;
}); });
}); });
} }
function test_non_symlinks(callback) { function test_non_symlinks(callback) {
console.log("test_non_symlinks"); console.log('test_non_symlinks');
bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) { bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) {
if (err) return callback(err); if (err) return callback(err);
var p = fixturesAbsDir.lastIndexOf('/'); var p = fixturesAbsDir.lastIndexOf('/');
var entrydir = fixturesAbsDir.substr(0, p); var entrydir = fixturesAbsDir.substr(0, p);
var entry = fixturesAbsDir.substr(p+1)+'/cycles/root.js'; var entry = fixturesAbsDir.substr(p + 1) + '/cycles/root.js';
var expected = fixturesAbsDir+'/cycles/root.js'; var expected = fixturesAbsDir + '/cycles/root.js';
var origcwd = process.cwd(); var origcwd = process.cwd();
process.chdir(entrydir); process.chdir(entrydir);
assert.equal(fs.realpathSync(entry), expected); assert.equal(fs.realpathSync(entry), expected);
asynctest(fs.realpath, [entry], callback, function(err, result){ asynctest(fs.realpath, [entry], callback, function(err, result) {
process.chdir(origcwd); process.chdir(origcwd);
assert.equal(result, expected, assert.equal(result, expected,
'got '+common.inspect(result)+' expected '+common.inspect(expected)); 'got ' +
common.inspect(result) +
' expected ' +
common.inspect(expected));
return true; return true;
}); });
}); });
} }
var upone = path.join(process.cwd(), ".."); var upone = path.join(process.cwd(), '..');
function test_escape_cwd (cb) { function test_escape_cwd(cb) {
console.log("test_escape_cwd"); console.log('test_escape_cwd');
asynctest(fs.realpath, [".."], cb, function(er, uponeActual){ asynctest(fs.realpath, ['..'], cb, function(er, uponeActual) {
assert.equal(upone, uponeActual, assert.equal(upone, uponeActual,
"realpath('..') expected: "+upone+" actual:"+uponeActual); 'realpath("..") expected: ' + upone + ' actual:' + uponeActual);
}) });
} }
var uponeActual = fs.realpathSync(".."); var uponeActual = fs.realpathSync('..');
assert.equal(upone, uponeActual, assert.equal(upone, uponeActual,
"realpathSync('..') expected: "+upone+" actual:"+uponeActual); 'realpathSync("..") expected: ' + upone + ' actual:' + uponeActual);
// absolute symlinks with children. // absolute symlinks with children.
// . // .
@ -275,49 +306,49 @@ assert.equal(upone, uponeActual,
// | `-- x.txt // | `-- x.txt
// `-- link -> /tmp/node-test-realpath-abs-kids/a/b/ // `-- link -> /tmp/node-test-realpath-abs-kids/a/b/
// realpath(root+'/a/link/c/x.txt') ==> root+'/a/b/c/x.txt' // realpath(root+'/a/link/c/x.txt') ==> root+'/a/b/c/x.txt'
function test_abs_with_kids (cb) { function test_abs_with_kids(cb) {
console.log("test_abs_with_kids"); console.log('test_abs_with_kids');
bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) { bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) {
var root = fixturesAbsDir+'/node-test-realpath-abs-kids'; var root = fixturesAbsDir + '/node-test-realpath-abs-kids';
function cleanup () { function cleanup() {
;['/a/b/c/x.txt' ['/a/b/c/x.txt',
, '/a/link' '/a/link'
].forEach(function (file) { ].forEach(function(file) {
try {fs.unlinkSync(root+file)} catch (ex) {} try {fs.unlinkSync(root + file)} catch (ex) {}
}); });
;['/a/b/c' ['/a/b/c',
, '/a/b' '/a/b',
, '/a' '/a',
, '' ''
].forEach(function (folder) { ].forEach(function(folder) {
try {fs.rmdirSync(root+folder)} catch (ex) {} try {fs.rmdirSync(root + folder)} catch (ex) {}
}); });
} }
function setup () { function setup() {
cleanup() cleanup();
;['' ['',
, '/a' '/a',
, '/a/b' '/a/b',
, '/a/b/c' '/a/b/c'
].forEach(function (folder) { ].forEach(function(folder) {
console.log("mkdir "+root+folder) console.log('mkdir ' + root + folder);
fs.mkdirSync(root+folder, 0700); fs.mkdirSync(root + folder, 0700);
}); });
fs.writeFileSync(root+'/a/b/c/x.txt', 'foo'); fs.writeFileSync(root + '/a/b/c/x.txt', 'foo');
fs.symlinkSync(root+'/a/b', root+'/a/link'); fs.symlinkSync(root + '/a/b', root + '/a/link');
} }
setup(); setup();
var linkPath = root+'/a/link/c/x.txt'; var linkPath = root + '/a/link/c/x.txt';
var expectPath = root+'/a/b/c/x.txt'; var expectPath = root + '/a/b/c/x.txt';
var actual = fs.realpathSync(linkPath); var actual = fs.realpathSync(linkPath);
// console.log({link:linkPath,expect:expectPath,actual:actual},'sync'); // console.log({link:linkPath,expect:expectPath,actual:actual},'sync');
assert.equal(actual, expectPath); assert.equal(actual, expectPath);
asynctest(fs.realpath, [linkPath], cb, function (er, actual) { asynctest(fs.realpath, [linkPath], cb, function(er, actual) {
// console.log({link:linkPath,expect:expectPath,actual:actual},'async'); // console.log({link:linkPath,expect:expectPath,actual:actual},'async');
assert.equal(actual, expectPath); assert.equal(actual, expectPath);
cleanup(); cleanup();
}); });
}) });
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@ -338,22 +369,23 @@ var tests = [
var numtests = tests.length; var numtests = tests.length;
function runNextTest(err) { function runNextTest(err) {
if (err) throw err; if (err) throw err;
var test = tests.shift() var test = tests.shift();
if (!test) console.log(numtests+' subtests completed OK for fs.realpath'); if (!test) console.log(numtests +
' subtests completed OK for fs.realpath');
else test(runNextTest); else test(runNextTest);
} }
runNextTest(); runNextTest();
assert.equal('/', fs.realpathSync('/')); assert.equal('/', fs.realpathSync('/'));
fs.realpath('/', function (err, result) { fs.realpath('/', function(err, result) {
assert.equal(null, err); assert.equal(null, err);
assert.equal('/', result); assert.equal('/', result);
}); });
process.addListener("exit", function () { process.addListener('exit', function() {
unlink.forEach(function(path){ try {fs.unlinkSync(path);}catch(e){} }); unlink.forEach(function(path) { try {fs.unlinkSync(path);} catch (e) {} });
assert.equal(async_completed, async_expected); assert.equal(async_completed, async_expected);
}); });

Write Preview
Loading…
Cancel
Save