1 var fdSlicer = require('../');
2 var fs = require('fs');
3 var crypto = require('crypto');
4 var path = require('path');
5 var streamEqual = require('stream-equal');
6 var assert = require('assert');
7 var Pend = require('pend');
8 var StreamSink = require('streamsink');
10 var describe = global.describe;
12 var before = global.before;
13 var beforeEach = global.beforeEach;
14 var after = global.after;
16 var testBlobFile = path.join(__dirname, "test-blob.bin");
17 var testBlobFileSize = 20 * 1024 * 1024;
18 var testOutBlobFile = path.join(__dirname, "test-blob-out.bin");
20 describe("FdSlicer", function() {
21 before(function(done) {
22 var out = fs.createWriteStream(testBlobFile);
23 for (var i = 0; i < testBlobFileSize / 1024; i += 1) {
24 out.write(crypto.pseudoRandomBytes(1024));
27 out.on('close', done);
29 beforeEach(function() {
31 fs.unlinkSync(testOutBlobFile);
37 fs.unlinkSync(testBlobFile);
38 fs.unlinkSync(testOutBlobFile);
42 it("reads a 20MB file (autoClose on)", function(done) {
43 fs.open(testBlobFile, 'r', function(err, fd) {
44 if (err) return done(err);
45 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
46 var actualStream = slicer.createReadStream();
47 var expectedStream = fs.createReadStream(testBlobFile);
49 var pend = new Pend();
50 pend.go(function(cb) {
51 slicer.on('close', cb);
53 pend.go(function(cb) {
54 streamEqual(expectedStream, actualStream, function(err, equal) {
55 if (err) return done(err);
63 it("reads 4 chunks simultaneously", function(done) {
64 fs.open(testBlobFile, 'r', function(err, fd) {
65 if (err) return done(err);
66 var slicer = fdSlicer.createFromFd(fd);
67 var actualPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
68 var actualPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
69 var actualPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
70 var actualPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
71 var expectedPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
72 var expectedPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
73 var expectedPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
74 var expectedPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
75 var pend = new Pend();
76 pend.go(function(cb) {
77 streamEqual(expectedPart1, actualPart1, function(err, equal) {
82 pend.go(function(cb) {
83 streamEqual(expectedPart2, actualPart2, function(err, equal) {
88 pend.go(function(cb) {
89 streamEqual(expectedPart3, actualPart3, function(err, equal) {
94 pend.go(function(cb) {
95 streamEqual(expectedPart4, actualPart4, function(err, equal) {
100 pend.wait(function(err) {
101 if (err) return done(err);
107 it("writes a 20MB file (autoClose on)", function(done) {
108 fs.open(testOutBlobFile, 'w', function(err, fd) {
109 if (err) return done(err);
110 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
111 var actualStream = slicer.createWriteStream();
112 var inStream = fs.createReadStream(testBlobFile);
114 slicer.on('close', function() {
115 var expected = fs.createReadStream(testBlobFile);
116 var actual = fs.createReadStream(testOutBlobFile);
118 streamEqual(expected, actual, function(err, equal) {
119 if (err) return done(err);
124 inStream.pipe(actualStream);
128 it("writes 4 chunks simultaneously", function(done) {
129 fs.open(testOutBlobFile, 'w', function(err, fd) {
130 if (err) return done(err);
131 var slicer = fdSlicer.createFromFd(fd);
132 var actualPart1 = slicer.createWriteStream({start: testBlobFileSize * 0/4});
133 var actualPart2 = slicer.createWriteStream({start: testBlobFileSize * 1/4});
134 var actualPart3 = slicer.createWriteStream({start: testBlobFileSize * 2/4});
135 var actualPart4 = slicer.createWriteStream({start: testBlobFileSize * 3/4});
136 var in1 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
137 var in2 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
138 var in3 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
139 var in4 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
140 var pend = new Pend();
141 pend.go(function(cb) {
142 actualPart1.on('finish', cb);
144 pend.go(function(cb) {
145 actualPart2.on('finish', cb);
147 pend.go(function(cb) {
148 actualPart3.on('finish', cb);
150 pend.go(function(cb) {
151 actualPart4.on('finish', cb);
153 in1.pipe(actualPart1);
154 in2.pipe(actualPart2);
155 in3.pipe(actualPart3);
156 in4.pipe(actualPart4);
157 pend.wait(function() {
158 fs.close(fd, function(err) {
159 if (err) return done(err);
160 var expected = fs.createReadStream(testBlobFile);
161 var actual = fs.createReadStream(testOutBlobFile);
162 streamEqual(expected, actual, function(err, equal) {
163 if (err) return done(err);
172 it("throws on invalid ref", function(done) {
173 fs.open(testOutBlobFile, 'w', function(err, fd) {
174 if (err) return done(err);
175 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
176 assert.throws(function() {
183 it("write stream emits error when max size exceeded", function(done) {
184 fs.open(testOutBlobFile, 'w', function(err, fd) {
185 if (err) return done(err);
186 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
187 var ws = slicer.createWriteStream({start: 0, end: 1000});
188 ws.on('error', function(err) {
189 assert.strictEqual(err.code, 'ETOOBIG');
190 slicer.on('close', done);
192 ws.end(new Buffer(1001));
196 it("write stream does not emit error when max size not exceeded", function(done) {
197 fs.open(testOutBlobFile, 'w', function(err, fd) {
198 if (err) return done(err);
199 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
200 var ws = slicer.createWriteStream({end: 1000});
201 slicer.on('close', done);
202 ws.end(new Buffer(1000));
206 it("write stream start and end work together", function(done) {
207 fs.open(testOutBlobFile, 'w', function(err, fd) {
208 if (err) return done(err);
209 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
210 var ws = slicer.createWriteStream({start: 1, end: 1000});
211 ws.on('error', function(err) {
212 assert.strictEqual(err.code, 'ETOOBIG');
213 slicer.on('close', done);
215 ws.end(new Buffer(1000));
219 it("write stream emits progress events", function(done) {
220 fs.open(testOutBlobFile, 'w', function(err, fd) {
221 if (err) return done(err);
222 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
223 var ws = slicer.createWriteStream();
224 var progressEventCount = 0;
225 var prevBytesWritten = 0;
226 ws.on('progress', function() {
227 progressEventCount += 1;
228 assert.ok(ws.bytesWritten > prevBytesWritten);
229 prevBytesWritten = ws.bytesWritten;
231 slicer.on('close', function() {
232 assert.ok(progressEventCount > 5);
235 for (var i = 0; i < 10; i += 1) {
236 ws.write(new Buffer(16 * 1024 * 2));
242 it("write stream unrefs when destroyed", function(done) {
243 fs.open(testOutBlobFile, 'w', function(err, fd) {
244 if (err) return done(err);
245 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
246 var ws = slicer.createWriteStream();
247 slicer.on('close', done);
248 ws.write(new Buffer(1000));
253 it("read stream unrefs when destroyed", function(done) {
254 fs.open(testBlobFile, 'r', function(err, fd) {
255 if (err) return done(err);
256 var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
257 var rs = slicer.createReadStream();
258 rs.on('error', function(err) {
259 assert.strictEqual(err.message, "stream destroyed");
260 slicer.on('close', done);
266 it("fdSlicer.read", function(done) {
267 fs.open(testBlobFile, 'r', function(err, fd) {
268 if (err) return done(err);
269 var slicer = fdSlicer.createFromFd(fd);
270 var outBuf = new Buffer(1024);
271 slicer.read(outBuf, 0, 10, 0, function(err, bytesRead, buf) {
272 assert.strictEqual(bytesRead, 10);
278 it("fdSlicer.write", function(done) {
279 fs.open(testOutBlobFile, 'w', function(err, fd) {
280 if (err) return done(err);
281 var slicer = fdSlicer.createFromFd(fd);
282 slicer.write(new Buffer("blah\n"), 0, 5, 0, function() {
283 if (err) return done(err);
290 describe("BufferSlicer", function() {
291 it("invalid ref", function() {
292 var slicer = fdSlicer.createFromBuffer(new Buffer(16));
295 assert.throws(function() {
299 it("read and write", function(done) {
300 var buf = new Buffer("through the tangled thread the needle finds its way");
301 var slicer = fdSlicer.createFromBuffer(buf);
302 var outBuf = new Buffer(1024);
303 slicer.read(outBuf, 10, 11, 8, function(err) {
304 if (err) return done(err);
305 assert.strictEqual(outBuf.toString('utf8', 10, 21), "the tangled");
306 slicer.write(new Buffer("derp"), 0, 4, 7, function(err) {
307 if (err) return done(err);
308 assert.strictEqual(buf.toString('utf8', 7, 19), "derp tangled");
313 it("createReadStream", function(done) {
314 var str = "I never conquered rarely came, 16 just held such better days";
315 var buf = new Buffer(str);
316 var slicer = fdSlicer.createFromBuffer(buf);
317 var inStream = slicer.createReadStream();
318 var sink = new StreamSink();
320 sink.on('finish', function() {
321 assert.strictEqual(sink.toString(), str);
326 it("createWriteStream exceed buffer size", function(done) {
327 var slicer = fdSlicer.createFromBuffer(new Buffer(4));
328 var outStream = slicer.createWriteStream();
329 outStream.on('error', function(err) {
330 assert.strictEqual(err.code, 'ETOOBIG');
333 outStream.write("hi!\n");
334 outStream.write("it warked\n");
337 it("createWriteStream ok", function(done) {
338 var buf = new Buffer(1024);
339 var slicer = fdSlicer.createFromBuffer(buf);
340 var outStream = slicer.createWriteStream();
341 outStream.on('finish', function() {
342 assert.strictEqual(buf.toString('utf8', 0, "hi!\nit warked\n".length), "hi!\nit warked\n");
346 outStream.write("hi!\n");
347 outStream.write("it warked\n");