Fill coverage holes

grunt/config/mochacov.js

@@ -5,28 +5,30 @@ module.exports = {
   options: {
     require: ['should']
   },
-  coverage: {
-    src: unitTests,
-    options: {
-      reporter: 'mocha-lcov-reporter',
-      coveralls: {
-        serviceName: 'travis-ci',
-        repoToken: process.env.ESJS_COVERALS_REPO_TOKEN
-      }
-    }
-  },
   unit: {
     src: unitTests
   },
   integration: {
     src: integrationTests
   },
-  make_html_unit_cov: {
+
+  // run the unit tests, and update coverage.html
+  make_coverage_html: {
     src: unitTests,
     options: {
       reporter: 'html-cov',
       output: 'coverage.html'
     }
   },
 
+  // for use by travis
+  ship_coverage: {
+    src: unitTests,
+    options: {
+      reporter: 'mocha-lcov-reporter',
+      coveralls: {
+        serviceName: 'travis-ci'
+      }
+    }
+  }
 };

grunt/config/open.js

@@ -0,0 +1,6 @@
+module.exports = {
+  coverage: {
+    path: 'coverage.html',
+    app: 'Google Chrome'
+  }
+};

grunt/config/watch.js

@@ -2,16 +2,16 @@ module.exports = {
   source: {
     files: [
       'src/**/*.js',
-      'test/unit/**/*.js',
       'grunt/**/*.js',
+      'test/unit/**/*.js',
       'Gruntfile.js'
     ],
     tasks: [
       'jshint',
-      'run:unit_tests'
+      'mochacov:unit'
     ],
     options: {
-      interrupt: true,
+      interrupt: true
     }
   }
 };

grunt/tasks.js

@@ -2,7 +2,6 @@ module.exports = function (grunt) {
 
   // Default task runs the build process.
   grunt.registerTask('default', [
-    'generate',
     'test'
   ]);
 
@@ -13,17 +12,17 @@ module.exports = function (grunt) {
   grunt.registerTask('test', [
     'jshint',
     'mochacov:unit',
-    'run:generate',
+    'generate',
     'mochacov:integration',
   ]);
 
   grunt.registerTask('coverage', [
-    'mochacov:make_html_unit_cov',
-    'open:html_unit_cov'
+    'mochacov:make_coverage_html',
+    'open:coverage'
   ]);
 
   grunt.registerTask('travis', [
     'test',
-    'mochacov:coverage'
+    'mochacov:ship_coverage'
   ]);
 };

package.json

@@ -43,7 +43,8 @@
     "grunt-contrib-compress": "~0.5.3",
     "grunt-contrib-copy": "~0.4.1",
     "grunt-prompt": "~0.1.2",
-    "grunt-mocha-cov": "~0.1.1"
+    "grunt-mocha-cov": "~0.1.1",
+    "grunt-open": "~0.2.2"
   },
   "license": "Apache 2.0",
   "dependencies": {
@@ -58,7 +59,6 @@
   },
   "scripts": {
     "test": "grunt test",
-    "coverage": "mocha test/unit/test_*.js --require blanket -R html-cov > coverage.html && open -a \"Google Chrome\" ./coverage.html",
     "blanket": {
       "pattern": "src"
     }

test/unit/test_client.js

@@ -17,6 +17,12 @@ describe('Client instances creation', function () {
     }).should.throw(/previous "elasticsearch" module/);
   });
 
+  it('Succeeds even not called with new', function () {
+    var client = es.Client();
+    client.bulk.should.eql(api.bulk);
+    client.cluster.nodeStats.should.eql(api.cluster.prototype.nodeStats);
+  });
+
   it('inherits the api', function () {
     client.bulk.should.eql(api.bulk);
     client.cluster.nodeStats.should.eql(api.cluster.prototype.nodeStats);

test/unit/test_connection_abstract.js

@@ -1,7 +1,9 @@
 var ConnectionAbstract = require('../../src/lib/connection');
 var Host = require('../../src/lib/host');
 var sinon = require('sinon');
+var should = require('should');
 var _ = require('lodash');
+var errors = require('../../src/lib/errors');
 
 var stub = require('./auto_release_stub').make();
 
@@ -72,8 +74,62 @@ describe('Connection Abstract', function () {
       conn.request.callCount.should.eql(1);
     });
 
-    it('sets a timer for the request');
-    it('aborts the request if it takes too long');
+    it('sets a timer for the request', function (done) {
+      var conn = new ConnectionAbstract(host);
+      var clock = sinon.useFakeTimers('setTimeout', 'clearTimeout');
+      var order = 0;
+
+      stub(conn, 'request', function (params, cb) {
+        setTimeout(function () {
+          should(++order).eql(2);
+          cb();
+        }, 10001);
+      });
+
+      conn.ping({
+        requestTimeout: 100
+      }, function (err) {
+        should(++order).eql(1);
+        err.should.be.an.instanceOf(errors.RequestTimeout);
+      });
+
+      process.nextTick(function () {
+        clock.tick(1000);
+        clock.tick(10000);
+        clock.restore();
+        done();
+      });
+    });
+    it('calls the requestAborter if req takes too long', function (done) {
+      var conn = new ConnectionAbstract(host);
+      var clock = sinon.useFakeTimers('setTimeout', 'clearTimeout');
+      var order = 0;
+
+      stub(conn, 'request', function (params, cb) {
+        setTimeout(function () {
+          should(++order).eql(3);
+          cb();
+        }, 10001);
+
+        return function () {
+          should(++order).eql(1);
+        };
+      });
+
+      conn.ping({
+        requestTimeout: 100
+      }, function (err) {
+        should(++order).eql(2);
+        err.should.be.an.instanceOf(errors.RequestTimeout);
+      });
+
+      process.nextTick(function () {
+        clock.tick(1000);
+        clock.tick(10000);
+        clock.restore();
+        done();
+      });
+    });
     it('ignores the response from the request if it already aborted');
   });
 

test/unit/test_connection_pool.js

@@ -1,10 +1,12 @@
 var ConnectionPool = require('../../src/lib/connection_pool');
 var Host = require('../../src/lib/host');
+var errors = require('../../src/lib/errors');
 var ConnectionAbstract = require('../../src/lib/connection');
 var _ = require('lodash');
 var EventEmitter = require('events').EventEmitter;
 var should = require('should');
 var sinon = require('sinon');
+var stub = require('./auto_release_stub').make();
 
 function listenerCount(emitter, event) {
   if (EventEmitter.listenerCount) {
@@ -157,14 +159,53 @@ describe('Connection Pool', function () {
       });
     });
 
-    it('should automatically select the dead connection with the shortest timeout when there no living connections',
+  });
+
+  describe('Connection selection with no living nodes', function () {
+    it('should ping all of the dead nodes, in order of oldest timeout, and return the first that\'s okay',
     function (done) {
-      pool.setHosts([]);
-      pool._conns.alive = [];
-      pool._conns.dead = [1, 2, 3];
+      var clock = sinon.useFakeTimers('setTimeout', 'clearTimeout');
+      var pool = new ConnectionPool({
+        deadTimeout: 10000
+      });
+
+      var connections = [
+        new ConnectionAbstract(new Host('http://localhost:9200')),
+        new ConnectionAbstract(new Host('http://localhost:9201')),
+        new ConnectionAbstract(new Host('http://localhost:9202')),
+        new ConnectionAbstract(new Host('http://localhost:9203'))
+      ];
+      var pingQueue = _.shuffle(connections);
+      var expectedSelection = pingQueue[pingQueue.length - 1];
+
+      pingQueue.forEach(function (conn) {
+        pool.addConnection(conn);
+        stub(conn, 'ping', function (params, cb) {
+          if (typeof params === 'function') {
+            cb = params;
+          }
+          var expectedConn = pingQueue.shift();
+          conn.should.be.exactly(expectedConn);
+          if (pingQueue.length) {
+            process.nextTick(function () {
+              cb(new Error('keep trying'));
+            });
+          } else {
+            process.nextTick(function () {
+              cb(null, true);
+            });
+          }
+        });
+        conn.setStatus('dead');
+        clock.tick(500);
+      });
 
       pool.select(function (err, selection) {
-        // selection.should.be.exactly(1);
+        clock.restore();
+        selection.should.be.exactly(expectedSelection);
+        pingQueue.should.have.length(0);
+        pool.setHosts([]);
+        should.not.exist(err);
         done();
       });
     });