@yousolution/node-red-contrib-you-tunnel-websocket 1.1.1 → 1.2.0

package/nodes/wsTunnel.html

@@ -74,7 +74,7 @@
       host: { value: '' },
       port: { value: '' },
       path: { value: '' },
-      tunnelIdHeaderName: { value: '' },
+      tunnelIdHeaderName: { value: 'x-tunnel-id' },
       logLevel: { value: 'info' },
     },
     label: function () {
@@ -261,12 +261,57 @@
     The log level configured in the <code>wstunnel</code> config node is applied when the server starts, controlling the verbosity of logging output from the
     tunnel library.
   </p>
+  <p>
+    Send any message to the input to request a server metrics snapshot on the output. The snapshot includes aggregate counters and per-tunnel detail from the
+    tunnel library.
+  </p>
+
+  <h3>Output</h3>
+  <p>The single output emits messages when tunnels connect, disconnect, or when metrics are requested.</p>
+  <dl class="message-properties">
+    <dt>event <span class="property-type">string</span></dt>
+    <dd><code>"connect"</code> when a tunnel is registered, <code>"disconnect"</code> when it closes, <code>"metrics"</code> when a metrics snapshot is returned.</dd>
+
+    <dt>tunnelId <span class="property-type">string</span></dt>
+    <dd>The unique tunnel identifier (UUID). Present on connect and disconnect events.</dd>
+
+    <dt>remoteAddress <span class="property-type">string</span></dt>
+    <dd>The client IP address from the WebSocket upgrade request.</dd>
+
+    <dt>connectedAt <span class="property-type">number</span></dt>
+    <dd><code>Date.now()</code> when the tunnel was registered. Present on connect events.</dd>
+
+    <dt>serverPort <span class="property-type">number</span></dt>
+    <dd>The port the WebSocket server is listening on.</dd>
+
+    <dt>payload <span class="property-type">object</span></dt>
+    <dd>On metrics events, contains the full snapshot object with aggregate and per-tunnel metrics.</dd>
+  </dl>
+
+  <h3>Example</h3>
+  <p>Connect the output to a <code>switch</code> node to route events separately:</p>
+  <pre>[wstunnel server] → [switch: event == "connect"]    → [notification flow]
+                   → [switch: event == "disconnect"] → [cleanup flow]
+                   → [switch: event == "metrics"]    → [dashboard flow]</pre>
+
+  <h3>Metrics</h3>
+  <p>Send any message to the input to request a metrics snapshot. The output emits a message with <code>event: "metrics"</code> and <code>payload</code> containing:</p>
+  <ul>
+    <li><code>active_tunnels</code> — number of currently active tunnels</li>
+    <li><code>active_streams</code> — number of active TCP streams</li>
+    <li><code>bytes_in_total / bytes_out_total</code> — aggregate byte counters</li>
+    <li><code>event_loop_lag_ms</code> — <code>{ p50, p99 }</code> event loop lag</li>
+    <li><code>tunnels_detail</code> — per-tunnel: <code>remoteAddress</code>, <code>streamCount</code>, <code>bytesIn</code>, <code>bytesOut</code>, <code>agentVersion</code></li>
+  </ul>
 
   <h3>Runtime Behavior</h3>
   <ul>
     <li>Status will show <code>listening on port [port]</code> when active.</li>
     <li>Each client connection updates the status with the current number of connected clients.</li>
     <li>All client connections are properly closed when the node is stopped or removed.</li>
+    <li>The output emits a message for each tunnel that successfully registers (after CONFIG handshake).</li>
+    <li>If a WebSocket connects but does not complete the CONFIG handshake, no events are emitted.</li>
+    <li>Any message sent to the input triggers a metrics snapshot on the output with <code>event: "metrics"</code>.</li>
   </ul>
 
   <h3>Logging</h3>
@@ -287,7 +332,9 @@
     </li>
     <li>Redeploying the flow will gracefully shut down existing WebSocket servers and restart them with updated configuration.</li>
     <li>Log level changes require redeployment to take effect.</li>
-    <li>This node does not have input or output wires – it works autonomously based on its configuration.</li>
+    <li>The output is optional — if not wired, the node behaves exactly as before (status-only monitoring).</li>
+    <li>The input accepts any message to trigger a metrics snapshot. Connect an <code>inject</code> node for periodic metrics.</li>
+    <li>Events are only emitted for tunnels that complete the CONFIG handshake. Raw WebSocket connections that are rejected or close before registration do not emit events.</li>
   </ul>
 </script>
 
@@ -299,8 +346,8 @@
       wstunnel: { type: 'wstunnel', required: true },
       name: { value: '' },
     },
-    inputs: 0,
-    outputs: 0,
+    inputs: 1,
+    outputs: 1,
     icon: 'font-awesome/fa-lock',
     label: function () {
       return this.name || 'tunnel Websocket server';
@@ -310,3 +357,78 @@
     },
   });
 </script>
+
+<script type="text/x-red" data-template-name="wstunnel command">
+  <div class="form-row">
+    <label for="node-input-wstunnel"><i class="fa fa-gears"></i> Tunnel Config</label>
+    <input type="text" id="node-input-wstunnel">
+  </div>
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Name">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="wstunnel command">
+  <p>Sends commands to connected tunnel clients via WebSocket.</p>
+
+  <h3>Inputs</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">object</span></dt>
+    <dd>The command payload. May contain <code>tunnelId</code>, <code>command</code>, and <code>args</code>.</dd>
+
+    <dt>tunnelId <span class="property-type">string</span></dt>
+    <dd>Alternative to <code>payload.tunnelId</code>. The UUID of the target tunnel.</dd>
+
+    <dt>command <span class="property-type">string</span></dt>
+    <dd>Alternative to <code>payload.command</code>. The command name to send (e.g. <code>"kill"</code>).</dd>
+
+    <dt>args <span class="property-type">object</span></dt>
+    <dd>Alternative to <code>payload.args</code>. Optional arguments for the command.</dd>
+  </dl>
+
+  <h3>Outputs</h3>
+  <dl class="message-properties">
+    <dt class="optional">output 0 — success</dt>
+    <dd>Sent when the command was delivered. <code>msg.payload</code> is <code>true</code>.</dd>
+
+    <dt class="optional">output 1 — failure</dt>
+    <dd>Sent when the tunnel was not found or not connected. <code>msg.payload</code> is <code>false</code>.</dd>
+  </dl>
+
+  <h3>Details</h3>
+  <p>
+    The node sends a command to a connected tunnel client. The target tunnel is identified by its <code>tunnelId</code>.
+    If the tunnel exists and its WebSocket is open, the command is delivered and output 0 fires.
+    If the tunnel does not exist or is disconnected, output 1 fires with <code>msg.error</code>.
+  </p>
+  <p>Missing <code>tunnelId</code> or <code>command</code> sends the message to output 1 with an error.</p>
+
+  <h3>Example</h3>
+  <pre>
+[inject: {tunnelId: "uuid", command: "kill"}]
+  → [wstunnel command]
+    → output 0 → [debug: success]
+    → output 1 → [debug: failure]
+</pre>
+</script>
+
+<script type="text/javascript">
+  RED.nodes.registerType('wstunnel command', {
+    category: 'network',
+    color: '#a7c957',
+    defaults: {
+      wstunnel: { type: 'wstunnel', required: true },
+      name: { value: '' },
+    },
+    inputs: 1,
+    outputs: 2,
+    icon: 'font-awesome/fa-terminal',
+    label: function () {
+      return this.name || 'tunnel command';
+    },
+    labelStyle: function () {
+      return this.name ? 'node_label_italic' : '';
+    },
+  });
+</script>

package/nodes/wsTunnel.js

@@ -13,9 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  **/
-
-const { startWebSocketServer } = require('@remotelinker/reverse-ws-tunnel/server');
-const { setLogLevel } = require('@remotelinker/reverse-ws-tunnel/utils');
+const { startWebSocketServer, stopWebSocketServer, sendCommand } = require('@remotelinker/reverse-ws-tunnel/server');
+const { logger, setLogContext, setLogLevel, getMetrics } = require('@remotelinker/reverse-ws-tunnel/utils');
 
 const instances = {};
 
@@ -45,112 +44,188 @@ module.exports = function (RED) {
 
     // Set the log level dynamically based on configuration
     const logLevel = node.tunnelConfig.options.logLevel || 'info';
+    setLogContext('TunnelNode-' + node.tunnelConfig.options.name);
     setLogLevel(logLevel);
 
     node.status({ fill: 'red', shape: 'ring', text: 'disconnected' });
-
     const port = node.tunnelConfig.options.port;
-    const host = node.tunnelConfig.options.host ? '' : undefined;
-    const path = node.tunnelConfig.options.path ? '' : undefined;
+    const host = node.tunnelConfig.options.host || undefined;
+    const path = node.tunnelConfig.options.path || undefined;
     const tunnelIdHeaderName = node.tunnelConfig.options.tunnelIdHeaderName;
-
-    instances[id] = instances[id] || { state: {} };
-
-    if (instances[id].state[port]) {
-      console.warn(`Server already running on port ${port} for node ${id}. Skipping creation.`);
-      node.status({
-        fill: 'green',
-        shape: 'dot',
-        text: `listening on port ${port}`,
+    instances[id] = instances[id] || {};
+    const pendingConnections = new Map();
+    const confirmedConnections = new Map();
+    // Cleanup any existing server on this port before starting
+    // This handles cases where previous deployment didn't cleanup properly
+    stopWebSocketServer(port)
+      .then(() => {
+        logger.info(`Cleaned up any existing server on port ${port} before starting`);
+        return startWebSocketServer({
+          port,
+          host,
+          path,
+          tunnelIdHeaderName,
+        });
+      })
+      .then((state) => {
+        instances[id].state = state;
+        logger.info(`Started WebSocketServer for node ${id} on port ${port}`);
+        if (instances[id].state[port].webSocketServer) {
+          onListening();
+        }
+      })
+      .catch((err) => {
+        logger.error(`Error starting WebSocketServer on port ${port}:`, err);
+        node.status({
+          fill: 'red',
+          shape: 'dot',
+          text: `error: ${err.message}`,
+        });
       });
-      return;
-    }
-
-    instances[id].state = startWebSocketServer({
-      port,
-      host,
-      path,
-      tunnelIdHeaderName,
-    });
-
-    console.log(`Started WebSocketServer for node ${id} on port ${port}`);
-
-    if (instances[id].state[port].webSocketServer) {
-      onListening();
-    }
-
     function onListening() {
       const server = instances[id].state[port].webSocketServer;
-
       server.on('listening', () => {
-        console.log('Listening ' + id);
+        logger.info('Listening ' + id);
         node.status({
           fill: 'green',
           shape: 'dot',
           text: `listening on port ${port}`,
         });
       });
-
       server.on('connection', (ws) => {
         const clientAddress = ws._socket.remoteAddress;
         const clientPort = ws._socket.remotePort;
         const totalClients = server.clients.size;
-
         node.status({
           fill: 'green',
           shape: 'dot',
           text: `clients ${totalClients}`,
         });
-
-        console.log(`WebSocket connection from ${clientAddress}:${clientPort}`);
-        console.log(`Total connected clients: ${totalClients}`);
+        logger.info(`WebSocket connection from ${clientAddress}:${clientPort}`);
+        logger.info(`Total connected clients: ${totalClients}`);
+
+        const connectedAt = Date.now();
+        pendingConnections.set(ws, { remoteAddress: clientAddress, connectedAt });
+
+        const onFirstMessage = () => {
+          ws.removeListener('message', onFirstMessage);
+          setImmediate(() => {
+            const tunnels =
+              instances[id]?.state?.[port]?.websocketTunnels || {};
+            for (const [tunnelId, tunnel] of Object.entries(tunnels)) {
+              if (tunnel.ws === ws) {
+                const pending = pendingConnections.get(ws);
+                if (pending) {
+                  pendingConnections.delete(ws);
+                  confirmedConnections.set(ws, {
+                    tunnelId,
+                    remoteAddress: pending.remoteAddress,
+                    connectedAt: pending.connectedAt,
+                  });
+                  node.send({
+                    event: 'connect',
+                    tunnelId,
+                    remoteAddress: pending.remoteAddress,
+                    connectedAt: pending.connectedAt,
+                    serverPort: port,
+                  });
+                }
+                return;
+              }
+            }
+          });
+        };
+        ws.on('message', onFirstMessage);
 
         ws.on('close', () => {
+          const confirmed = confirmedConnections.get(ws);
+          confirmedConnections.delete(ws);
+          pendingConnections.delete(ws);
+
           const remainingClients = server.clients.size;
           node.status({
             fill: 'green',
             shape: 'dot',
             text: `clients ${remainingClients}`,
           });
-          console.log(`Client disconnected: ${clientAddress}:${clientPort}`);
-          console.log(`Remaining clients: ${remainingClients}`);
+          logger.info(`Client disconnected: ${clientAddress}:${clientPort}`);
+          logger.info(`Remaining clients: ${remainingClients}`);
+
+          if (confirmed) {
+            node.send({
+              event: 'disconnect',
+              tunnelId: confirmed.tunnelId,
+              remoteAddress: confirmed.remoteAddress,
+              serverPort: port,
+            });
+          }
         });
       });
     }
 
-    this.on('close', function (removed, done) {
-      if (instances[id] && instances[id].state && instances[id].state[port]) {
-        const server = instances[id].state[port].webSocketServer;
-        if (server) {
-          try {
-            for (const client of server.clients) {
-              try {
-                client.removeAllListeners();
-                client.close();
-              } catch (clientErr) {
-                console.error(`Error terminating client on port ${port}:`, clientErr);
-              }
-            }
+    node.on('input', function (msg) {
+      const snapshot = getMetrics().snapshot();
+      msg.payload = snapshot;
+      msg.event = 'metrics';
+      msg.serverPort = port;
+      node.send(msg);
+    });
 
-            server.close(() => {
-              console.log(`Closed WebSocketServer on port ${port} during node shutdown`);
-            });
-          } catch (err) {
-            console.error(`Error closing WebSocketServer on port ${port}:`, err);
-          }
-        }
+    this.on('close', function (removed, done) {
+      logger.debug(`Close called for node ${id}, removed=${removed}`);
+      pendingConnections.clear();
+      confirmedConnections.clear();
 
-        delete instances[id].state[port];
+      if (instances[id] && instances[id].state && instances[id].state[port]) {
+        stopWebSocketServer(port)
+          .then(() => {
+            logger.info(`Cleaned up WebSocketServer on port ${port} for node ${id}`);
+            delete instances[id];
+            done();
+          })
+          .catch((err) => {
+            logger.error(`Error stopping server on port ${port}:`, err);
+            delete instances[id];
+            done();
+          });
+      } else {
+        logger.info(`No server state found for node ${id} on port ${port}`);
+        done();
+      }
+    });
+  }
+  RED.nodes.registerType('wstunnel server', WSTunnelServer);
 
-        // Se non ci sono più porte attive per questo nodo, cancella del tutto
-        if (Object.keys(instances[id].state).length === 0) {
-          delete instances[id];
-        }
+  function WSTunnelCommand(n) {
+    RED.nodes.createNode(this, n);
+    const node = this;
+    node.tunnelConfig = RED.nodes.getNode(n.wstunnel);
+
+    node.on('input', function (msg) {
+      const port = node.tunnelConfig.options.port;
+      const tunnelId = msg.tunnelId || (msg.payload && msg.payload.tunnelId);
+      const command = msg.command || (msg.payload && msg.payload.command);
+      const args = msg.args || (msg.payload && msg.payload.args) || {};
+
+      if (!tunnelId || !command) {
+        node.error('Missing tunnelId or command');
+        msg.payload = false;
+        msg.sent = false;
+        msg.error = 'Missing tunnelId or command';
+        node.send([null, msg]);
+        return;
       }
 
-      done();
+      const sent = sendCommand(port, tunnelId, command, args);
+      msg.payload = sent;
+      msg.sent = sent;
+      msg.tunnelId = tunnelId;
+      msg.command = command;
+      if (!sent) {
+        msg.error = 'Tunnel not found or not connected';
+      }
+      node.send([sent ? msg : null, sent ? null : msg]);
     });
   }
-
-  RED.nodes.registerType('wstunnel server', WSTunnelServer);
+  RED.nodes.registerType('wstunnel command', WSTunnelCommand);
 };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@yousolution/node-red-contrib-you-tunnel-websocket",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Module to create websockeet tunnel for NODE-RED",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "scripts": {
     "update": "PACKAGE_NAME=$(npm pack) && mv $PACKAGE_NAME ./data && cd data && rm -rf node_modules && npm i $PACKAGE_NAME  && docker-compose restart",
-    "test": "mocha 'test/**/*.spec.js'",
+    "test": "jest --verbose",
     "coverage": "nyc npm run test"
   },
   "keywords": [
@@ -23,15 +23,7 @@
     }
   },
   "dependencies": {
-    "@remotelinker/reverse-ws-tunnel": "^1.0.10",
-    "cookie": "^1.0.2",
-    "cross-conf-env": "^1.3.0",
-    "dotenv": "^17.2.1",
-    "express": "^4.21.2",
-    "http-parser-js": "^0.5.10",
-    "http-proxy": "^1.18.1",
-    "uuid": "^11.1.0",
-    "ws": "^8.18.0"
+    "@remotelinker/reverse-ws-tunnel": "^1.2.0"
   },
   "repository": {
     "type": "git",

package/test/ki-001-host-path-passthrough.test.js

@@ -0,0 +1,187 @@
+/**
+ * KI-001 — Inverted host/path Default Logic (Regression Test)
+ *
+ * This test proves that configured host and path values are discarded
+ * by the current ternary logic in WSTunnelServer.
+ *
+ * Expected behavior after fix:
+ *   - host: '0.0.0.0' is passed through to startWebSocketServer
+ *   - path: '/api/tunnel' is passed through to startWebSocketServer
+ *
+ * Current (defective) behavior:
+ *   - host: '0.0.0.0' becomes ''
+ *   - path: '/api/tunnel' becomes ''
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+// Mock stopWebSocketServer — resolves synchronously to avoid timing issues
+const mockStopWebSocketServer = jest.fn(() => Promise.resolve());
+
+// Mock startWebSocketServer — captures the options passed to it
+const mockStartWebSocketServer = jest.fn((opts) =>
+  Promise.resolve({
+    [opts.port]: {
+      webSocketServer: {
+        on: jest.fn(),
+        clients: new Set(),
+      },
+    },
+  })
+);
+
+// Mock logger
+const mockLogger = {
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn(),
+  trace: jest.fn(),
+};
+
+// Mock setLogContext and setLogLevel
+const mockSetLogContext = jest.fn();
+const mockSetLogLevel = jest.fn();
+
+// Creates a mock RED object with configurable getNode return value
+function createMockRED(configOverrides = {}) {
+  const registeredTypes = {};
+  const defaultConfig = {
+    name: 'test-tunnel',
+    host: 'localhost',
+    port: 1880,
+    path: '',
+    tunnelIdHeaderName: 'x-tunnel-id',
+    logLevel: 'info',
+  };
+  return {
+    nodes: {
+      createNode: jest.fn((node, config) => {
+        node.status = jest.fn();
+        node.on = jest.fn((event, handler) => {
+          node._handlers = node._handlers || {};
+          node._handlers[event] = handler;
+        });
+      }),
+      registerType: jest.fn((type, constructor) => {
+        registeredTypes[type] = constructor;
+      }),
+      getNode: jest.fn(() => ({
+        options: { ...defaultConfig, ...configOverrides },
+      })),
+    },
+    _registeredTypes: registeredTypes,
+  };
+}
+
+// Flush the promise chain: stopWebSocketServer().then(startWebSocketServer(...))
+async function flushPromises() {
+  // Advance past setImmediate and all microtasks
+  await new Promise((resolve) => {
+    setImmediate(resolve);
+  });
+  // One more tick to handle the chained .then()
+  await new Promise((resolve) => {
+    setImmediate(resolve);
+  });
+}
+
+describe('KI-001 — host/path value passthrough (regression)', () => {
+  beforeAll(() => {
+    const serverModule = require('@remotelinker/reverse-ws-tunnel/server');
+    serverModule.stopWebSocketServer = mockStopWebSocketServer;
+    serverModule.startWebSocketServer = mockStartWebSocketServer;
+
+    const utilsModule = require('@remotelinker/reverse-ws-tunnel/utils');
+    utilsModule.logger = mockLogger;
+    utilsModule.setLogContext = mockSetLogContext;
+    utilsModule.setLogLevel = mockSetLogLevel;
+  });
+
+  beforeEach(() => {
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockLogger.info.mockClear();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  test('configured host "0.0.0.0" is passed through to startWebSocketServer', async () => {
+    const RED = createMockRED({ host: '0.0.0.0' });
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = {};
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await flushPromises();
+
+    expect(mockStartWebSocketServer).toHaveBeenCalledTimes(1);
+    const passedOptions = mockStartWebSocketServer.mock.calls[0][0];
+
+    // ASSERTION: host must be '0.0.0.0', not ''
+    // This FAILS with current code because the ternary converts truthy → ''
+    expect(passedOptions.host).toBe('0.0.0.0');
+  });
+
+  test('configured path "/api/tunnel" is passed through to startWebSocketServer', async () => {
+    const RED = createMockRED({ path: '/api/tunnel' });
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = {};
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await flushPromises();
+
+    expect(mockStartWebSocketServer).toHaveBeenCalledTimes(1);
+    const passedOptions = mockStartWebSocketServer.mock.calls[0][0];
+
+    // ASSERTION: path must be '/api/tunnel', not ''
+    // This FAILS with current code because the ternary converts truthy → ''
+    expect(passedOptions.path).toBe('/api/tunnel');
+  });
+
+  test('empty path becomes undefined (semantically equivalent to unset)', async () => {
+    const RED = createMockRED({ path: '' });
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = {};
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await flushPromises();
+
+    expect(mockStartWebSocketServer).toHaveBeenCalledTimes(1);
+    const passedOptions = mockStartWebSocketServer.mock.calls[0][0];
+
+    // ASSERTION: empty path should become undefined (ws library default = accept all)
+    // The ws library treats undefined/null the same as falsy for path filtering
+    expect(passedOptions.path).toBeUndefined();
+  });
+
+  test('both host and path are passed through simultaneously', async () => {
+    const RED = createMockRED({ host: '0.0.0.0', path: '/api/tunnel' });
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = {};
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await flushPromises();
+
+    expect(mockStartWebSocketServer).toHaveBeenCalledTimes(1);
+    const passedOptions = mockStartWebSocketServer.mock.calls[0][0];
+
+    // ASSERTION: both values must be preserved
+    // This FAILS with current code — both become ''
+    expect(passedOptions.host).toBe('0.0.0.0');
+    expect(passedOptions.path).toBe('/api/tunnel');
+  });
+});