Localize all global clock and timer mocks

ali-ince · ali-ince · commit bf647e758b49 · 2019-07-12T12:19:51.000+01:00
diff --git a/test/driver.test.js b/test/driver.test.js
@@ -28,7 +28,6 @@ import { ServerVersion, VERSION_4_0_0 } from '../src/internal/server-version'
 import testUtils from './internal/test-utils'
 
 describe('#integration driver', () => {
-  let clock
   let driver
   let serverVersion
 
@@ -42,10 +41,6 @@ describe('#integration driver', () => {
   })
 
   afterEach(() => {
-    if (clock) {
-      clock.uninstall()
-      clock = null
-    }
     if (driver) {
       driver.close()
       driver = null
@@ -295,38 +290,38 @@ describe('#integration driver', () => {
     })
   })
 
-  it('should discard old connections', done => {
+  it('should discard old connections', async () => {
     const maxLifetime = 100000
     driver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken, {
       maxConnectionLifetime: maxLifetime
     })
 
     const session1 = driver.session()
-    session1.run('CREATE () RETURN 42').then(() => {
-      session1.close()
+    await session1.run('CREATE () RETURN 42')
+    session1.close()
 
-      // one connection should be established
-      const connections1 = openConnectionFrom(driver)
-      expect(connections1.length).toEqual(1)
+    // one connection should be established
+    const connections1 = openConnectionFrom(driver)
+    expect(connections1.length).toEqual(1)
 
-      // make existing connection look very old by advancing the `Date.now()` value
-      const currentTime = Date.now()
-      clock = lolex.install()
+    // make existing connection look very old by advancing the `Date.now()` value
+    const currentTime = Date.now()
+    const clock = lolex.install()
+    try {
       clock.setSystemTime(currentTime + maxLifetime * 2)
 
       const session2 = driver.session()
-      session2.run('RETURN 1').then(() => {
-        session2.close()
+      await session2.run('RETURN 1')
+      session2.close()
 
-        // old connection should be disposed and new one should be created
-        const connections2 = openConnectionFrom(driver)
-        expect(connections2.length).toEqual(1)
+      // old connection should be disposed and new one should be created
+      const connections2 = openConnectionFrom(driver)
+      expect(connections2.length).toEqual(1)
 
-        expect(connections1[0]).not.toEqual(connections2[0])
-
-        done()
-      })
-    })
+      expect(connections1[0]).not.toEqual(connections2[0])
+    } finally {
+      clock.uninstall()
+    }
   })
 
   const exposedTypes = [
diff --git a/test/internal/connection-channel.test.js b/test/internal/connection-channel.test.js
@@ -41,15 +41,9 @@ const FAILURE_MESSAGE = { signature: 0x7f, fields: [newError('Hello')] }
 const RECORD_MESSAGE = { signature: 0x71, fields: [{ value: 'Hello' }] }
 
 describe('#integration ChannelConnection', () => {
-  let clock
   let connection
 
   afterEach(done => {
-    if (clock) {
-      clock.uninstall()
-      clock = null
-    }
-
     const usedConnection = connection
     connection = null
     if (usedConnection) {
@@ -59,12 +53,16 @@ describe('#integration ChannelConnection', () => {
   })
 
   it('should have correct creation timestamp', () => {
-    clock = lolex.install()
-    clock.setSystemTime(424242)
+    const clock = lolex.install()
+    try {
+      clock.setSystemTime(424242)
 
-    connection = createConnection('bolt://localhost')
+      connection = createConnection('bolt://localhost')
 
-    expect(connection.creationTimestamp).toEqual(424242)
+      expect(connection.creationTimestamp).toEqual(424242)
+    } finally {
+      clock.uninstall()
+    }
   })
 
   it('should read/write basic messages', done => {
@@ -231,12 +229,12 @@ describe('#integration ChannelConnection', () => {
       })
   })
 
-  it('should respect connection timeout', done => {
-    testConnectionTimeout(false, done)
+  it('should respect connection timeout', async () => {
+    await testConnectionTimeout(false)
   })
 
-  it('should respect encrypted connection timeout', done => {
-    testConnectionTimeout(true, done)
+  it('should respect encrypted connection timeout', async () => {
+    await testConnectionTimeout(true)
   })
 
   it('should not queue INIT observer when broken', done => {
@@ -471,30 +469,38 @@ describe('#integration ChannelConnection', () => {
     }
   }
 
-  function testConnectionTimeout (encrypted, done) {
-    const boltUri = 'bolt://10.0.0.0' // use non-routable IP address which never responds
-    connection = createConnection(
-      boltUri,
-      { encrypted: encrypted, connectionTimeout: 1000 },
-      'TestErrorCode'
-    )
-
-    connection
-      .connect('mydriver/0.0.0', basicAuthToken())
-      .then(() => done.fail('Should not be able to connect'))
-      .catch(error => {
-        expect(error.code).toEqual('TestErrorCode')
+  async function testConnectionTimeout (encrypted) {
+    const clock = jasmine.clock()
+    clock.install()
+
+    try {
+      const boltUri = 'bolt://10.0.0.0' // use non-routable IP address which never responds
+      connection = createConnection(
+        boltUri,
+        { encrypted: encrypted, connectionTimeout: 1000 },
+        'TestErrorCode'
+      )
+
+      clock.tick(1001)
+
+      await connection.connect('mydriver/0.0.0', basicAuthToken())
+    } catch (error) {
+      expect(error.code).toEqual('TestErrorCode')
+
+      // in some environments non-routable address results in immediate 'connection refused' error and connect
+      // timeout is not fired; skip message assertion for such cases, it is important for connect attempt to not hang
+      if (error.message.indexOf('Failed to establish connection') === 0) {
+        expect(error.message).toEqual(
+          'Failed to establish connection in 1000ms'
+        )
+      }
 
-        // in some environments non-routable address results in immediate 'connection refused' error and connect
-        // timeout is not fired; skip message assertion for such cases, it is important for connect attempt to not hang
-        if (error.message.indexOf('Failed to establish connection') === 0) {
-          expect(error.message).toEqual(
-            'Failed to establish connection in 1000ms'
-          )
-        }
+      return
+    } finally {
+      clock.uninstall()
+    }
 
-        done()
-      })
+    expect(false).toBeTruthy('exception expected')
   }
 
   function testQueueingOfObserversWithBrokenConnection (connectionAction, done) {
diff --git a/test/internal/connection-provider-pooled.test.js b/test/internal/connection-provider-pooled.test.js
@@ -21,15 +21,6 @@ import FakeConnection from './fake-connection'
 import lolex from 'lolex'
 
 describe('#unit PooledConnectionProvider', () => {
-  let clock
-
-  beforeEach(() => {
-    if (clock) {
-      clock.uninstall()
-      clock = null
-    }
-  })
-
   it('should treat closed connections as invalid', () => {
     const provider = new PooledConnectionProvider({
       id: 0,
@@ -52,11 +43,15 @@ describe('#unit PooledConnectionProvider', () => {
     })
 
     const connection = new FakeConnection().withCreationTimestamp(12)
-    clock = lolex.install()
-    clock.setSystemTime(20)
-    const connectionValid = provider._validateConnection(connection)
+    const clock = lolex.install()
+    try {
+      clock.setSystemTime(20)
+      const connectionValid = provider._validateConnection(connection)
 
-    expect(connectionValid).toBeTruthy()
+      expect(connectionValid).toBeTruthy()
+    } finally {
+      clock.uninstall()
+    }
   })
 
   it('should treat old open connections as invalid', () => {
@@ -68,10 +63,14 @@ describe('#unit PooledConnectionProvider', () => {
     })
 
     const connection = new FakeConnection().withCreationTimestamp(5)
-    clock = lolex.install()
-    clock.setSystemTime(20)
-    const connectionValid = provider._validateConnection(connection)
+    const clock = lolex.install()
+    try {
+      clock.setSystemTime(20)
+      const connectionValid = provider._validateConnection(connection)
 
-    expect(connectionValid).toBeFalsy()
+      expect(connectionValid).toBeFalsy()
+    } finally {
+      clock.uninstall()
+    }
   })
 })
diff --git a/test/internal/node/routing.driver.boltkit.test.js b/test/internal/node/routing.driver.boltkit.test.js
@@ -27,7 +27,6 @@ import ServerAddress from '../../../src/internal/server-address'
 
 describe('#stub-routing routing driver with stub server', () => {
   let originalTimeout
-  let clock
 
   beforeAll(() => {
     originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL
@@ -1586,18 +1585,19 @@ describe('#stub-routing routing driver with stub server', () => {
       const driver = boltStub.newDriver('neo4j://127.0.0.1:9001')
       const session = driver.session()
 
+      let clock
       let invocations = 0
       const resultPromise = session.readTransaction(tx => {
         invocations++
         if (invocations === 2) {
           // make retries stop after two invocations
-          moveTime30SecondsForward()
+          clock = moveTime30SecondsForward()
         }
         return tx.run('MATCH (n) RETURN n.name')
       })
 
       resultPromise.catch(error => {
-        removeTimeMocking() // uninstall lolex mocking to make test complete, boltkit uses timers
+        removeTimeMocking(clock) // uninstall lolex mocking to make test complete, boltkit uses timers
 
         expect(error.code).toEqual(SESSION_EXPIRED)
         expect(invocations).toEqual(2)
@@ -1642,18 +1642,19 @@ describe('#stub-routing routing driver with stub server', () => {
       const driver = boltStub.newDriver('neo4j://127.0.0.1:9001')
       const session = driver.session()
 
+      let clock = null
       let invocations = 0
       const resultPromise = session.writeTransaction(tx => {
         invocations++
         if (invocations === 2) {
           // make retries stop after two invocations
-          moveTime30SecondsForward()
+          clock = moveTime30SecondsForward()
         }
         return tx.run("CREATE (n {name:'Bob'})")
       })
 
       resultPromise.catch(error => {
-        removeTimeMocking() // uninstall lolex mocking to make test complete, boltStub uses timers
+        removeTimeMocking(clock) // uninstall lolex mocking to make test complete, boltStub uses timers
 
         expect(error.code).toEqual(SESSION_EXPIRED)
         expect(invocations).toEqual(2)
@@ -2939,14 +2940,14 @@ describe('#stub-routing routing driver with stub server', () => {
 
   function moveTime30SecondsForward () {
     const currentTime = Date.now()
-    clock = lolex.install()
+    const clock = lolex.install()
     clock.setSystemTime(currentTime + 30 * 1000 + 1)
+    return clock
   }
 
-  function removeTimeMocking () {
+  function removeTimeMocking (clock) {
     if (clock) {
       clock.uninstall()
-      clock = null
     }
   }
 
diff --git a/test/internal/routing-util.test.js b/test/internal/routing-util.test.js
