Handle when a Sub Millisecond Tx Timeout is specified

If a user sets a timeout with a fractional millisecond value it will be rounded up to the next integer value. e.g

0.1 → 1

1.4 → 2.0

1.8 → 2.0

A warning that a rounding has taken place should be logged under info level.

Author: bigmontz

packages/core/src/integer.ts

@@ -908,14 +908,18 @@ class Integer {
    * @param {!Integer|number|string|bigint|!{low: number, high: number}} val Value
    * @param {Object} [opts={}] Configuration options
    * @param {boolean} [opts.strictStringValidation=false] Enable strict validation generated Integer.
+   * @param {boolean} [opts.ceilFloat=false] Enable round up float to the nearest Integer.
    * @returns {!Integer}
    * @expose
    */
-  static fromValue (val: Integerable, opts: { strictStringValidation?: boolean} = {}): Integer {
+  static fromValue (val: Integerable, opts: { strictStringValidation?: boolean, ceilFloat?: boolean } = {}): Integer {
     if (val /* is compatible */ instanceof Integer) {
       return val
     }
     if (typeof val === 'number') {
+      if (opts.ceilFloat === true) {
+        val = Math.ceil(val)
+      }
       return Integer.fromNumber(val)
     }
     if (typeof val === 'string') {
@@ -1066,6 +1070,7 @@ const TWO_PWR_24 = Integer.fromInt(TWO_PWR_24_DBL)
  * @param {Mixed} value - The value to use.
  * @param {Object} [opts={}] Configuration options
  * @param {boolean} [opts.strictStringValidation=false] Enable strict validation generated Integer.
+ * @param {boolean} [opts.ceilFloat=false] Enable round up float to the nearest Integer.
  * @return {Integer} - An object of type Integer.
  */
 const int = Integer.fromValue

packages/core/src/internal/tx-config.ts

@@ -66,7 +66,7 @@ const EMPTY_CONFIG = new TxConfig({})
 function extractTimeout (config: any): Integer | null {
   if (util.isObject(config) && config.timeout != null) {
     util.assertNumberOrInteger(config.timeout, 'Transaction timeout')
-    const timeout = int(config.timeout)
+    const timeout = int(config.timeout, { ceilFloat: true })
     if (timeout.isNegative()) {
       throw newError('Transaction timeout should not be negative')
     }

packages/core/test/session.test.ts

@@ -16,13 +16,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ConnectionProvider, Session, Connection, TransactionPromise, Transaction, BookmarkManager, bookmarkManager, NotificationFilter } from '../src'
+import { ConnectionProvider, Session, Connection, TransactionPromise, Transaction, BookmarkManager, bookmarkManager, NotificationFilter, int } from '../src'
 import { bookmarks } from '../src/internal'
 import { ACCESS_MODE_READ, FETCH_ALL } from '../src/internal/constants'
 import ManagedTransaction from '../src/transaction-managed'
 import { AuthToken } from '../src/types'
 import FakeConnection from './utils/connection.fake'
 import { validNotificationFilters } from './utils/notification-filters.fixtures'
+import fc from 'fast-check'
 
 describe('session', () => {
   const systemBookmarks = ['sys:bm01', 'sys:bm02']
@@ -474,6 +475,28 @@ describe('session', () => {
         expect.objectContaining({ auth })
       )
     })
+
+    it('should round up sub milliseconds transaction timeouts', async () => {
+      return await fc.assert(
+        fc.asyncProperty(
+          fc.float({ min: 0, noNaN: true }),
+          async (timeout: number) => {
+            const connection = mockBeginWithSuccess(newFakeConnection())
+
+            const { session } = setupSession({
+              connection,
+              beginTx: false,
+              database: 'neo4j'
+            })
+
+            await session.beginTransaction({ timeout })
+
+            expect(connection.seenBeginTransaction[0][0].txConfig.timeout)
+              .toEqual(int(Math.ceil(timeout)))
+          }
+        )
+      )
+    })
   })
 
   describe('.commit()', () => {
@@ -588,6 +611,29 @@ describe('session', () => {
       expect(status.functionCalled).toEqual(true)
       expect(run).toHaveBeenCalledWith(query, params)
     })
+
+    it('should round up sub milliseconds transaction timeouts', async () => {
+      return await fc.assert(
+        fc.asyncProperty(
+          fc.float({ min: 0, noNaN: true }),
+          async (timeout: number) => {
+            const connection = mockBeginWithSuccess(newFakeConnection())
+            const session = newSessionWithConnection(connection, false, FETCH_ALL)
+            // @ts-expect-error
+            jest.spyOn(Transaction.prototype, 'run').mockImplementation(async () => await Promise.resolve())
+            const query = 'RETURN $a'
+            const params = { a: 1 }
+
+            await execute(session)(async (tx: ManagedTransaction) => {
+              await tx.run(query, params)
+            }, { timeout })
+
+            expect(connection.seenBeginTransaction[0][0].txConfig.timeout)
+              .toEqual(int(Math.ceil(timeout)))
+          }
+        )
+      )
+    })
   })
 
   describe('.run()', () => {
@@ -893,7 +939,7 @@ describe('session', () => {
       })
 
       await session.run('query')
-      
+
       expect(connectionProvider.acquireConnection).toBeCalledWith(
         expect.objectContaining({ auth })
       )
@@ -918,6 +964,28 @@ describe('session', () => {
         expect.objectContaining({ auth })
       )
     })
+
+    it('should round up sub milliseconds transaction timeouts', async () => {
+      return await fc.assert(
+        fc.asyncProperty(
+          fc.float({ min: 0, noNaN: true }),
+          async (timeout: number) => {
+            const connection = newFakeConnection()
+
+            const { session } = setupSession({
+              connection,
+              beginTx: false,
+              database: 'neo4j'
+            })
+
+            await session.run('query', {}, { timeout })
+
+            expect(connection.seenProtocolOptions[0].txConfig.timeout)
+              .toEqual(int(Math.ceil(timeout)))
+          }
+        )
+      )
+    })
   })
 })