Ensure idle observers are removed when purging

src/v1/internal/pool.js

@@ -210,7 +210,10 @@ class Pool {
         if (this._installIdleObserver) {
           this._installIdleObserver(resource, {
             onError: () => {
-              this._pools[key] = this._pools[key].filter(r => r !== resource)
+              const pool = this._pools[key]
+              if (pool) {
+                this._pools[key] = pool.filter(r => r !== resource)
+              }
               this._destroy(resource)
             }
           })
@@ -235,6 +238,9 @@ class Pool {
     const pool = this._pools[key] || []
     while (pool.length) {
       const resource = pool.pop()
+      if (this._removeIdleObserver) {
+        this._removeIdleObserver(resource)
+      }
       this._destroy(resource)
     }
     delete this._pools[key]

test/internal/connection-providers.test.js

@@ -51,6 +51,16 @@ describe('DirectConnectionProvider', () => {
 })
 
 describe('LoadBalancer', () => {
+  let originalTimeout
+  beforeEach(function () {
+    originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000
+  })
+
+  afterEach(function () {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout
+  })
+
   const server0 = ServerAddress.fromUrl('server0')
   const server1 = ServerAddress.fromUrl('server1')
   const server2 = ServerAddress.fromUrl('server2')

test/internal/http/http-request-runner.test.js

@@ -28,6 +28,16 @@ const VALID_URI = 'http://localhost'
 const INVALID_URI = 'http://not-localhost'
 
 describe('http request runner', () => {
+  let originalTimeout
+  beforeEach(function () {
+    originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000
+  })
+
+  afterEach(function () {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout
+  })
+
   it('should begin transaction', done => {
     if (testUtils.isServer()) {
       done()

test/internal/pool.test.js

@@ -866,6 +866,38 @@ describe('Pool', () => {
       })
     })
   })
+
+  it('should clean-up idle observer on purge', done => {
+    const address = ServerAddress.fromUrl('bolt://localhost:7687')
+    let resourceCount = 0
+
+    const pool = new Pool({
+      create: (server, release) =>
+        Promise.resolve(new Resource(server, resourceCount++, release)),
+      destroy: resource => {},
+      validate: resource => true,
+      installIdleObserver: (resource, observer) => {
+        resource['observer'] = observer
+      },
+      removeIdleObserver: resource => {
+        delete resource['observer']
+      }
+    })
+
+    pool.acquire(address).then(resource1 => {
+      pool.acquire(address).then(resource2 => {
+        resource1.close()
+        resource2.close()
+
+        pool.purge(address)
+
+        expect(resource1['observer']).toBeFalsy()
+        expect(resource2['observer']).toBeFalsy()
+
+        done()
+      })
+    })
+  })
 })
 
 function expectNoPendingAcquisitionRequests (pool) {