--- /dev/null
+var fdSlicer = require('../');
+var fs = require('fs');
+var crypto = require('crypto');
+var path = require('path');
+var streamEqual = require('stream-equal');
+var assert = require('assert');
+var Pend = require('pend');
+var StreamSink = require('streamsink');
+
+var describe = global.describe;
+var it = global.it;
+var before = global.before;
+var beforeEach = global.beforeEach;
+var after = global.after;
+
+var testBlobFile = path.join(__dirname, "test-blob.bin");
+var testBlobFileSize = 20 * 1024 * 1024;
+var testOutBlobFile = path.join(__dirname, "test-blob-out.bin");
+
+describe("FdSlicer", function() {
+ before(function(done) {
+ var out = fs.createWriteStream(testBlobFile);
+ for (var i = 0; i < testBlobFileSize / 1024; i += 1) {
+ out.write(crypto.pseudoRandomBytes(1024));
+ }
+ out.end();
+ out.on('close', done);
+ });
+ beforeEach(function() {
+ try {
+ fs.unlinkSync(testOutBlobFile);
+ } catch (err) {
+ }
+ });
+ after(function() {
+ try {
+ fs.unlinkSync(testBlobFile);
+ fs.unlinkSync(testOutBlobFile);
+ } catch (err) {
+ }
+ });
+ it("reads a 20MB file (autoClose on)", function(done) {
+ fs.open(testBlobFile, 'r', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ var actualStream = slicer.createReadStream();
+ var expectedStream = fs.createReadStream(testBlobFile);
+
+ var pend = new Pend();
+ pend.go(function(cb) {
+ slicer.on('close', cb);
+ });
+ pend.go(function(cb) {
+ streamEqual(expectedStream, actualStream, function(err, equal) {
+ if (err) return done(err);
+ assert.ok(equal);
+ cb();
+ });
+ });
+ pend.wait(done);
+ });
+ });
+ it("reads 4 chunks simultaneously", function(done) {
+ fs.open(testBlobFile, 'r', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd);
+ var actualPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
+ var actualPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
+ var actualPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
+ var actualPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
+ var expectedPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
+ var expectedPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
+ var expectedPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
+ var expectedPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
+ var pend = new Pend();
+ pend.go(function(cb) {
+ streamEqual(expectedPart1, actualPart1, function(err, equal) {
+ assert.ok(equal);
+ cb(err);
+ });
+ });
+ pend.go(function(cb) {
+ streamEqual(expectedPart2, actualPart2, function(err, equal) {
+ assert.ok(equal);
+ cb(err);
+ });
+ });
+ pend.go(function(cb) {
+ streamEqual(expectedPart3, actualPart3, function(err, equal) {
+ assert.ok(equal);
+ cb(err);
+ });
+ });
+ pend.go(function(cb) {
+ streamEqual(expectedPart4, actualPart4, function(err, equal) {
+ assert.ok(equal);
+ cb(err);
+ });
+ });
+ pend.wait(function(err) {
+ if (err) return done(err);
+ fs.close(fd, done);
+ });
+ });
+ });
+
+ it("writes a 20MB file (autoClose on)", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ var actualStream = slicer.createWriteStream();
+ var inStream = fs.createReadStream(testBlobFile);
+
+ slicer.on('close', function() {
+ var expected = fs.createReadStream(testBlobFile);
+ var actual = fs.createReadStream(testOutBlobFile);
+
+ streamEqual(expected, actual, function(err, equal) {
+ if (err) return done(err);
+ assert.ok(equal);
+ done();
+ });
+ });
+ inStream.pipe(actualStream);
+ });
+ });
+
+ it("writes 4 chunks simultaneously", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd);
+ var actualPart1 = slicer.createWriteStream({start: testBlobFileSize * 0/4});
+ var actualPart2 = slicer.createWriteStream({start: testBlobFileSize * 1/4});
+ var actualPart3 = slicer.createWriteStream({start: testBlobFileSize * 2/4});
+ var actualPart4 = slicer.createWriteStream({start: testBlobFileSize * 3/4});
+ var in1 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
+ var in2 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
+ var in3 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
+ var in4 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
+ var pend = new Pend();
+ pend.go(function(cb) {
+ actualPart1.on('finish', cb);
+ });
+ pend.go(function(cb) {
+ actualPart2.on('finish', cb);
+ });
+ pend.go(function(cb) {
+ actualPart3.on('finish', cb);
+ });
+ pend.go(function(cb) {
+ actualPart4.on('finish', cb);
+ });
+ in1.pipe(actualPart1);
+ in2.pipe(actualPart2);
+ in3.pipe(actualPart3);
+ in4.pipe(actualPart4);
+ pend.wait(function() {
+ fs.close(fd, function(err) {
+ if (err) return done(err);
+ var expected = fs.createReadStream(testBlobFile);
+ var actual = fs.createReadStream(testOutBlobFile);
+ streamEqual(expected, actual, function(err, equal) {
+ if (err) return done(err);
+ assert.ok(equal);
+ done();
+ });
+ });
+ });
+ });
+ });
+
+ it("throws on invalid ref", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ assert.throws(function() {
+ slicer.unref();
+ }, /invalid unref/);
+ fs.close(fd, done);
+ });
+ });
+
+ it("write stream emits error when max size exceeded", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ var ws = slicer.createWriteStream({start: 0, end: 1000});
+ ws.on('error', function(err) {
+ assert.strictEqual(err.code, 'ETOOBIG');
+ slicer.on('close', done);
+ });
+ ws.end(new Buffer(1001));
+ });
+ });
+
+ it("write stream does not emit error when max size not exceeded", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ var ws = slicer.createWriteStream({end: 1000});
+ slicer.on('close', done);
+ ws.end(new Buffer(1000));
+ });
+ });
+
+ it("write stream start and end work together", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ var ws = slicer.createWriteStream({start: 1, end: 1000});
+ ws.on('error', function(err) {
+ assert.strictEqual(err.code, 'ETOOBIG');
+ slicer.on('close', done);
+ });
+ ws.end(new Buffer(1000));
+ });
+ });
+
+ it("write stream emits progress events", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ var ws = slicer.createWriteStream();
+ var progressEventCount = 0;
+ var prevBytesWritten = 0;
+ ws.on('progress', function() {
+ progressEventCount += 1;
+ assert.ok(ws.bytesWritten > prevBytesWritten);
+ prevBytesWritten = ws.bytesWritten;
+ });
+ slicer.on('close', function() {
+ assert.ok(progressEventCount > 5);
+ done();
+ });
+ for (var i = 0; i < 10; i += 1) {
+ ws.write(new Buffer(16 * 1024 * 2));
+ }
+ ws.end();
+ });
+ });
+
+ it("write stream unrefs when destroyed", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ var ws = slicer.createWriteStream();
+ slicer.on('close', done);
+ ws.write(new Buffer(1000));
+ ws.destroy();
+ });
+ });
+
+ it("read stream unrefs when destroyed", function(done) {
+ fs.open(testBlobFile, 'r', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+ var rs = slicer.createReadStream();
+ rs.on('error', function(err) {
+ assert.strictEqual(err.message, "stream destroyed");
+ slicer.on('close', done);
+ });
+ rs.destroy();
+ });
+ });
+
+ it("fdSlicer.read", function(done) {
+ fs.open(testBlobFile, 'r', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd);
+ var outBuf = new Buffer(1024);
+ slicer.read(outBuf, 0, 10, 0, function(err, bytesRead, buf) {
+ assert.strictEqual(bytesRead, 10);
+ fs.close(fd, done);
+ });
+ });
+ });
+
+ it("fdSlicer.write", function(done) {
+ fs.open(testOutBlobFile, 'w', function(err, fd) {
+ if (err) return done(err);
+ var slicer = fdSlicer.createFromFd(fd);
+ slicer.write(new Buffer("blah\n"), 0, 5, 0, function() {
+ if (err) return done(err);
+ fs.close(fd, done);
+ });
+ });
+ });
+});
+
+describe("BufferSlicer", function() {
+ it("invalid ref", function() {
+ var slicer = fdSlicer.createFromBuffer(new Buffer(16));
+ slicer.ref();
+ slicer.unref();
+ assert.throws(function() {
+ slicer.unref();
+ }, /invalid unref/);
+ });
+ it("read and write", function(done) {
+ var buf = new Buffer("through the tangled thread the needle finds its way");
+ var slicer = fdSlicer.createFromBuffer(buf);
+ var outBuf = new Buffer(1024);
+ slicer.read(outBuf, 10, 11, 8, function(err) {
+ if (err) return done(err);
+ assert.strictEqual(outBuf.toString('utf8', 10, 21), "the tangled");
+ slicer.write(new Buffer("derp"), 0, 4, 7, function(err) {
+ if (err) return done(err);
+ assert.strictEqual(buf.toString('utf8', 7, 19), "derp tangled");
+ done();
+ });
+ });
+ });
+ it("createReadStream", function(done) {
+ var str = "I never conquered rarely came, 16 just held such better days";
+ var buf = new Buffer(str);
+ var slicer = fdSlicer.createFromBuffer(buf);
+ var inStream = slicer.createReadStream();
+ var sink = new StreamSink();
+ inStream.pipe(sink);
+ sink.on('finish', function() {
+ assert.strictEqual(sink.toString(), str);
+ inStream.destroy();
+ done();
+ });
+ });
+ it("createWriteStream exceed buffer size", function(done) {
+ var slicer = fdSlicer.createFromBuffer(new Buffer(4));
+ var outStream = slicer.createWriteStream();
+ outStream.on('error', function(err) {
+ assert.strictEqual(err.code, 'ETOOBIG');
+ done();
+ });
+ outStream.write("hi!\n");
+ outStream.write("it warked\n");
+ outStream.end();
+ });
+ it("createWriteStream ok", function(done) {
+ var buf = new Buffer(1024);
+ var slicer = fdSlicer.createFromBuffer(buf);
+ var outStream = slicer.createWriteStream();
+ outStream.on('finish', function() {
+ assert.strictEqual(buf.toString('utf8', 0, "hi!\nit warked\n".length), "hi!\nit warked\n");
+ outStream.destroy();
+ done();
+ });
+ outStream.write("hi!\n");
+ outStream.write("it warked\n");
+ outStream.end();
+ });
+});
projects / yaffs-website / blobdiff