Updated test

test/unit/connection-pool.test.js

@@ -5,6 +5,7 @@ const { URL } = require('url')
 const ConnectionPool = require('../../lib/ConnectionPool')
 const Connection = require('../../lib/Connection')
 const { RoundRobinSelector } = require('../../lib/Selectors')
+const { buildServer } = require('../utils')
 
 test('API', t => {
   t.test('addConnection', t => {
@@ -17,6 +18,19 @@ test('API', t => {
     t.end()
   })
 
+  t.test('addConnection should throw with two connections with the same id', t => {
+    const pool = new ConnectionPool({ selector: new RoundRobinSelector() })
+    const href = 'http://localhost:9200/'
+    pool.addConnection(href)
+    try {
+      pool.addConnection(href)
+      t.fail('Should throw')
+    } catch (err) {
+      t.is(err.message, `Connection with id '${href}' is already present`)
+    }
+    t.end()
+  })
+
   t.test('markDead', t => {
     const pool = new ConnectionPool({ selector: new RoundRobinSelector() })
     const href = 'http://localhost:9200/'
@@ -30,6 +44,20 @@ test('API', t => {
     t.end()
   })
 
+  t.test('markDead should sort the dead queue by deadTimeout', t => {
+    const pool = new ConnectionPool({ selector: new RoundRobinSelector() })
+    const href1 = 'http://localhost:9200/1'
+    const href2 = 'http://localhost:9200/2'
+    const conn1 = pool.addConnection(href1)
+    const conn2 = pool.addConnection(href2)
+    pool.markDead(conn2)
+    setTimeout(() => {
+      pool.markDead(conn1)
+      t.deepEqual(pool.dead, [href2, href1])
+      t.end()
+    }, 10)
+  })
+
   t.test('markAlive', t => {
     const pool = new ConnectionPool({ selector: new RoundRobinSelector() })
     const href = 'http://localhost:9200/'
@@ -45,15 +73,98 @@ test('API', t => {
   })
 
   t.test('resurrect', t => {
-    const pool = new ConnectionPool({ selector: new RoundRobinSelector() })
-    const href = 'http://localhost:9200/'
-    var connection = pool.addConnection(href)
-    pool.markDead(connection)
-    connection = pool.resurrect(Date.now() + 1000 * 60 * 3)
-    t.strictEqual(connection.deadCount, 1)
-    t.true(connection.resurrectTimeout > 0)
-    t.deepEqual(pool.alive, [href])
-    t.deepEqual(pool.dead, [])
+    t.test('ping strategy', t => {
+      t.test('alive', t => {
+        function handler (req, res) {
+          res.end()
+        }
+
+        buildServer(handler, ({ port }, server) => {
+          const pool = new ConnectionPool({
+            selector: new RoundRobinSelector(),
+            resurrectStrategy: 'ping',
+            pingTimeout: 3000
+          })
+          const href = `http://localhost:${port}/`
+          var connection = pool.addConnection(href)
+          pool.markDead(connection)
+          pool.resurrect(Date.now() + 1000 * 60 * 3, (isAlive, connection) => {
+            t.true(isAlive)
+            connection = pool.connections.get(connection.id)
+            t.strictEqual(connection.deadCount, 0)
+            t.strictEqual(connection.resurrectTimeout, 0)
+            t.deepEqual(pool.alive, [href])
+            t.deepEqual(pool.dead, [])
+            t.end()
+          })
+        })
+      })
+
+      t.test('dead', t => {
+        buildServer(() => {}, ({ port }, server) => {
+          server.close()
+          const pool = new ConnectionPool({
+            selector: new RoundRobinSelector(),
+            resurrectStrategy: 'ping',
+            pingTimeout: 3000
+          })
+          const href = `http://localhost:${port}/`
+          var connection = pool.addConnection(href)
+          pool.markDead(connection)
+          pool.resurrect(Date.now() + 1000 * 60 * 3, (isAlive, connection) => {
+            t.false(isAlive)
+            connection = pool.connections.get(connection.id)
+            t.strictEqual(connection.deadCount, 2)
+            t.true(connection.resurrectTimeout > 0)
+            t.deepEqual(pool.alive, [])
+            t.deepEqual(pool.dead, [href])
+            t.end()
+          })
+        })
+      })
+
+      t.end()
+    })
+
+    t.test('optimistic strategy', t => {
+      const pool = new ConnectionPool({
+        selector: new RoundRobinSelector(),
+        resurrectStrategy: 'optimistic'
+      })
+      const href = 'http://localhost:9200/'
+      var connection = pool.addConnection(href)
+      pool.markDead(connection)
+      pool.resurrect(Date.now() + 1000 * 60 * 3, (isAlive, connection) => {
+        t.ok(isAlive === null)
+        connection = pool.connections.get(connection.id)
+        t.strictEqual(connection.deadCount, 1)
+        t.true(connection.resurrectTimeout > 0)
+        t.deepEqual(pool.alive, [href])
+        t.deepEqual(pool.dead, [])
+        t.end()
+      })
+    })
+
+    t.test('none strategy', t => {
+      const pool = new ConnectionPool({
+        selector: new RoundRobinSelector(),
+        resurrectStrategy: 'none'
+      })
+      const href = 'http://localhost:9200/'
+      var connection = pool.addConnection(href)
+      pool.markDead(connection)
+      pool.resurrect(Date.now() + 1000 * 60 * 3, (isAlive, connection) => {
+        t.ok(isAlive === null)
+        t.ok(connection === null)
+        connection = pool.connections.get(href)
+        t.strictEqual(connection.deadCount, 1)
+        t.true(connection.resurrectTimeout > 0)
+        t.deepEqual(pool.alive, [])
+        t.deepEqual(pool.dead, [href])
+        t.end()
+      })
+    })
+
     t.end()
   })