improved stream mocks for older versions and increased compatabity from 0.8 up

test/unit/buffer_flush_tests.js

@@ -0,0 +1,59 @@
+module.exports = function (makeLogger) {
+  var stub = require('./auto_release_stub').make();
+  var fs = require('fs');
+  var once = require('events').EventEmitter.prototype.once;
+  var _ = require('lodash');
+
+  describe('buffer flush', function () {
+    if (require('stream').Writable) {
+      it('writes everything in the buffer to console.error', function () {
+        var line = 'This string is written 10 times to create buffered output\n';
+
+        var exitHandler;
+        stub(process, 'once', function (event, handler) {
+          if (event === 'exit') {
+            exitHandler = handler;
+          }
+          once.call(process, event, handler);
+        });
+
+        var logger = makeLogger();
+
+        // write the line 10 times
+        _.times(10, function () {
+          logger.onDebug(line);
+        });
+
+        // collect everything that is written to fs.appendFileSync
+        var flushedOutput = '';
+        stub(fs, 'appendFileSync', function (path, str) {
+          flushedOutput += str;
+        });
+
+        // call the event handler
+        exitHandler.call(process);
+
+        // the first line is sent immediately to _write and there is nothing we can do about that
+        flushedOutput.should.match(new RegExp(line));
+        flushedOutput.match(new RegExp(line, 'g')).length.should.eql(9);
+      });
+    } else {
+      it('does not fall apart with non streams2 streams', function () {
+        var exitHandler;
+        stub(process, 'once', function (event, handler) {
+          if (event === 'exit') {
+            exitHandler = handler;
+          }
+          once.call(process, event, handler);
+        });
+
+        var logger = makeLogger();
+
+        (function () {
+          // call the event handler
+          exitHandler.call(process);
+        }).should.not.throw();
+      });
+    }
+  });
+};

test/unit/test_file_logger.js

@@ -1,11 +1,9 @@
 var Log = require('../../src/lib/log');
 var FileLogger = require('../../src/lib/loggers/file');
-var sinon = require('sinon');
 var once = require('events').EventEmitter.prototype.once;
-var write = require('stream').Writable.prototype.write;
-var MockWritableStream = require('../mocks/writable_stream');
 var _ = require('lodash');
 var parentLog;
+var logger;
 var fs = require('fs');
 
 beforeEach(function () {
@@ -14,58 +12,81 @@ beforeEach(function () {
 
 afterEach(function () {
   parentLog.close();
+
+  if (logger
+    && logger.stream
+    && logger.stream._writableState
+    && logger.stream._writableState.buffer.length
+  ) {
+    // empty the buffer manually
+    logger.stream._writableState.buffer.splice(0);
+  }
 });
 
-function makeLogger(parent, levels, path) {
+function makeLogger(parent, levels) {
   parent = parent || parentLog;
-  var config = {
+  logger = new FileLogger(parent, {
     levels: Log.parseLevels(levels || 'trace'),
-    path: path === void 0 ? 'elasticsearch.log' : path
-  };
-  var logger = new FileLogger(parent, config);
-  logger.stream.end();
-
-  logger.stream = new MockWritableStream();
+    path: 'test.log'
+  });
   return logger;
 }
 
 var stub = require('./auto_release_stub').make();
 
 describe('File Logger', function () {
-
   require('./generic_logger_tests')(makeLogger);
 
   describe('buffer flush', function () {
-    it('writes everything in the buffer to console.error', function () {
-      var line = 'This string is writte 10 times to create buffered output.\n';
+    if (require('stream').Writable) {
+      it('writes everything in the buffer to console.error', function () {
+        var line = 'This string is written 10 times to create buffered output\n';
 
-      var exitHandler;
-      stub(process, 'once', function (event, handler) {
-        if (event === 'exit') {
-          exitHandler = handler;
-        }
-        once.call(process, event, handler);
+        var exitHandler;
+        stub(process, 'once', function (event, handler) {
+          if (event === 'exit') {
+            exitHandler = handler;
+          }
+          once.call(process, event, handler);
+        });
+
+        var logger = makeLogger();
+
+        // write the line 10 times
+        _.times(10, function () {
+          logger.onDebug(line);
+        });
+
+        // collect everything that is written to fs.appendFileSync
+        var flushedOutput = '';
+        stub(fs, 'appendFileSync', function (path, str) {
+          flushedOutput += str;
+        });
+
+        // call the event handler
+        exitHandler.call(process);
+
+        // the first line is sent immediately to _write and there is nothing we can do about that
+        flushedOutput.should.match(new RegExp(line));
+        flushedOutput.match(new RegExp(line, 'g')).length.should.eql(9);
       });
+    } else {
+      it('does not fall apart with non streams2 streams', function () {
+        var exitHandler;
+        stub(process, 'once', function (event, handler) {
+          if (event === 'exit') {
+            exitHandler = handler;
+          }
+          once.call(process, event, handler);
+        });
 
-      var logger = makeLogger();
+        var logger = makeLogger();
 
-      // write the line 10 times
-      _.times(10, function () {
-        logger.onDebug(line);
+        (function () {
+          // call the event handler
+          exitHandler.call(process);
+        }).should.not.throw();
       });
-
-      // collect everything that is written to fs.appendFileSync
-      var flushedOutput = '';
-      stub(fs, 'appendFileSync', function (path, str) {
-        flushedOutput += str;
-      });
-
-      // call the event handler
-      exitHandler.call(process);
-
-      // the first line is sent immediately to _write and there is nothing we can do about that
-      flushedOutput.match(new RegExp(line, 'g')).length.should.eql(9);
-    });
+    }
   });
-
 });

test/unit/test_http_connector.js

@@ -38,28 +38,6 @@ describe('Http Connector', function () {
     };
   }
 
-  function whichMocksMessage(prep) {
-    return function (req, params, cb) {
-      process.nextTick(function () {
-        var incom = new MockIncommingMessage();
-        if (prep) {
-          prep(incom);
-        }
-        cb(incom);
-      });
-    };
-  }
-
-  function whichErrorsAfterPartialBody(err) {
-    return function (incom) {
-      incom.statusCode = 200;
-      incom.push('{ "hits": { "hits": { "hits": { "hits": { "hits": { "hits": ');
-      setTimeout(function () {
-        incom.emit('error', err || new Error('Socket is dead now...'));
-      }, 20);
-    };
-  }
-
   describe('Constructor', function () {
     it('creates an object that extends ConnectionAbstract', function () {
       var con = new HttpConnection(new Host());
@@ -259,7 +237,17 @@ describe('Http Connector', function () {
 
   describe('#request with incomming message error', function () {
     function makeStubReqWithMsgWhichErrorsMidBody(err) {
-      return makeStubReqMethod(whichMocksMessage(whichErrorsAfterPartialBody(err)));
+      return makeStubReqMethod(function (req, params, cb) {
+        process.nextTick(function () {
+          var incom = new MockIncommingMessage();
+          incom.statusCode = 200;
+          setTimeout(function () {
+            incom.emit('data', '{ "not json"');
+            incom.emit('error', err || new Error('Socket is dead now...'));
+          }, 20);
+          cb(incom);
+        });
+      });
     }
 
     it('logs error event', function (done) {

test/unit/test_stream_logger.js

@@ -1,27 +1,27 @@
 var Log = require('../../src/lib/log');
 var StreamLogger = require('../../src/lib/loggers/stream');
 var MockWritableStream = require('../mocks/writable_stream');
-var MockOldWritableStream = require('../mocks/old_writable_stream');
 var once = require('events').EventEmitter.prototype.once;
 var stream = new MockWritableStream();
 var _ = require('lodash');
-var util = require('util');
 var parentLog;
 
 var stub = require('./auto_release_stub').make();
 
 beforeEach(function () {
-  parentLog = new Log();
-  if (stream._writableState.buffer.length) {
-    // empty the buffer manually
-    stream._writableState.buffer.splice(0);
-  }
   stub(stream, 'write');
   stub(stream, 'end');
+
+  parentLog = new Log();
 });
 
 afterEach(function () {
   parentLog.close();
+
+  if (stream._writableState && stream._writableState.buffer.length) {
+    // empty the buffer manually
+    stream._writableState.buffer.splice(0);
+  }
 });
 
 function makeLogger(parent, levels) {
@@ -34,41 +34,60 @@ function makeLogger(parent, levels) {
 }
 
 describe('Stream Logger', function () {
-  describe('buffer flushing', function () {
-    it('writes everything in the buffer to console.error', function () {
-      var logger = makeLogger();
-      var line = 'This string is writte 10 times to create buffered output.\n';
-
-      // get the last handler for process's "exit" event
-      var exitHandlers = process._events.exit;
-      var exitHandler = _.isArray(exitHandlers) ? _.last(exitHandlers) : exitHandlers;
-
-      // allow the logger to acctually write to the stream
-      stream.write.restore();
-
-      // write the line 10 times
-      _.times(10, function () {
-        logger.onDebug(line);
-      });
-
-      // collect everything that is written to console.error
-      var flushedOutput = '';
-      stub(console, 'error', function (str) {
-        flushedOutput += str;
-      });
-
-      // call the event handler
-      exitHandler.call(process);
-
-      // restore console.error asap.
-      console.error.restore();
-
-      // the first line is sent immediately to _write and there is nothing we are not going to worry about it
-      flushedOutput.match(new RegExp(line, 'g')).length.should.eql(9);
-    });
-  });
-
-
   require('./generic_logger_tests')(makeLogger);
 
+  describe('buffer flush', function () {
+    if (require('stream').Writable) {
+      it('writes everything in the buffer to console.error', function () {
+        var logger = makeLogger();
+        var line = 'This string is written 10 times to create buffered output\n';
+
+        // get the last handler for process's "exit" event
+        var exitHandlers = process._events.exit;
+        var exitHandler = _.isArray(exitHandlers) ? _.last(exitHandlers) : exitHandlers;
+
+        // allow the logger to acctually write to the stream
+        stream.write.restore();
+
+        // write the line 10 times
+        _.times(10, function () {
+          logger.onDebug(line);
+        });
+
+        // collect everything that is written to console.error
+        var flushedOutput = '';
+        stub(console, 'error', function (str) {
+          flushedOutput += str;
+        });
+
+        // call the event handler
+        exitHandler.call(process);
+
+        // restore console.error asap.
+        console.error.restore();
+
+        // the first line is sent immediately to _write and there is nothing we are not going to worry about it
+        flushedOutput.should.match(new RegExp(line));
+        flushedOutput.match(new RegExp(line, 'g')).length.should.eql(9);
+      });
+    } else {
+      it('does not fall apart with non streams2 streams', function () {
+        var exitHandler;
+        stub(process, 'once', function (event, handler) {
+          if (event === 'exit') {
+            exitHandler = handler;
+          }
+          once.call(process, event, handler);
+        });
+
+        var logger = makeLogger();
+
+        (function () {
+          // call the event handler
+          exitHandler.call(process);
+        }).should.not.throw();
+      });
+    }
+  });
+
 });

test/unit/test_utils.js

@@ -385,19 +385,20 @@ describe('Utils', function () {
       should.not.exist(_.getUnwrittenFromStream({}));
     });
 
-    var MockWritableStream = require('../mocks/writable_stream');
+    if (require('stream').Writable) {
+      var MockWritableStream = require('../mocks/writable_stream');
+      it('ignores empty stream', function () {
+        var stream = new MockWritableStream();
+        _.getUnwrittenFromStream(stream).should.be.exactly('');
+      });
 
-    it('ignores empty stream', function () {
-      var stream = new MockWritableStream();
-      _.getUnwrittenFromStream(stream).should.be.exactly('');
-    });
-
-    it('returns only what is in the buffer', function () {
-      var stream = new MockWritableStream();
-      stream.write('hot');
-      stream.write('dog');
-      _.getUnwrittenFromStream(stream).should.be.exactly('dog');
-    });
+      it('returns only what is in the buffer', function () {
+        var stream = new MockWritableStream();
+        stream.write('hot');
+        stream.write('dog');
+        _.getUnwrittenFromStream(stream).should.be.exactly('dog');
+      });
+    }
   });
 
 });