www.aleph1.co.uk Git - yaffs-website/blob - node_modules/fd-slicer/test/test.js

   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');
   9
  10 var describe = global.describe;
  11 var it = global.it;
  12 var before = global.before;
  13 var beforeEach = global.beforeEach;
  14 var after = global.after;
  15
  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");
  19
  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));
  25     }
  26     out.end();
  27     out.on('close', done);
  28   });
  29   beforeEach(function() {
  30     try {
  31       fs.unlinkSync(testOutBlobFile);
  32     } catch (err) {
  33     }
  34   });
  35   after(function() {
  36     try {
  37       fs.unlinkSync(testBlobFile);
  38       fs.unlinkSync(testOutBlobFile);
  39     } catch (err) {
  40     }
  41   });
  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);
  48
  49       var pend = new Pend();
  50       pend.go(function(cb) {
  51         slicer.on('close', cb);
  52       });
  53       pend.go(function(cb) {
  54         streamEqual(expectedStream, actualStream, function(err, equal) {
  55           if (err) return done(err);
  56           assert.ok(equal);
  57           cb();
  58         });
  59       });
  60       pend.wait(done);
  61     });
  62   });
  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) {
  78           assert.ok(equal);
  79           cb(err);
  80         });
  81       });
  82       pend.go(function(cb) {
  83         streamEqual(expectedPart2, actualPart2, function(err, equal) {
  84           assert.ok(equal);
  85           cb(err);
  86         });
  87       });
  88       pend.go(function(cb) {
  89         streamEqual(expectedPart3, actualPart3, function(err, equal) {
  90           assert.ok(equal);
  91           cb(err);
  92         });
  93       });
  94       pend.go(function(cb) {
  95         streamEqual(expectedPart4, actualPart4, function(err, equal) {
  96           assert.ok(equal);
  97           cb(err);
  98         });
  99       });
 100       pend.wait(function(err) {
 101         if (err) return done(err);
 102         fs.close(fd, done);
 103       });
 104     });
 105   });
 106
 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);
 113
 114       slicer.on('close', function() {
 115         var expected = fs.createReadStream(testBlobFile);
 116         var actual = fs.createReadStream(testOutBlobFile);
 117
 118         streamEqual(expected, actual, function(err, equal) {
 119           if (err) return done(err);
 120           assert.ok(equal);
 121           done();
 122         });
 123       });
 124       inStream.pipe(actualStream);
 125     });
 126   });
 127
 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);
 143       });
 144       pend.go(function(cb) {
 145         actualPart2.on('finish', cb);
 146       });
 147       pend.go(function(cb) {
 148         actualPart3.on('finish', cb);
 149       });
 150       pend.go(function(cb) {
 151         actualPart4.on('finish', cb);
 152       });
 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);
 164             assert.ok(equal);
 165             done();
 166           });
 167         });
 168       });
 169     });
 170   });
 171
 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() {
 177         slicer.unref();
 178       }, /invalid unref/);
 179       fs.close(fd, done);
 180     });
 181   });
 182
 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);
 191       });
 192       ws.end(new Buffer(1001));
 193     });
 194   });
 195
 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));
 203     });
 204   });
 205
 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);
 214       });
 215       ws.end(new Buffer(1000));
 216     });
 217   });
 218
 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;
 230       });
 231       slicer.on('close', function() {
 232         assert.ok(progressEventCount > 5);
 233         done();
 234       });
 235       for (var i = 0; i < 10; i += 1) {
 236         ws.write(new Buffer(16 * 1024 * 2));
 237       }
 238       ws.end();
 239     });
 240   });
 241
 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));
 249       ws.destroy();
 250     });
 251   });
 252
 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);
 261       });
 262       rs.destroy();
 263     });
 264   });
 265
 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);
 273         fs.close(fd, done);
 274       });
 275     });
 276   });
 277
 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);
 284         fs.close(fd, done);
 285       });
 286     });
 287   });
 288 });
 289
 290 describe("BufferSlicer", function() {
 291   it("invalid ref", function() {
 292     var slicer = fdSlicer.createFromBuffer(new Buffer(16));
 293     slicer.ref();
 294     slicer.unref();
 295     assert.throws(function() {
 296       slicer.unref();
 297     }, /invalid unref/);
 298   });
 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");
 309         done();
 310       });
 311     });
 312   });
 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();
 319     inStream.pipe(sink);
 320     sink.on('finish', function() {
 321       assert.strictEqual(sink.toString(), str);
 322       inStream.destroy();
 323       done();
 324     });
 325   });
 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');
 331       done();
 332     });
 333     outStream.write("hi!\n");
 334     outStream.write("it warked\n");
 335     outStream.end();
 336   });
 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");
 343       outStream.destroy();
 344       done();
 345     });
 346     outStream.write("hi!\n");
 347     outStream.write("it warked\n");
 348     outStream.end();
 349   });
 350 });