893 lines
27 KiB
JavaScript
893 lines
27 KiB
JavaScript
'use strict';
|
|
|
|
var createNamespace = require('../context.js').createNamespace
|
|
, fs = require('fs')
|
|
, path = require('path')
|
|
, exec = require('child_process').exec
|
|
, tap = require('tap')
|
|
, test = tap.test
|
|
;
|
|
|
|
// CONSTANTS
|
|
var FILENAME = '__testfile'
|
|
, DIRNAME = '__TESTDIR'
|
|
, LINKNAME = '__testlink'
|
|
, HARDLINKNAME = '__testhardlink'
|
|
;
|
|
|
|
function createFile(assert) {
|
|
var contents = new Buffer("UHOH")
|
|
, file = fs.openSync(FILENAME, 'w')
|
|
, written = fs.writeSync(file, contents, 0, contents.length, 0)
|
|
;
|
|
assert.equals(written, contents.length, "whole buffer was written");
|
|
var rc = fs.closeSync(file);
|
|
// need this here to avoid dealing with umask complications
|
|
fs.chmodSync(FILENAME, '0666');
|
|
return rc;
|
|
}
|
|
|
|
function deleteFile() { return fs.unlinkSync(FILENAME); }
|
|
|
|
|
|
function createLink(assert) {
|
|
createFile(assert);
|
|
fs.symlinkSync(FILENAME, LINKNAME);
|
|
if (fs.lchmodSync) {
|
|
// This function only exists on BSD systems (like OSX)
|
|
fs.lchmodSync(LINKNAME, '0777');
|
|
}
|
|
}
|
|
|
|
function deleteLink() {
|
|
fs.unlinkSync(LINKNAME);
|
|
return deleteFile();
|
|
}
|
|
|
|
|
|
function createDirectory(assert) {
|
|
fs.mkdirSync(DIRNAME);
|
|
assert.ok(fs.existsSync(DIRNAME), "directory was created");
|
|
}
|
|
|
|
function deleteDirectory() { return fs.rmdirSync(DIRNAME); }
|
|
|
|
|
|
function mapIds(username, groupname, callback) {
|
|
if (!callback) throw new Error("mapIds requires callback");
|
|
if (!username) return callback(new Error("mapIds requires username"));
|
|
if (!groupname) return callback(new Error("mapIds requires groupname"));
|
|
|
|
exec('id -u ' + username, function (error, stdout, stderr) {
|
|
if (error) return callback(error);
|
|
if (stderr) return callback(new Error(stderr));
|
|
|
|
var uid = +stdout;
|
|
exec('id -g ' + groupname, function (error, stdout, stderr) {
|
|
if (error) return callback(error);
|
|
if (stderr) return callback(new Error(stderr));
|
|
|
|
var gid = +stdout;
|
|
callback(null, uid, gid);
|
|
});
|
|
});
|
|
}
|
|
|
|
test("continuation-local state with MakeCallback and fs module", function (t) {
|
|
t.plan(33);
|
|
|
|
var namespace = createNamespace('fs');
|
|
namespace.run(function () {
|
|
namespace.set('test', 0xabad1dea);
|
|
t.test("fs.rename", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'rename');
|
|
t.equal(namespace.get('test'), 'rename', "state has been mutated");
|
|
|
|
fs.rename(FILENAME, '__renamed', function (error) {
|
|
t.notOk(error, "renaming shouldn't error");
|
|
t.equal(namespace.get('test'), 'rename',
|
|
"mutated state has persisted to fs.rename's callback");
|
|
|
|
fs.unlinkSync('__renamed');
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.truncate", function (t) {
|
|
// truncate -> ftruncate in Node > 0.8.x
|
|
if (!fs.ftruncate) return t.end();
|
|
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'truncate');
|
|
t.equal(namespace.get('test'), 'truncate', "state has been mutated");
|
|
|
|
fs.truncate(FILENAME, 0, function (error) {
|
|
t.notOk(error, "truncation shouldn't error");
|
|
|
|
var stats = fs.statSync(FILENAME);
|
|
t.equal(stats.size, 0, "file has been truncated");
|
|
|
|
t.equal(namespace.get('test'), 'truncate',
|
|
"mutated state has persisted to fs.truncate's callback");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.ftruncate", function (t) {
|
|
createFile(t);
|
|
|
|
// truncate -> ftruncate in Node > 0.8.x
|
|
var truncate = fs.ftruncate ? fs.ftruncate : fs.truncate;
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'ftruncate');
|
|
t.equal(namespace.get('test'), 'ftruncate', "state has been mutated");
|
|
|
|
var file = fs.openSync(FILENAME, 'w');
|
|
truncate(file, 0, function (error) {
|
|
t.notOk(error, "truncation shouldn't error");
|
|
|
|
fs.closeSync(file);
|
|
var stats = fs.statSync(FILENAME);
|
|
t.equal(stats.size, 0, "file has been truncated");
|
|
|
|
t.equal(namespace.get('test'), 'ftruncate',
|
|
"mutated state has persisted to fs.ftruncate's callback");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.chown", function (t) {
|
|
createFile(t);
|
|
|
|
mapIds('daemon', 'daemon', function (error, uid, gid) {
|
|
t.notOk(error, "looking up uid & gid shouldn't error");
|
|
t.ok(uid, "uid for daemon was found");
|
|
t.ok(gid, "gid for daemon was found");
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'chown');
|
|
t.equal(namespace.get('test'), 'chown', "state has been mutated");
|
|
|
|
fs.chown(FILENAME, uid, gid, function (error) {
|
|
t.ok(error, "changing ownership will error for non-root users");
|
|
|
|
t.equal(namespace.get('test'), 'chown',
|
|
"mutated state has persisted to fs.chown's callback");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.fchown", function (t) {
|
|
createFile(t);
|
|
|
|
mapIds('daemon', 'daemon', function (error, uid, gid) {
|
|
t.notOk(error, "looking up uid & gid shouldn't error");
|
|
t.ok(uid, "uid for daemon was found");
|
|
t.ok(gid, "gid for daemon was found");
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'fchown');
|
|
t.equal(namespace.get('test'), 'fchown', "state has been mutated");
|
|
|
|
var file = fs.openSync(FILENAME, 'w');
|
|
fs.fchown(file, uid, gid, function (error) {
|
|
t.ok(error, "changing ownership will error for non-root users");
|
|
|
|
t.equal(namespace.get('test'), 'fchown',
|
|
"mutated state has persisted to fs.fchown's callback");
|
|
|
|
fs.closeSync(file);
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.lchown", function (t) {
|
|
if (!fs.lchown) return t.end();
|
|
createLink(t);
|
|
|
|
mapIds('daemon', 'daemon', function (error, uid, gid) {
|
|
t.notOk(error, "looking up uid & gid shouldn't error");
|
|
t.ok(uid, "uid for daemon was found");
|
|
t.ok(gid, "gid for daemon was found");
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'lchown');
|
|
t.equal(namespace.get('test'), 'lchown', "state has been mutated");
|
|
|
|
fs.lchown(LINKNAME, uid, gid, function (error) {
|
|
t.ok(error, "changing ownership will error for non-root users");
|
|
|
|
t.equal(namespace.get('test'), 'lchown',
|
|
"mutated state has persisted to fs.lchown's callback");
|
|
|
|
deleteLink();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.chmod", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'chmod');
|
|
t.equal(namespace.get('test'), 'chmod', "state has been mutated");
|
|
|
|
fs.chmod(FILENAME, '0700', function (error) {
|
|
t.notOk(error, "changing mode shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'chmod',
|
|
"mutated state has persisted to fs.chmod's callback");
|
|
|
|
var stats = fs.statSync(FILENAME);
|
|
t.equal(stats.mode.toString(8), '100700', "extra access bits are stripped");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.fchmod", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'fchmod');
|
|
t.equal(namespace.get('test'), 'fchmod', "state has been mutated");
|
|
|
|
var file = fs.openSync(FILENAME, 'w+');
|
|
fs.fchmod(file, '0700', function (error) {
|
|
t.notOk(error, "changing mode shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'fchmod',
|
|
"mutated state has persisted to fs.fchmod's callback");
|
|
|
|
fs.closeSync(file);
|
|
var stats = fs.statSync(FILENAME);
|
|
t.equal(stats.mode.toString(8), '100700', "extra access bits are stripped");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.lchmod", function (t) {
|
|
if (!fs.lchmod) return t.end();
|
|
createLink(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'lchmod');
|
|
t.equal(namespace.get('test'), 'lchmod', "state has been mutated");
|
|
|
|
fs.lchmod(LINKNAME, '0700', function (error) {
|
|
t.notOk(error, "changing mode shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'lchmod',
|
|
"mutated state has persisted to fs.lchmod's callback");
|
|
|
|
var stats = fs.lstatSync(LINKNAME);
|
|
t.equal(stats.mode.toString(8), '120700', "extra access bits are stripped");
|
|
|
|
deleteLink();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.stat", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'stat');
|
|
t.equal(namespace.get('test'), 'stat', "state has been mutated");
|
|
|
|
fs.stat(FILENAME, function (error, stats) {
|
|
t.notOk(error, "reading stats shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'stat',
|
|
"mutated state has persisted to fs.stat's callback");
|
|
|
|
t.equal(stats.mode.toString(8), '100666', "permissions should be as created");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.fstat", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'fstat');
|
|
t.equal(namespace.get('test'), 'fstat', "state has been mutated");
|
|
|
|
var file = fs.openSync(FILENAME, 'r');
|
|
fs.fstat(file, function (error, stats) {
|
|
t.notOk(error, "reading stats shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'fstat',
|
|
"mutated state has persisted to fs.fstat's callback");
|
|
|
|
t.equal(stats.mode.toString(8), '100666', "permissions should be as created");
|
|
|
|
fs.closeSync(file);
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.lstat", function (t) {
|
|
createLink(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'lstat');
|
|
t.equal(namespace.get('test'), 'lstat', "state has been mutated");
|
|
|
|
fs.lstat(LINKNAME, function (error, stats) {
|
|
t.notOk(error, "reading stats shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'lstat',
|
|
"mutated state has persisted to fs.lstat's callback");
|
|
|
|
t.equal(
|
|
stats.mode.toString(8),
|
|
'120777',
|
|
"permissions should be as created"
|
|
);
|
|
|
|
deleteLink();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.link", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'link');
|
|
t.equal(namespace.get('test'), 'link', "state has been mutated");
|
|
|
|
fs.link(FILENAME, HARDLINKNAME, function (error) {
|
|
t.notOk(error, "creating a link shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'link',
|
|
"mutated state has persisted to fs.link's callback");
|
|
|
|
var orig = fs.statSync(FILENAME)
|
|
, linked = fs.statSync(HARDLINKNAME)
|
|
;
|
|
t.equal(orig.ino, linked.ino, "entries should point to same file");
|
|
|
|
t.notOk(fs.unlinkSync(HARDLINKNAME), "link has been removed");
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.symlink", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'symlink');
|
|
t.equal(namespace.get('test'), 'symlink', "state has been mutated");
|
|
|
|
fs.symlink(FILENAME, LINKNAME, function (error) {
|
|
t.notOk(error, "creating a symlink shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'symlink',
|
|
"mutated state has persisted to fs.symlink's callback");
|
|
|
|
var pointed = fs.readlinkSync(LINKNAME);
|
|
t.equal(pointed, FILENAME, "symlink points back to original file");
|
|
|
|
t.notOk(fs.unlinkSync(LINKNAME), "symlink has been removed");
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.readlink", function (t) {
|
|
createLink(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'readlink');
|
|
t.equal(namespace.get('test'), 'readlink', "state has been mutated");
|
|
|
|
fs.readlink(LINKNAME, function (error, pointed) {
|
|
t.notOk(error, "reading symlink shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'readlink',
|
|
"mutated state has persisted to fs.readlink's callback");
|
|
|
|
t.equal(pointed, FILENAME, "symlink points back to original file");
|
|
|
|
deleteLink();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.unlink", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'unlink');
|
|
t.equal(namespace.get('test'), 'unlink', "state has been mutated");
|
|
|
|
fs.unlink(FILENAME, function (error) {
|
|
t.notOk(error, "deleting file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'unlink',
|
|
"mutated state has persisted to fs.unlink's callback");
|
|
|
|
t.notOk(fs.exists(FILENAME), "file should be gone");
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.realpath", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'realpath');
|
|
t.equal(namespace.get('test'), 'realpath', "state has been mutated");
|
|
|
|
fs.realpath(FILENAME, function (error, real) {
|
|
t.notOk(error, "deleting file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'realpath',
|
|
"mutated state has persisted to fs.realpath's callback");
|
|
|
|
t.equal(real, path.resolve(FILENAME), "no funny business with the real path");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.mkdir", function (t) {
|
|
namespace.run(function () {
|
|
namespace.set('test', 'mkdir');
|
|
t.equal(namespace.get('test'), 'mkdir', "state has been mutated");
|
|
|
|
fs.mkdir(DIRNAME, function (error) {
|
|
t.notOk(error, "creating directory shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'mkdir',
|
|
"mutated state has persisted to fs.mkdir's callback");
|
|
|
|
t.ok(fs.existsSync(DIRNAME), "directory was created");
|
|
|
|
fs.rmdirSync(DIRNAME);
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.rmdir", function (t) {
|
|
createDirectory(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'rmdir');
|
|
t.equal(namespace.get('test'), 'rmdir', "state has been mutated");
|
|
|
|
fs.rmdir(DIRNAME, function (error) {
|
|
t.notOk(error, "deleting directory shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'rmdir',
|
|
"mutated state has persisted to fs.rmdir's callback");
|
|
|
|
t.notOk(fs.existsSync(DIRNAME), "directory was removed");
|
|
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.readdir", function (t) {
|
|
createDirectory(t);
|
|
|
|
var file1 = fs.openSync(path.join(DIRNAME, 'file1'), 'w');
|
|
fs.writeSync(file1, 'one');
|
|
fs.closeSync(file1);
|
|
|
|
var file2 = fs.openSync(path.join(DIRNAME, 'file2'), 'w');
|
|
fs.writeSync(file2, 'two');
|
|
fs.closeSync(file2);
|
|
|
|
var file3 = fs.openSync(path.join(DIRNAME, 'file3'), 'w');
|
|
fs.writeSync(file3, 'three');
|
|
fs.closeSync(file3);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'readdir');
|
|
t.equal(namespace.get('test'), 'readdir', "state has been mutated");
|
|
|
|
fs.readdir(DIRNAME, function (error, contents) {
|
|
t.notOk(error, "reading directory shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'readdir',
|
|
"mutated state has persisted to fs.readdir's callback");
|
|
|
|
t.equal(contents.length, 3, "3 files were found");
|
|
|
|
fs.unlinkSync(path.join(DIRNAME, 'file1'));
|
|
fs.unlinkSync(path.join(DIRNAME, 'file2'));
|
|
fs.unlinkSync(path.join(DIRNAME, 'file3'));
|
|
deleteDirectory();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.watch", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'watch');
|
|
t.equal(namespace.get('test'), 'watch', "state has been mutated");
|
|
|
|
var watcher = fs.watch(FILENAME,
|
|
{persistent : false, interval : 200},
|
|
function (event) {
|
|
t.equal(namespace.get('test'), 'watch',
|
|
"mutated state has persisted to fs.watch's callback");
|
|
|
|
t.equal(event, 'change', "file was changed");
|
|
|
|
watcher.close();
|
|
process.nextTick(function cleanup() {
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
|
|
setTimeout(function poke() {
|
|
fs.writeFileSync(FILENAME, 'still a test');
|
|
}, 20);
|
|
});
|
|
});
|
|
|
|
t.test("fs.utimes", function (t) {
|
|
createFile(t);
|
|
|
|
/* utimes(2) takes seconds since the epoch, and Date() deals with
|
|
* milliseconds. I just want a date some time in the past.
|
|
*/
|
|
var PASTIME = new Date(Math.floor((Date.now() - 31337) / 1000) * 1000);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'utimes');
|
|
t.equal(namespace.get('test'), 'utimes', "state has been mutated");
|
|
|
|
var before = fs.statSync(FILENAME);
|
|
t.ok(before.atime, "access time of newly-created file set");
|
|
t.ok(before.mtime, "modification time of newly-created file set");
|
|
|
|
fs.utimes(FILENAME, PASTIME, PASTIME, function (error) {
|
|
t.notOk(error, "setting utimes shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'utimes',
|
|
"mutated state has persisted to fs.utimes's callback");
|
|
|
|
var after = fs.statSync(FILENAME);
|
|
t.deepEqual(after.atime, PASTIME, "access time of newly-created file is reset");
|
|
t.deepEqual(after.mtime, PASTIME, "mod time of newly-created file is reset");
|
|
t.notDeepEqual(before.atime, after.atime, "access time changed");
|
|
t.notDeepEqual(before.mtime, after.mtime, "mod time changed");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.futimes", function (t) {
|
|
createFile(t);
|
|
|
|
/* futimes(2) takes seconds since the epoch, and Date() deals with
|
|
* milliseconds. I just want a date some time in the past.
|
|
*/
|
|
var PASTIME = new Date(Math.floor((Date.now() - 0xb33fd) / 1000) * 1000);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'futimes');
|
|
t.equal(namespace.get('test'), 'futimes', "state has been mutated");
|
|
|
|
var before = fs.statSync(FILENAME);
|
|
t.ok(before.atime, "access time of newly-created file set");
|
|
t.ok(before.mtime, "modification time of newly-created file set");
|
|
|
|
var file = fs.openSync(FILENAME, "w+");
|
|
fs.futimes(file, PASTIME, PASTIME, function (error) {
|
|
t.notOk(error, "setting futimes shouldn't error");
|
|
fs.closeSync(file);
|
|
|
|
t.equal(namespace.get('test'), 'futimes',
|
|
"mutated state has persisted to fs.futimes's callback");
|
|
|
|
var after = fs.statSync(FILENAME);
|
|
t.deepEqual(after.atime, PASTIME, "access time of newly-created file is reset");
|
|
t.deepEqual(after.mtime, PASTIME, "mod time of newly-created file is reset");
|
|
t.notDeepEqual(before.atime, after.atime, "access time changed");
|
|
t.notDeepEqual(before.mtime, after.mtime, "mod time changed");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.fsync", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'fsync');
|
|
t.equal(namespace.get('test'), 'fsync', "state has been mutated");
|
|
|
|
var file = fs.openSync(FILENAME, 'w+');
|
|
fs.fsync(file, function (error) {
|
|
t.notOk(error, "syncing the file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'fsync',
|
|
"mutated state has persisted to fs.fsync's callback");
|
|
|
|
fs.closeSync(file);
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.open", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'open');
|
|
t.equal(namespace.get('test'), 'open', "state has been mutated");
|
|
|
|
fs.open(FILENAME, 'r', function (error, file) {
|
|
t.notOk(error, "opening the file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'open',
|
|
"mutated state has persisted to fs.open's callback");
|
|
|
|
|
|
var contents = new Buffer(4);
|
|
fs.readSync(file, contents, 0, 4, 0);
|
|
t.equal(contents.toString(), 'UHOH', "contents are still available");
|
|
|
|
fs.closeSync(file);
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.close", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'close');
|
|
t.equal(namespace.get('test'), 'close', "state has been mutated");
|
|
|
|
var file = fs.openSync(FILENAME, 'r');
|
|
fs.close(file, function (error) {
|
|
t.notOk(error, "closing the file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'close',
|
|
"mutated state has persisted to fs.close's callback");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.read", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'read');
|
|
t.equal(namespace.get('test'), 'read', "state has been mutated");
|
|
|
|
var file = fs.openSync(FILENAME, 'r')
|
|
, contents = new Buffer(4)
|
|
;
|
|
fs.read(file, contents, 0, 4, 0, function (error) {
|
|
t.notOk(error, "reading from the file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'read',
|
|
"mutated state has persisted to fs.read's callback");
|
|
|
|
t.equal(contents.toString(), 'UHOH', "contents are still available");
|
|
|
|
fs.closeSync(file);
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.write", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'write');
|
|
t.equal(namespace.get('test'), 'write', "state has been mutated");
|
|
|
|
var file = fs.openSync(FILENAME, 'w')
|
|
, contents = new Buffer('yeap')
|
|
;
|
|
fs.write(file, contents, 0, 4, 0, function (error) {
|
|
t.notOk(error, "writing to the file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'write',
|
|
"mutated state has persisted to fs.write's callback");
|
|
|
|
fs.closeSync(file);
|
|
|
|
var readback = fs.readFileSync(FILENAME);
|
|
t.equal(readback.toString(), 'yeap', "contents are still available");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.readFile", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'readFile');
|
|
t.equal(namespace.get('test'), 'readFile', "state has been mutated");
|
|
|
|
fs.readFile(FILENAME, function (error, contents) {
|
|
t.notOk(error, "reading from the file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'readFile',
|
|
"mutated state has persisted to fs.readFile's callback");
|
|
|
|
t.equal(contents.toString(), 'UHOH', "contents are still available");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.writeFile", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'writeFile');
|
|
t.equal(namespace.get('test'), 'writeFile', "state has been mutated");
|
|
|
|
fs.writeFile(FILENAME, 'woopwoop', function (error) {
|
|
t.notOk(error, "rewriting the file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'writeFile',
|
|
"mutated state has persisted to fs.writeFile's callback");
|
|
|
|
var readback = fs.readFileSync(FILENAME);
|
|
t.equal(readback.toString(), 'woopwoop', "rewritten contents are available");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.appendFile", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'appendFile');
|
|
t.equal(namespace.get('test'), 'appendFile', "state has been mutated");
|
|
|
|
fs.appendFile(FILENAME, '/jk', function (error) {
|
|
t.notOk(error, "appending to the file shouldn't error");
|
|
|
|
t.equal(namespace.get('test'), 'appendFile',
|
|
"mutated state has persisted to fs.appendFile's callback");
|
|
|
|
var readback = fs.readFileSync(FILENAME);
|
|
t.equal(readback.toString(), 'UHOH/jk',
|
|
"appended contents are still available");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.exists", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'exists');
|
|
t.equal(namespace.get('test'), 'exists', "state has been mutated");
|
|
|
|
fs.exists(FILENAME, function (yep) {
|
|
t.equal(namespace.get('test'), 'exists',
|
|
"mutated state has persisted to fs.exists's callback");
|
|
|
|
t.ok(yep, "precreated file does indeed exist.");
|
|
|
|
fs.exists('NOPENOWAY', function (nope) {
|
|
t.equal(namespace.get('test'), 'exists',
|
|
"mutated state continues to persist to fs.exists's second callback");
|
|
|
|
t.notOk(nope, "nonexistent file doesn't exist.");
|
|
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
t.test("fs.watchFile", function (t) {
|
|
createFile(t);
|
|
|
|
namespace.run(function () {
|
|
namespace.set('test', 'watchFile');
|
|
t.equal(namespace.get('test'), 'watchFile', "state has been mutated");
|
|
|
|
var options = {
|
|
persistent: true,
|
|
interval: 20
|
|
};
|
|
|
|
fs.watchFile(FILENAME, options, function (before, after) {
|
|
t.equal(namespace.get('test'), 'watchFile',
|
|
"mutated state has persisted to fs.watchFile's callback");
|
|
|
|
t.ok(before.ino, "file has an entry");
|
|
t.equal(before.ino, after.ino, "file is at the same location");
|
|
|
|
fs.unwatchFile(FILENAME);
|
|
process.nextTick(function () {
|
|
deleteFile();
|
|
t.end();
|
|
});
|
|
});
|
|
|
|
setTimeout(function poke() {
|
|
fs.appendFileSync(FILENAME, 'still a test');
|
|
}, 20);
|
|
});
|
|
});
|
|
});
|
|
});
|