deps: remove timekeeper

ruiquelhas · ruiquelhas · commit d47716a9fd19 · 2022-01-24T14:21:49.000Z
The timekeeper package is being used to perform fake time travel in a
couple of unit tests. The same can also be easily achieved by using a
mock of the JavaScript API resorting to other 3rd-party libraries
already being used like testdouble.js.

This patch introduces some changes to centralize the most common use of
the JavaScript API, in the form of "Date.now()" to a custom "global"
utility function as part of the existing system tools. Additionally, it
changes the corresponding component unit tests to use a fake version of
that function which can be controlled individually for each test and
avoids the need to use the timekeeper package. As a consequence, the
package was also removed from the list of "devDependencies".
diff --git a/lib/DevAPI/Connection.js b/lib/DevAPI/Connection.js
@@ -661,7 +661,7 @@ function Connection ({ auth, connectionAttributes = {}, connectTimeout = 10000,
                         // When a connection becomes unavailable, it should
                         // include the timestamp of when it was last tried.
                         const unavailable = Object.assign({}, state.endpoints.available.shift(), {
-                            unavailableAt: Date.now()
+                            unavailableAt: system.time()
                         });
 
                         state.endpoints.unavailable.push(unavailable);
@@ -1238,7 +1238,7 @@ function Connection ({ auth, connectionAttributes = {}, connectTimeout = 10000,
          * @returns {module:Connection}
          */
         update () {
-            const now = Date.now();
+            const now = system.time();
             // Check which unavailable endpoints can be re-tried.
             // If the current element in the list is not "retryable", neither
             // are the remaining. A retryable endpoint is any endpoint that has
diff --git a/lib/DevAPI/ConnectionPool.js b/lib/DevAPI/ConnectionPool.js
@@ -32,6 +32,7 @@
 
 const connection = require('./PoolConnection');
 const errors = require('../constants/errors');
+const system = require('../system');
 const util = require('util');
 const { isValidBoolean, isValidInteger } = require('../validator');
 
@@ -172,7 +173,7 @@ function ConnectionPool (options = {}) {
          * @throws Will return a rejected Promise if queueTimeout is exceeded.
          * @returns {Promise<PoolConnection>}
          */
-        getConnection (requestedAt = Date.now()) {
+        getConnection (requestedAt = system.time()) {
             return this.update()
                 .then(() => {
                     // If previous connection requests were queued and the
@@ -185,7 +186,7 @@ function ConnectionPool (options = {}) {
                         return;
                     }
 
-                    const elapsedTime = Date.now() - requestedAt;
+                    const elapsedTime = system.time() - requestedAt;
                     const queueTimeout = options.pooling.queueTimeout;
 
                     const postConnect = con => {
diff --git a/lib/DevAPI/PoolConnection.js b/lib/DevAPI/PoolConnection.js
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2021, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as
@@ -31,6 +31,7 @@
 'use strict';
 
 const connection = require('./Connection');
+const system = require('../system');
 
 /**
  * API for connections to be used by a connection pool.
@@ -73,7 +74,7 @@ function PoolConnection (options = { pooling: {} }) {
          * @returns {Promise} Returns a promise just to keep consistency with standalone connections
          */
         close () {
-            state.releasedAt = Date.now();
+            state.releasedAt = system.time();
             return Promise.resolve();
         },
 
@@ -100,7 +101,7 @@ function PoolConnection (options = { pooling: {} }) {
 
             // Otherwise, we should check if the connection was released for
             // more than the value of maxIdleTime.
-            return Date.now() - state.releasedAt > options.pooling.maxIdleTime;
+            return system.time() - state.releasedAt > options.pooling.maxIdleTime;
         },
 
         /**
diff --git a/lib/system.js b/lib/system.js
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2021, 2022, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0, as
@@ -155,3 +155,13 @@ exports.platform = function () {
 
     return convention;
 };
+
+/**
+ * Retrieve the current system time in milliseconds elapsed since the Unix
+ * epoch.
+ * @private
+ * @returns {number}
+ */
+exports.time = function () {
+    return Date.now();
+};
diff --git a/package.json b/package.json
@@ -71,8 +71,7 @@
     "nyc": "15.1.0",
     "snazzy": "9.0.0",
     "standardx": "7.0.0",
-    "testdouble": "3.16.1",
-    "timekeeper": "2.2.0"
+    "testdouble": "3.16.1"
   },
   "nyc": {
     "branches": 75,
diff --git a/test/unit/DevAPI/ConnectionPool.js b/test/unit/DevAPI/ConnectionPool.js
@@ -35,7 +35,6 @@
 const errors = require('../../../lib/constants/errors');
 const expect = require('chai').expect;
 const td = require('testdouble');
-const tk = require('timekeeper');
 const util = require('util');
 
 // subject under test needs to be reloaded with replacement fakes
@@ -44,7 +43,6 @@ let connectionPool = require('../../../lib/DevAPI/ConnectionPool');
 describe('ConnectionPool', () => {
     afterEach('reset fakes', () => {
         td.reset();
-        tk.reset();
     });
 
     context('create()', () => {
@@ -141,30 +139,6 @@ describe('ConnectionPool', () => {
             connectionPool = require('../../../lib/DevAPI/ConnectionPool');
         });
 
-        it('fails if queueTimeout was exceeded', done => {
-            const queueTimeout = 5000;
-            const pool = connectionPool({ pooling: { maxSize: 3, queueTimeout } }).create({ active: ['foo', 'bar', 'baz'] });
-            const isAvailable = td.replace(pool, 'isAvailable');
-            const update = td.replace(pool, 'update');
-
-            td.when(update()).thenResolve();
-            td.when(isAvailable()).thenReturn(true);
-
-            // We need to travel in time only after calling
-            // pool.getConnection(), otherwise, Date.now() will also be in the
-            // future.
-            pool.getConnection()
-                .then(() => {
-                    done(expect.fail());
-                })
-                .catch(err => {
-                    expect(err.message).to.equal(util.format(errors.MESSAGES.ER_DEVAPI_POOL_QUEUE_TIMEOUT, queueTimeout));
-                    done();
-                });
-
-            tk.travel(new Date(Date.now() + queueTimeout + 1));
-        });
-
         it('acquires and returns an idle connection if one exists and no expired ones exist', () => {
             const poolConnection = { acquire, isClosing, isExpired, isOpen, override };
             const pool = connectionPool({ pooling: { maxSize: 3 } }).create({ active: ['foo'], idle: [poolConnection] });
@@ -281,61 +255,109 @@ describe('ConnectionPool', () => {
                 });
         });
 
-        it('queues the request when the pool is full and queueTimeout was not exceeded', done => {
-            const queueTimeout = 1000;
-            const options = { pooling: { maxSize: 3, queueTimeout } };
-            const pool = connectionPool(options).create({ active: ['foo', 'bar', 'baz'] });
-            const isAvailable = td.replace(pool, 'isAvailable');
-            const update = td.replace(pool, 'update');
-            const poolConnection = { acquire };
+        context('when the pool is full', () => {
+            let system;
 
-            td.when(update()).thenResolve();
-            td.when(isAvailable()).thenReturn(true);
-            td.when(connection(options)).thenReturn({ open });
-            td.when(open()).thenResolve(poolConnection);
-
-            // We need to travel in time only after calling
-            // pool.getConnection(), otherwise, Date.now() will also be in the
-            // future.
-            pool.getConnection().then(con => {
-                expect(td.explain(acquire).callCount).to.equal(1);
-                expect(pool.activeConnections()).to.deep.include(con);
-                expect(con).to.deep.equal(poolConnection);
+            beforeEach('setup fake time', () => {
+                system = td.replace('../../../lib/system');
 
-                return done();
+                connectionPool = require('../../../lib/DevAPI/ConnectionPool');
             });
 
-            tk.travel(new Date(Date.now() + queueTimeout / 10 + 1));
-            // We reset the pool after queueTimeout / 10.
-            setTimeout(() => pool.reset(), queueTimeout / 10);
-        });
-
-        it('queues the request when an an expired connection is available but is still being closed and queueTimeout was not exceeded', done => {
-            const queueTimeout = 1000;
-            const options = { pooling: { maxSize: 3, queueTimeout } };
-            const pool = connectionPool(options).create({ active: ['foo', 'bar'], expired: [{ isClosing }] });
-            const isAvailable = td.replace(pool, 'isAvailable');
-            const update = td.replace(pool, 'update');
-            const poolConnection = { acquire };
+            it('queues the request if queueTimeout was not exceeded', done => {
+                const queueTimeout = 1000;
+                const options = { pooling: { maxSize: 3, queueTimeout } };
+                const pool = connectionPool(options).create({ active: ['foo', 'bar', 'baz'] });
+                const isAvailable = td.replace(pool, 'isAvailable');
+                const update = td.replace(pool, 'update');
+                const poolConnection = { acquire };
+                const now = Date.now();
+
+                // The last time it is called, system.time() should return a time
+                // after queueTimeout.
+                td.when(system.time()).thenReturn(now + queueTimeout / 10 + 1);
+                // The first time it is called, system.time() should return the
+                // initial time.
+                td.when(system.time(), { times: 1 }).thenReturn(now);
+                td.when(update()).thenResolve();
+                td.when(isAvailable()).thenReturn(true);
+                td.when(connection(options)).thenReturn({ open });
+                td.when(open()).thenResolve(poolConnection);
+
+                // We need to travel in time only after calling
+                // pool.getConnection(), otherwise, Date.now() will also be in the
+                // future.
+                pool.getConnection().then(con => {
+                    expect(td.explain(acquire).callCount).to.equal(1);
+                    expect(pool.activeConnections()).to.deep.include(con);
+                    expect(con).to.deep.equal(poolConnection);
 
-            td.when(update()).thenResolve();
-            td.when(isAvailable()).thenReturn(true);
-            td.when(isClosing()).thenReturn(true);
-            td.when(connection(options)).thenReturn({ open });
-            td.when(open()).thenResolve(poolConnection);
+                    return done();
+                });
 
-            // We need to travel in time only after calling
-            // pool.getConnection(), otherwise, Date.now() will also be in the
-            // future.
-            pool.getConnection().then(con => {
-                expect(td.explain(acquire).callCount).to.equal(1);
-                expect(pool.activeConnections()).to.deep.include(con);
-                expect(con).to.deep.equal(poolConnection);
+                // We reset the pool after queueTimeout / 10.
+                setTimeout(() => pool.reset(), queueTimeout / 10);
+            });
 
-                return done();
+            it('queues the request when an an expired connection is available but is still being closed and queueTimeout was not exceeded', () => {
+                const queueTimeout = 1000;
+                const options = { pooling: { maxSize: 3, queueTimeout } };
+                const pool = connectionPool(options).create({ active: ['foo', 'bar'], expired: [{ isClosing }] });
+                const isAvailable = td.replace(pool, 'isAvailable');
+                const update = td.replace(pool, 'update');
+                const poolConnection = { acquire };
+                const now = Date.now();
+
+                // The last time it is called, system.time() should return a time
+                // after queueTimeout.
+                td.when(system.time()).thenReturn(now + queueTimeout / 10 + 1);
+                // The first time it is called, system.time() should return the
+                // initial time.
+                td.when(system.time(), { times: 1 }).thenReturn(now);
+                td.when(update()).thenResolve();
+                td.when(isAvailable()).thenReturn(true);
+                td.when(isClosing()).thenReturn(true);
+                td.when(connection(options)).thenReturn({ open });
+                td.when(open()).thenResolve(poolConnection);
+
+                // We need to travel in time only after calling
+                // pool.getConnection(), otherwise, Date.now() will also be in the
+                // future.
+                return pool.getConnection()
+                    .then(con => {
+                        expect(td.explain(acquire).callCount).to.equal(1);
+                        expect(pool.activeConnections()).to.deep.include(con);
+                        return expect(con).to.deep.equal(poolConnection);
+                    });
             });
 
-            tk.travel(new Date(Date.now() + queueTimeout / 10 + 1));
+            it('fails when queueTimeout is exceeded', () => {
+                const queueTimeout = 5000;
+                const pool = connectionPool({ pooling: { maxSize: 3, queueTimeout } }).create({ active: ['foo', 'bar', 'baz'] });
+                const isAvailable = td.replace(pool, 'isAvailable');
+                const update = td.replace(pool, 'update');
+                const now = Date.now();
+
+                // The last time it is called, system.time() should return a time
+                // after queueTimeout.
+                td.when(system.time()).thenReturn(now + queueTimeout + 1);
+                // The first time it is called, system.time() should return the
+                // initial time.
+                td.when(system.time(), { times: 1 }).thenReturn(now);
+                td.when(update()).thenResolve();
+                td.when(isAvailable()).thenReturn(true);
+
+                // We need to travel in time only after calling
+                // pool.getConnection(), otherwise, Date.now() will also be in the
+                // future.
+                return pool.getConnection()
+                    .then(() => {
+                        return expect.fail();
+                    })
+                    .catch(err => {
+                        return expect(err.message).to.equal(util.format(errors.MESSAGES.ER_DEVAPI_POOL_QUEUE_TIMEOUT, queueTimeout));
+                    });
+            });
         });
 
         it('does not re-use any connection when the pool is not available', () => {
diff --git a/test/unit/DevAPI/PoolConnection.js b/test/unit/DevAPI/PoolConnection.js
diff --git a/test/unit/system.js b/test/unit/system.js
