Clear WebSocket connection timeout when closing channel

`WebSocketChannel` is built on top of a `WebSocket` and contains
property that references it. `WebSocket` connection timeout is
enforced by a separate setTimeout timer that closes the socket
after configured amount of time. Previously this timeout has
only been cleared when connection is established. It has not
been cleared when channel is closed, resulting in potential
existence of stray timers.

This commit makes `WebSocketChannel` clear the connection timeout timer
when it's closed. So connect timeout timer is removed even if channel
is closed before connection is established.

Author: lutovich

src/v1/internal/ch-websocket.js

@@ -65,8 +65,8 @@ class WebSocketChannel {
         }
     };
     this._ws.onopen = function() {
-      // Connected! Cancel connection timeout
-      clearTimeout(self._connectionTimeoutId);
+      // Connected! Cancel the connection timeout
+      self._clearConnectionTimeout();
 
       // Drain all pending messages
       let pending = self._pending;
@@ -85,7 +85,7 @@ class WebSocketChannel {
     this._ws.onerror = this._handleConnectionError;
 
     this._connectionTimeoutFired = false;
-    this._connectionTimeoutId = this._setupConnectionTimeout(config);
+    this._connectionTimeoutId = this._setupConnectionTimeout();
   }
 
   _handleConnectionError() {
@@ -141,6 +141,7 @@ class WebSocketChannel {
    */
   close ( cb = ( () => null )) {
     this._open = false;
+    this._clearConnectionTimeout();
     this._ws.close();
     this._ws.onclose = cb;
   }
@@ -164,6 +165,19 @@ class WebSocketChannel {
     }
     return null;
   }
+
+  /**
+   * Remove active connection timeout, if any.
+   * @private
+   */
+  _clearConnectionTimeout() {
+    const timeoutId = this._connectionTimeoutId;
+    if (timeoutId || timeoutId === 0) {
+      this._connectionTimeoutFired = false;
+      this._connectionTimeoutId = null;
+      clearTimeout(timeoutId);
+    }
+  }
 }
 
 let available = typeof WebSocket !== 'undefined';

test/internal/ch-websocket.test.js

@@ -21,13 +21,15 @@ import wsChannel from '../../src/v1/internal/ch-websocket';
 import ChannelConfig from '../../src/v1/internal/ch-config';
 import urlUtil from '../../src/v1/internal/url-util';
 import {SERVICE_UNAVAILABLE} from '../../src/v1/error';
+import {setTimeoutMock} from './timers-util';
 
 describe('WebSocketChannel', () => {
 
   const WebSocketChannel = wsChannel.channel;
   const webSocketChannelAvailable = wsChannel.available;
 
   let OriginalWebSocket;
+  let webSocketChannel;
 
   beforeEach(() => {
     if (webSocketChannelAvailable) {
@@ -39,6 +41,9 @@ describe('WebSocketChannel', () => {
     if (webSocketChannelAvailable) {
       WebSocket = OriginalWebSocket;
     }
+    if (webSocketChannel) {
+      webSocketChannel.close();
+    }
   });
 
   it('should fallback to literal IPv6 when SyntaxError is thrown', () => {
@@ -49,6 +54,47 @@ describe('WebSocketChannel', () => {
     testFallbackToLiteralIPv6('bolt://[fe80::1%lo0]:8888', 'ws://fe80--1slo0.ipv6-literal.net:8888');
   });
 
+  it('should clear connection timeout when closed', () => {
+    if (!webSocketChannelAvailable) {
+      return;
+    }
+
+    const fakeSetTimeout = setTimeoutMock.install();
+    try {
+      // do not execute setTimeout callbacks
+      fakeSetTimeout.pause();
+
+      let fakeWebSocketClosed = false;
+
+      // replace real WebSocket with a function that does nothing
+      WebSocket = () => {
+        return {
+          close: () => {
+            fakeWebSocketClosed = true;
+          }
+        };
+      };
+
+      const url = urlUtil.parseBoltUrl('bolt://localhost:7687');
+      const driverConfig = {connectionTimeout: 4242};
+      const channelConfig = new ChannelConfig(url, driverConfig, SERVICE_UNAVAILABLE);
+
+      webSocketChannel = new WebSocketChannel(channelConfig);
+
+      expect(fakeWebSocketClosed).toBeFalsy();
+      expect(fakeSetTimeout.invocationDelays).toEqual([]);
+      expect(fakeSetTimeout.clearedTimeouts).toEqual([]);
+
+      webSocketChannel.close();
+
+      expect(fakeWebSocketClosed).toBeTruthy();
+      expect(fakeSetTimeout.invocationDelays).toEqual([]);
+      expect(fakeSetTimeout.clearedTimeouts).toEqual([0]); // cleared one timeout with id 0
+    } finally {
+      fakeSetTimeout.uninstall();
+    }
+  });
+
   function testFallbackToLiteralIPv6(boltAddress, expectedWsAddress) {
     if (!webSocketChannelAvailable) {
       return;
@@ -59,14 +105,19 @@ describe('WebSocketChannel', () => {
       if (url.indexOf('[') !== -1) {
         throw new SyntaxError();
       }
-      return {url: url};
+      return {
+        url: url,
+        close: () => {
+        }
+      };
     };
 
     const url = urlUtil.parseBoltUrl(boltAddress);
     // disable connection timeout, so that WebSocketChannel does not set any timeouts
     const driverConfig = {connectionTimeout: 0};
     const channelConfig = new ChannelConfig(url, driverConfig, SERVICE_UNAVAILABLE);
-    const webSocketChannel = new WebSocketChannel(channelConfig);
+
+    webSocketChannel = new WebSocketChannel(channelConfig);
 
     expect(webSocketChannel._ws.url).toEqual(expectedWsAddress);
   }