1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test: refactor test-fs-read-stream-inherit

Browse Source 
Refactor to take advantage of block scoping to isolate tests. Checks in
exit handlers now reside with the relevant test block. Where test cases
start and end is more clear.

Also: Some use of `common.mustCall()` and improved wrapping/indentation.

PR-URL: https://github.com/nodejs/node/pull/10246
Reviewed-By: Michaël Zasso <targos@protonmail.com>
This commit is contained in:
Rich Trott 2016-12-12 21:35:17 -08:00
parent 3daa4b1f76
commit 44e704f1f8
1 changed files with 151 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

291
test/parallel/test-fs-read-stream-inherit.js
View File

@ -7,174 +7,185 @@ const fs = require('fs');
const fn = path.join(common.fixturesDir, 'elipses.txt'); const fn = path.join(common.fixturesDir, 'elipses.txt');
const rangeFile = path.join(common.fixturesDir, 'x.txt'); const rangeFile = path.join(common.fixturesDir, 'x.txt');
const callbacks = { open: 0, end: 0, close: 0 };
let paused = false; let paused = false;
const file = fs.ReadStream(fn); {
const file = fs.ReadStream(fn);
file.on('open', function(fd) { file.on('open', common.mustCall(function(fd) {
file.length = 0; file.length = 0;
callbacks.open++; assert.strictEqual(typeof fd, 'number');
assert.strictEqual(typeof fd, 'number'); assert.ok(file.readable);
assert.ok(file.readable);
// GH-535 // GH-535
file.pause(); file.pause();
file.resume();
file.pause();
file.resume();
});
file.on('data', function(data) {
assert.ok(data instanceof Buffer);
assert.ok(!paused);
file.length += data.length;
paused = true;
file.pause();
setTimeout(function() {
paused = false;
file.resume(); file.resume();
}, 10); file.pause();
}); file.resume();
}));
file.on('data', function(data) {
assert.ok(data instanceof Buffer);
assert.ok(!paused);
file.length += data.length;
paused = true;
file.pause();
setTimeout(function() {
paused = false;
file.resume();
}, 10);
});
file.on('end', function(chunk) { file.on('end', common.mustCall(function() {}));
callbacks.end++;
});
file.on('close', function() { file.on('close', common.mustCall(function() {
callbacks.close++; assert.strictEqual(file.length, 30000);
}); }));
}
const file3 = fs.createReadStream(fn, Object.create({encoding: 'utf8'})); {
file3.length = 0; const file3 = fs.createReadStream(fn, Object.create({encoding: 'utf8'}));
file3.on('data', function(data) { file3.length = 0;
assert.strictEqual(typeof data, 'string'); file3.on('data', function(data) {
file3.length += data.length; assert.strictEqual(typeof data, 'string');
file3.length += data.length;
for (let i = 0; i < data.length; i++) { for (let i = 0; i < data.length; i++) {
// http://www.fileformat.info/info/unicode/char/2026/index.htm // http://www.fileformat.info/info/unicode/char/2026/index.htm
assert.strictEqual(data[i], '\u2026'); assert.strictEqual(data[i], '\u2026');
} }
}); });
file3.on('close', function() { file3.on('close', common.mustCall(function() {
callbacks.close++; assert.strictEqual(file3.length, 10000);
}); }));
}
process.on('exit', function() { {
assert.strictEqual(callbacks.open, 1); const options = Object.create({bufferSize: 1, start: 1, end: 2});
assert.strictEqual(callbacks.end, 1); const file4 = fs.createReadStream(rangeFile, options);
assert.strictEqual(callbacks.close, 2); assert.strictEqual(file4.start, 1);
assert.strictEqual(file.length, 30000); assert.strictEqual(file4.end, 2);
assert.strictEqual(file3.length, 10000); let contentRead = '';
console.error('ok'); file4.on('data', function(data) {
}); contentRead += data.toString('utf-8');
});
file4.on('end', common.mustCall(function() {
assert.strictEqual(contentRead, 'yz');
}));
}
const file4 = fs.createReadStream(rangeFile, Object.create({bufferSize: 1, {
start: 1, end: 2})); const options = Object.create({bufferSize: 1, start: 1});
assert.strictEqual(file4.start, 1); const file5 = fs.createReadStream(rangeFile, options);
assert.strictEqual(file4.end, 2); assert.strictEqual(file5.start, 1);
let contentRead = ''; file5.data = '';
file4.on('data', function(data) { file5.on('data', function(data) {
contentRead += data.toString('utf-8'); file5.data += data.toString('utf-8');
}); });
file4.on('end', function(data) { file5.on('end', common.mustCall(function() {
assert.strictEqual(contentRead, 'yz'); assert.strictEqual(file5.data, 'yz\n');
}); }));
}
const file5 = fs.createReadStream(rangeFile, Object.create({bufferSize: 1,
start: 1}));
assert.strictEqual(file5.start, 1);
file5.data = '';
file5.on('data', function(data) {
file5.data += data.toString('utf-8');
});
file5.on('end', function() {
assert.strictEqual(file5.data, 'yz\n');
});
// https://github.com/joyent/node/issues/2320 // https://github.com/joyent/node/issues/2320
const file6 = fs.createReadStream(rangeFile, Object.create({bufferSize: 1.23, {
start: 1})); const options = Object.create({bufferSize: 1.23, start: 1});
assert.strictEqual(file6.start, 1); const file6 = fs.createReadStream(rangeFile, options);
file6.data = ''; assert.strictEqual(file6.start, 1);
file6.on('data', function(data) { file6.data = '';
file6.data += data.toString('utf-8'); file6.on('data', function(data) {
}); file6.data += data.toString('utf-8');
file6.on('end', function() { });
assert.strictEqual(file6.data, 'yz\n'); file6.on('end', common.mustCall(function() {
}); assert.strictEqual(file6.data, 'yz\n');
}));
}
assert.throws(function() { {
fs.createReadStream(rangeFile, Object.create({start: 10, end: 2})); assert.throws(function() {
}, /"start" option must be <= "end" option/); fs.createReadStream(rangeFile, Object.create({start: 10, end: 2}));
}, /"start" option must be <= "end" option/);
}
const stream = fs.createReadStream(rangeFile, Object.create({ start: 0, {
end: 0 })); const options = Object.create({start: 0, end: 0});
assert.strictEqual(stream.start, 0); const stream = fs.createReadStream(rangeFile, options);
assert.strictEqual(stream.end, 0); assert.strictEqual(stream.start, 0);
stream.data = ''; assert.strictEqual(stream.end, 0);
stream.data = '';
stream.on('data', function(chunk) { stream.on('data', function(chunk) {
stream.data += chunk; stream.data += chunk;
}); });
stream.on('end', function() { stream.on('end', common.mustCall(function() {
assert.strictEqual(stream.data, 'x'); assert.strictEqual(stream.data, 'x');
}); }));
}
// pause and then resume immediately. // pause and then resume immediately.
const pauseRes = fs.createReadStream(rangeFile); {
pauseRes.pause(); const pauseRes = fs.createReadStream(rangeFile);
pauseRes.resume(); pauseRes.pause();
pauseRes.resume();
}
let file7 = fs.createReadStream(rangeFile, Object.create({autoClose: false })); {
assert.strictEqual(file7.autoClose, false); let file7 =
file7.on('data', function() {}); fs.createReadStream(rangeFile, Object.create({autoClose: false }));
file7.on('end', function() { assert.strictEqual(file7.autoClose, false);
process.nextTick(function() { file7.on('data', function() {});
assert(!file7.closed); file7.on('end', common.mustCall(function() {
assert(!file7.destroyed); process.nextTick(common.mustCall(function() {
file7Next(); assert(!file7.closed);
}); assert(!file7.destroyed);
}); file7Next();
}));
}));
function file7Next() { function file7Next() {
// This will tell us if the fd is usable again or not. // This will tell us if the fd is usable again or not.
file7 = fs.createReadStream(null, Object.create({fd: file7.fd, start: 0 })); file7 = fs.createReadStream(null, Object.create({fd: file7.fd, start: 0 }));
file7.data = ''; file7.data = '';
file7.on('data', function(data) { file7.on('data', function(data) {
file7.data += data; file7.data += data;
}); });
file7.on('end', function(err) { file7.on('end', common.mustCall(function() {
assert.strictEqual(file7.data, 'xyz\n'); assert.strictEqual(file7.data, 'xyz\n');
}));
}
process.on('exit', function() {
assert(file7.closed);
assert(file7.destroyed);
}); });
} }
// Just to make sure autoClose won't close the stream because of error. // Just to make sure autoClose won't close the stream because of error.
const file8 = fs.createReadStream(null, Object.create({fd: 13337, {
autoClose: false })); const options = Object.create({fd: 13337, autoClose: false});
file8.on('data', function() {}); const file8 = fs.createReadStream(null, options);
file8.on('error', common.mustCall(function() {})); file8.on('data', function() {});
file8.on('error', common.mustCall(function() {}));
process.on('exit', function() {
assert(!file8.closed);
assert(!file8.destroyed);
assert(file8.fd);
});
}
// Make sure stream is destroyed when file does not exist. // Make sure stream is destroyed when file does not exist.
const file9 = fs.createReadStream('/path/to/file/that/does/not/exist'); {
file9.on('data', function() {}); const file9 = fs.createReadStream('/path/to/file/that/does/not/exist');
file9.on('error', common.mustCall(function() {})); file9.on('data', function() {});
file9.on('error', common.mustCall(function() {}));
process.on('exit', function() { process.on('exit', function() {
assert(file7.closed); assert(!file9.closed);
assert(file7.destroyed); assert(file9.destroyed);
});
assert(!file8.closed); }
assert(!file8.destroyed);
assert(file8.fd);
assert(!file9.closed);
assert(file9.destroyed);
});