From caf88695b78946e3695840cd0ff4e4191ba2c731 Mon Sep 17 00:00:00 2001
From: Alex J Burke <alex@alexjeffburke.com>
Date: Thu, 12 May 2016 23:09:13 +0100
Subject: [PATCH] test: add tests for stream3 buffering using cork

adds 2 new tests for streams3 cork behavior, cork then uncork and cork then end

PR-URL: https://github.com/nodejs/node/pull/6493

Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/parallel/test-stream3-cork-end.js    | 91 +++++++++++++++++++++++
 test/parallel/test-stream3-cork-uncork.js | 86 +++++++++++++++++++++
 2 files changed, 177 insertions(+)
 create mode 100644 test/parallel/test-stream3-cork-end.js
 create mode 100644 test/parallel/test-stream3-cork-uncork.js

diff --git a/test/parallel/test-stream3-cork-end.js b/test/parallel/test-stream3-cork-end.js
new file mode 100644
index 00000000000000..a0b611d0da1b66
--- /dev/null
+++ b/test/parallel/test-stream3-cork-end.js
@@ -0,0 +1,91 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const stream = require('stream');
+const Writable = stream.Writable;
+
+// Test the buffering behaviour of Writable streams.
+//
+// The call to cork() triggers storing chunks which are flushed
+// on calling end() and the stream subsequently ended.
+//
+// node version target: 0.12
+
+const expectedChunks = ['please', 'buffer', 'me', 'kindly'];
+var inputChunks = expectedChunks.slice(0);
+var seenChunks = [];
+var seenEnd = false;
+
+var w = new Writable();
+// lets arrange to store the chunks
+w._write = function(chunk, encoding, cb) {
+  // stream end event is not seen before the last write
+  assert.ok(!seenEnd);
+  // default encoding given none was specified
+  assert.equal(encoding, 'buffer');
+
+  seenChunks.push(chunk);
+  cb();
+};
+// lets record the stream end event
+w.on('finish', () => {
+  seenEnd = true;
+});
+
+function writeChunks(remainingChunks, callback) {
+  var writeChunk = remainingChunks.shift();
+  var writeState;
+
+  if (writeChunk) {
+    setImmediate(() => {
+      writeState = w.write(writeChunk);
+      // we were not told to stop writing
+      assert.ok(writeState);
+
+      writeChunks(remainingChunks, callback);
+    });
+  } else {
+    callback();
+  }
+}
+
+// do an initial write
+w.write('stuff');
+// the write was immediate
+assert.equal(seenChunks.length, 1);
+// reset the seen chunks
+seenChunks = [];
+
+// trigger stream buffering
+w.cork();
+
+// write the bufferedChunks
+writeChunks(inputChunks, () => {
+  // should not have seen anything yet
+  assert.equal(seenChunks.length, 0);
+
+  // trigger flush and ending the stream
+  w.end();
+
+  // stream should not ended in current tick
+  assert.ok(!seenEnd);
+
+  // buffered bytes should be seen in current tick
+  assert.equal(seenChunks.length, 4);
+
+  // did the chunks match
+  for (var i = 0, l = expectedChunks.length; i < l; i++) {
+    var seen = seenChunks[i];
+    // there was a chunk
+    assert.ok(seen);
+
+    var expected = new Buffer(expectedChunks[i]);
+    // it was what we expected
+    assert.ok(seen.equals(expected));
+  }
+
+  setImmediate(() => {
+    // stream should have ended in next tick
+    assert.ok(seenEnd);
+  });
+});
diff --git a/test/parallel/test-stream3-cork-uncork.js b/test/parallel/test-stream3-cork-uncork.js
new file mode 100644
index 00000000000000..cd86e8cf809bac
--- /dev/null
+++ b/test/parallel/test-stream3-cork-uncork.js
@@ -0,0 +1,86 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const stream = require('stream');
+const Writable = stream.Writable;
+
+// Test the buffering behaviour of Writable streams.
+//
+// The call to cork() triggers storing chunks which are flushed
+// on calling uncork() in the same tick.
+//
+// node version target: 0.12
+
+const expectedChunks = ['please', 'buffer', 'me', 'kindly'];
+var inputChunks = expectedChunks.slice(0);
+var seenChunks = [];
+var seenEnd = false;
+
+var w = new Writable();
+// lets arrange to store the chunks
+w._write = function(chunk, encoding, cb) {
+  // default encoding given none was specified
+  assert.equal(encoding, 'buffer');
+
+  seenChunks.push(chunk);
+  cb();
+};
+// lets record the stream end event
+w.on('finish', () => {
+  seenEnd = true;
+});
+
+function writeChunks(remainingChunks, callback) {
+  var writeChunk = remainingChunks.shift();
+  var writeState;
+
+  if (writeChunk) {
+    setImmediate(() => {
+      writeState = w.write(writeChunk);
+      // we were not told to stop writing
+      assert.ok(writeState);
+
+      writeChunks(remainingChunks, callback);
+    });
+  } else {
+    callback();
+  }
+}
+
+// do an initial write
+w.write('stuff');
+// the write was immediate
+assert.equal(seenChunks.length, 1);
+// reset the chunks seen so far
+seenChunks = [];
+
+// trigger stream buffering
+w.cork();
+
+// write the bufferedChunks
+writeChunks(inputChunks, () => {
+  // should not have seen anything yet
+  assert.equal(seenChunks.length, 0);
+
+  // trigger writing out the buffer
+  w.uncork();
+
+  // buffered bytes shoud be seen in current tick
+  assert.equal(seenChunks.length, 4);
+
+  // did the chunks match
+  for (var i = 0, l = expectedChunks.length; i < l; i++) {
+    var seen = seenChunks[i];
+    // there was a chunk
+    assert.ok(seen);
+
+    var expected = new Buffer(expectedChunks[i]);
+    // it was what we expected
+    assert.ok(seen.equals(expected));
+  }
+
+  setImmediate(() => {
+    // the stream should not have been ended
+    assert.ok(!seenEnd);
+  });
+});