mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
12 KiB
355 lines
12 KiB
common = require("../common");
|
|
assert = common.assert
|
|
var fs = require('fs');
|
|
var path = require('path');
|
|
var exec = require('child_process').exec;
|
|
var async_completed = 0, async_expected = 0, unlink = [];
|
|
|
|
function asynctest(testBlock, args, callback, assertBlock) {
|
|
async_expected++;
|
|
testBlock.apply(testBlock, args.concat(function(err){
|
|
var ignoreError = false;
|
|
if (assertBlock) {
|
|
try {
|
|
ignoreError = assertBlock.apply(assertBlock, arguments);
|
|
}
|
|
catch (e) {
|
|
err = e;
|
|
}
|
|
}
|
|
async_completed++;
|
|
callback(ignoreError ? null : err);
|
|
}));
|
|
}
|
|
|
|
function bashRealpath(path, callback) {
|
|
exec("cd '"+path.replace("'","\\'")+"' && pwd -P",function
|
|
(err, o) {
|
|
callback(err, o.trim());
|
|
});
|
|
}
|
|
|
|
// sub-tests:
|
|
|
|
function test_simple_relative_symlink(callback) {
|
|
console.log("test_simple_relative_symlink");
|
|
var entry = common.fixturesDir+'/cycles/symlink',
|
|
expected = common.fixturesDir+'/cycles/root.js';
|
|
[
|
|
[entry, 'root.js'],
|
|
].forEach(function(t) {
|
|
try {fs.unlinkSync(t[0]);}catch(e){}
|
|
fs.symlinkSync(t[1], t[0]);
|
|
unlink.push(t[0]);
|
|
});
|
|
var result = fs.realpathSync(entry);
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
asynctest(fs.realpath, [entry], callback, function(err, result){
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
});
|
|
}
|
|
|
|
function test_simple_absolute_symlink(callback) {
|
|
console.log("test_simple_absolute_symlink");
|
|
bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) {
|
|
if (err) return callback(err);
|
|
var entry = fixturesAbsDir+'/cycles/symlink',
|
|
expected = fixturesAbsDir+'/nested-index/one/index.js';
|
|
[
|
|
[entry, expected],
|
|
].forEach(function(t) {
|
|
try {fs.unlinkSync(t[0]);}catch(e){}
|
|
fs.symlinkSync(t[1], t[0]);
|
|
unlink.push(t[0]);
|
|
});
|
|
var result = fs.realpathSync(entry);
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
asynctest(fs.realpath, [entry], callback, function(err, result){
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
});
|
|
});
|
|
}
|
|
|
|
function test_deep_relative_file_symlink(callback) {
|
|
console.log("test_deep_relative_file_symlink");
|
|
var expected = path.join(common.fixturesDir, 'cycles', 'root.js');
|
|
var linkData1 = "../../cycles/root.js";
|
|
var linkPath1 = path.join(common.fixturesDir, "nested-index", 'one', 'symlink1.js');
|
|
try {fs.unlinkSync(linkPath1);}catch(e){}
|
|
fs.symlinkSync(linkData1, linkPath1);
|
|
|
|
var linkData2 = "../one/symlink1.js";
|
|
var entry = path.join(common.fixturesDir, "nested-index", 'two', 'symlink1-b.js');
|
|
try {fs.unlinkSync(entry);}catch(e){}
|
|
fs.symlinkSync(linkData2, entry);
|
|
unlink.push(linkPath1);
|
|
unlink.push(entry);
|
|
|
|
assert.equal(fs.realpathSync(entry), expected);
|
|
asynctest(fs.realpath, [entry], callback, function(err, result){
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
});
|
|
}
|
|
|
|
function test_deep_relative_dir_symlink(callback) {
|
|
console.log("test_deep_relative_dir_symlink");
|
|
var expected = path.join(common.fixturesDir, 'cycles', 'folder');
|
|
var linkData1b = "../../cycles/folder";
|
|
var linkPath1b = path.join(common.fixturesDir, "nested-index", 'one', 'symlink1-dir');
|
|
try {fs.unlinkSync(linkPath1b);}catch(e){}
|
|
fs.symlinkSync(linkData1b, linkPath1b);
|
|
|
|
var linkData2b = "../one/symlink1-dir";
|
|
var entry = path.join(common.fixturesDir, "nested-index", 'two', 'symlink12-dir');
|
|
try {fs.unlinkSync(entry);}catch(e){}
|
|
fs.symlinkSync(linkData2b, entry);
|
|
unlink.push(linkPath1b);
|
|
unlink.push(entry);
|
|
|
|
assert.equal(fs.realpathSync(entry), expected);
|
|
|
|
asynctest(fs.realpath, [entry], callback, function(err, result){
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
});
|
|
}
|
|
|
|
function test_cyclic_link_protection(callback) {
|
|
console.log("test_cyclic_link_protection");
|
|
var entry = common.fixturesDir+'/cycles/realpath-3a';
|
|
[
|
|
[entry, '../cycles/realpath-3b'],
|
|
[common.fixturesDir+'/cycles/realpath-3b', '../cycles/realpath-3c'],
|
|
[common.fixturesDir+'/cycles/realpath-3c', '../cycles/realpath-3a'],
|
|
].forEach(function(t) {
|
|
try {fs.unlinkSync(t[0]);}catch(e){}
|
|
fs.symlinkSync(t[1], t[0]);
|
|
unlink.push(t[0]);
|
|
});
|
|
assert.throws(function(){ fs.realpathSync(entry); });
|
|
asynctest(fs.realpath, [entry], callback, function(err, result){
|
|
assert.ok(err && true);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
function test_cyclic_link_overprotection (callback) {
|
|
console.log("test_cyclic_link_overprotection");
|
|
var cycles = common.fixturesDir+'/cycles';
|
|
var expected = fs.realpathSync(cycles);
|
|
var folder = cycles+'/folder';
|
|
var link = folder+'/cycles';
|
|
var testPath = cycles;
|
|
for (var i = 0; i < 10; i ++) testPath += '/folder/cycles';
|
|
try {fs.unlinkSync(link)} catch (ex) {}
|
|
fs.symlinkSync(cycles, link);
|
|
assert.equal(fs.realpathSync(testPath), expected);
|
|
asynctest(fs.realpath, [testPath], callback, function (er, res) {
|
|
assert.equal(res, expected);
|
|
});
|
|
}
|
|
|
|
function test_relative_input_cwd(callback) {
|
|
console.log("test_relative_input_cwd");
|
|
var p = common.fixturesDir.lastIndexOf('/');
|
|
var entrydir = common.fixturesDir.substr(0, p);
|
|
var entry = common.fixturesDir.substr(p+1)+'/cycles/realpath-3a';
|
|
var expected = common.fixturesDir+'/cycles/root.js';
|
|
[
|
|
[entry, '../cycles/realpath-3b'],
|
|
[common.fixturesDir+'/cycles/realpath-3b', '../cycles/realpath-3c'],
|
|
[common.fixturesDir+'/cycles/realpath-3c', 'root.js'],
|
|
].forEach(function(t) {
|
|
var fn = t[0];
|
|
if (fn.charAt(0) !== '/') fn = entrydir + '/' + fn;
|
|
try {fs.unlinkSync(fn);}catch(e){}
|
|
fs.symlinkSync(t[1], fn);
|
|
unlink.push(fn);
|
|
});
|
|
var origcwd = process.cwd();
|
|
process.chdir(entrydir);
|
|
assert.equal(fs.realpathSync(entry), expected);
|
|
asynctest(fs.realpath, [entry], callback, function(err, result){
|
|
process.chdir(origcwd);
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
return true;
|
|
});
|
|
}
|
|
|
|
function test_deep_symlink_mix(callback) {
|
|
console.log("test_deep_symlink_mix");
|
|
// todo: check to see that common.fixturesDir is not rooted in the
|
|
// same directory as our test symlink.
|
|
// obtain our current realpath using bash (so we can test ourselves)
|
|
bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) {
|
|
if (err) return callback(err);
|
|
/*
|
|
/tmp/node-test-realpath-f1 -> ../tmp/node-test-realpath-d1/foo
|
|
/tmp/node-test-realpath-d1 -> ../node-test-realpath-d2
|
|
/tmp/node-test-realpath-d2/foo -> ../node-test-realpath-f2
|
|
/tmp/node-test-realpath-f2
|
|
-> /node/test/fixtures/nested-index/one/realpath-c
|
|
/node/test/fixtures/nested-index/one/realpath-c
|
|
-> /node/test/fixtures/nested-index/two/realpath-c
|
|
/node/test/fixtures/nested-index/two/realpath-c -> ../../cycles/root.js
|
|
/node/test/fixtures/cycles/root.js (hard)
|
|
*/
|
|
var 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', 0700);
|
|
try {
|
|
[
|
|
[entry, '../tmp/node-test-realpath-d1/foo'],
|
|
['/tmp/node-test-realpath-d1', '../tmp/node-test-realpath-d2'],
|
|
['/tmp/node-test-realpath-d2/foo', '../node-test-realpath-f2'],
|
|
['/tmp/node-test-realpath-f2', fixturesAbsDir+'/nested-index/one/realpath-c'],
|
|
[fixturesAbsDir+'/nested-index/one/realpath-c', fixturesAbsDir+'/nested-index/two/realpath-c'],
|
|
[fixturesAbsDir+'/nested-index/two/realpath-c', '../../cycles/root.js'],
|
|
].forEach(function(t) {
|
|
//common.debug('setting up '+t[0]+' -> '+t[1]);
|
|
try {fs.unlinkSync(t[0]);}catch(e){}
|
|
fs.symlinkSync(t[1], t[0]);
|
|
unlink.push(t[0]);
|
|
});
|
|
} finally {
|
|
unlink.push('/tmp/node-test-realpath-d2');
|
|
}
|
|
var expected = fixturesAbsDir+'/cycles/root.js';
|
|
assert.equal(fs.realpathSync(entry), expected);
|
|
asynctest(fs.realpath, [entry], callback, function(err, result){
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
return true;
|
|
});
|
|
});
|
|
}
|
|
|
|
function test_non_symlinks(callback) {
|
|
console.log("test_non_symlinks");
|
|
bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) {
|
|
if (err) return callback(err);
|
|
var p = fixturesAbsDir.lastIndexOf('/');
|
|
var entrydir = fixturesAbsDir.substr(0, p);
|
|
var entry = fixturesAbsDir.substr(p+1)+'/cycles/root.js';
|
|
var expected = fixturesAbsDir+'/cycles/root.js';
|
|
var origcwd = process.cwd();
|
|
process.chdir(entrydir);
|
|
assert.equal(fs.realpathSync(entry), expected);
|
|
asynctest(fs.realpath, [entry], callback, function(err, result){
|
|
process.chdir(origcwd);
|
|
assert.equal(result, expected,
|
|
'got '+common.inspect(result)+' expected '+common.inspect(expected));
|
|
return true;
|
|
});
|
|
});
|
|
}
|
|
|
|
var upone = path.join(process.cwd(), "..");
|
|
function test_escape_cwd (cb) {
|
|
console.log("test_escape_cwd");
|
|
asynctest(fs.realpath, [".."], cb, function(er, uponeActual){
|
|
assert.equal(upone, uponeActual,
|
|
"realpath('..') expected: "+upone+" actual:"+uponeActual);
|
|
})
|
|
}
|
|
var uponeActual = fs.realpathSync("..");
|
|
assert.equal(upone, uponeActual,
|
|
"realpathSync('..') expected: "+upone+" actual:"+uponeActual);
|
|
|
|
// absolute symlinks with children.
|
|
// .
|
|
// `-- a/
|
|
// |-- b/
|
|
// | `-- c/
|
|
// | `-- x.txt
|
|
// `-- link -> /tmp/node-test-realpath-abs-kids/a/b/
|
|
// realpath(root+'/a/link/c/x.txt') ==> root+'/a/b/c/x.txt'
|
|
function test_abs_with_kids (cb) {
|
|
console.log("test_abs_with_kids");
|
|
bashRealpath(common.fixturesDir, function(err, fixturesAbsDir) {
|
|
var root = fixturesAbsDir+'/node-test-realpath-abs-kids';
|
|
function cleanup () {
|
|
;['/a/b/c/x.txt'
|
|
, '/a/link'
|
|
].forEach(function (file) {
|
|
try {fs.unlinkSync(root+file)} catch (ex) {}
|
|
});
|
|
;['/a/b/c'
|
|
, '/a/b'
|
|
, '/a'
|
|
, ''
|
|
].forEach(function (folder) {
|
|
try {fs.rmdirSync(root+folder)} catch (ex) {}
|
|
});
|
|
}
|
|
function setup () {
|
|
cleanup()
|
|
;[''
|
|
, '/a'
|
|
, '/a/b'
|
|
, '/a/b/c'
|
|
].forEach(function (folder) {
|
|
console.log("mkdir "+root+folder)
|
|
fs.mkdirSync(root+folder, 0700);
|
|
});
|
|
fs.writeFileSync(root+'/a/b/c/x.txt', 'foo');
|
|
fs.symlinkSync(root+'/a/b', root+'/a/link');
|
|
}
|
|
setup();
|
|
var linkPath = root+'/a/link/c/x.txt';
|
|
var expectPath = root+'/a/b/c/x.txt';
|
|
var actual = fs.realpathSync(linkPath);
|
|
// console.log({link:linkPath,expect:expectPath,actual:actual},'sync');
|
|
assert.equal(actual, expectPath);
|
|
asynctest(fs.realpath, [linkPath], cb, function (er, actual) {
|
|
// console.log({link:linkPath,expect:expectPath,actual:actual},'async');
|
|
assert.equal(actual, expectPath);
|
|
cleanup();
|
|
});
|
|
})
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
var tests = [
|
|
test_simple_relative_symlink,
|
|
test_simple_absolute_symlink,
|
|
test_deep_relative_file_symlink,
|
|
test_deep_relative_dir_symlink,
|
|
test_cyclic_link_protection,
|
|
test_cyclic_link_overprotection,
|
|
test_relative_input_cwd,
|
|
test_deep_symlink_mix,
|
|
test_non_symlinks,
|
|
test_escape_cwd,
|
|
test_abs_with_kids
|
|
];
|
|
var numtests = tests.length;
|
|
function runNextTest(err) {
|
|
if (err) throw err;
|
|
var test = tests.shift()
|
|
if (!test) console.log(numtests+' subtests completed OK for fs.realpath');
|
|
else test(runNextTest);
|
|
}
|
|
runNextTest();
|
|
|
|
|
|
assert.equal('/', fs.realpathSync('/'));
|
|
fs.realpath('/', function (err, result) {
|
|
assert.equal(null, err);
|
|
assert.equal('/', result);
|
|
});
|
|
|
|
|
|
|
|
process.addListener("exit", function () {
|
|
unlink.forEach(function(path){ try {fs.unlinkSync(path);}catch(e){} });
|
|
assert.equal(async_completed, async_expected);
|
|
});
|
|
|