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

package/test/start-failure-path.test.js

@@ -0,0 +1,212 @@
+/**
+ * Start Failure Path — startWebSocketServer rejection during construction
+ *
+ * This test proves that when startWebSocketServer() rejects during
+ * WSTunnelServer construction, the error is caught and logged via
+ * logger.error(), not lost as an unhandled rejection.
+ *
+ * Production code (wsTunnel.js lines 75-82):
+ *   .catch((err) => {
+ *     logger.error(`Error starting WebSocketServer on port ${port}:`, err);
+ *     node.status({ fill: 'red', shape: 'dot', text: `error: ${err.message}` });
+ *   });
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+// Mock stopWebSocketServer — resolves successfully
+const mockStopWebSocketServer = jest.fn(() => Promise.resolve());
+
+// Mock startWebSocketServer — rejects with a controlled error
+const START_ERROR = new Error('EADDRINUSE: port 1880 already in use');
+let mockStartRejects = false;
+
+const mockStartWebSocketServer = jest.fn((opts) => {
+  if (mockStartRejects) {
+    return Promise.reject(START_ERROR);
+  }
+  return 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();
+
+// Mock RED object
+function createMockRED() {
+  const registeredTypes = {};
+  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: {
+          name: 'test-tunnel',
+          host: 'localhost',
+          port: 1880,
+          path: '',
+          tunnelIdHeaderName: 'x-tunnel-id',
+          logLevel: 'info',
+        },
+      })),
+    },
+    _registeredTypes: registeredTypes,
+  };
+}
+
+describe('Start failure path — startWebSocketServer rejection', () => {
+  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(() => {
+    mockStartRejects = false;
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockLogger.info.mockClear();
+    mockLogger.error.mockClear();
+    mockLogger.debug.mockClear();
+    mockLogger.warn.mockClear();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  test('startWebSocketServer rejection is caught and logged via logger.error', async () => {
+    mockStartRejects = true;
+
+    const RED = createMockRED();
+    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' });
+
+    // Flush stopWebSocketServer().then(startWebSocketServer().catch())
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // ASSERTION: logger.error must be called with the start failure message
+    expect(mockLogger.error).toHaveBeenCalled();
+    const errorCalls = mockLogger.error.mock.calls.map((c) => c[0]);
+    expect(errorCalls.some((msg) => msg.includes('Error starting WebSocketServer'))).toBe(true);
+  });
+
+  test('the original error is passed to logger.error as the second argument', async () => {
+    mockStartRejects = true;
+
+    const RED = createMockRED();
+    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 new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // ASSERTION: The error object itself is passed (not just the message string)
+    const errorCalls = mockLogger.error.mock.calls.filter((c) =>
+      c[0].includes('Error starting WebSocketServer')
+    );
+    expect(errorCalls.length).toBe(1);
+    expect(errorCalls[0][1]).toBe(START_ERROR);
+  });
+
+  test('node.status is set to error state with the error message', async () => {
+    mockStartRejects = true;
+
+    const RED = createMockRED();
+    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 new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // ASSERTION: node.status was called with error state
+    expect(node.status).toHaveBeenCalledWith({
+      fill: 'red',
+      shape: 'dot',
+      text: `error: ${START_ERROR.message}`,
+    });
+  });
+
+  test('stopWebSocketServer still runs before start failure is handled', async () => {
+    mockStartRejects = true;
+
+    const RED = createMockRED();
+    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 new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // ASSERTION: stopWebSocketServer was called (cleanup runs before start)
+    expect(mockStopWebSocketServer).toHaveBeenCalled();
+    // ASSERTION: startWebSocketServer was called (it rejected)
+    expect(mockStartWebSocketServer).toHaveBeenCalled();
+  });
+
+  test('successful start does not log error', async () => {
+    mockStartRejects = false;
+
+    const RED = createMockRED();
+    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 new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // ASSERTION: logger.error must NOT be called for successful start
+    const errorCalls = mockLogger.error.mock.calls.filter((c) =>
+      c[0].includes('Error starting WebSocketServer')
+    );
+    expect(errorCalls.length).toBe(0);
+  });
+});

package/test/wstunnel-command.test.js

@@ -0,0 +1,203 @@
+/**
+ * wstunnel command — Regression Test
+ *
+ * Tests that the wstunnel command node correctly sends commands to tunnel
+ * clients via sendCommand(), routes success to output 0, failure to output 1,
+ * and validates input parameters.
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+const PORT = 4443;
+
+const mockLogger = {
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn(),
+  trace: jest.fn(),
+};
+const mockSetLogContext = jest.fn();
+const mockSetLogLevel = jest.fn();
+
+function createMockRED() {
+  const registeredTypes = {};
+  return {
+    nodes: {
+      createNode: jest.fn((node) => {
+        if (!node.id) node.id = 'node-' + Math.random().toString(36).slice(2, 9);
+        node.status = jest.fn();
+        node.send = jest.fn();
+        node.error = 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: {
+          name: 'test-tunnel',
+          host: 'localhost',
+          port: PORT,
+          path: '',
+          tunnelIdHeaderName: 'x-tunnel-id',
+          logLevel: 'info',
+        },
+      })),
+    },
+    _registeredTypes: registeredTypes,
+  };
+}
+
+describe('wstunnel command', () => {
+  let mockSendCommand;
+
+  beforeAll(() => {
+    mockSendCommand = jest.fn();
+
+    const serverModule = require('@remotelinker/reverse-ws-tunnel/server');
+    serverModule.sendCommand = mockSendCommand;
+
+    const utilsModule = require('@remotelinker/reverse-ws-tunnel/utils');
+    utilsModule.logger = mockLogger;
+    utilsModule.setLogContext = mockSetLogContext;
+    utilsModule.setLogLevel = mockSetLogLevel;
+  });
+
+  beforeEach(() => {
+    mockSendCommand.mockReset();
+    mockSendCommand.mockReturnValue(true);
+    mockLogger.error.mockClear();
+  });
+
+  test('sends command to output 0 when sendCommand returns true', () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelCommand = RED._registeredTypes['wstunnel command'];
+    expect(WSTunnelCommand).toBeDefined();
+
+    const node = {};
+    WSTunnelCommand.call(node, { wstunnel: 'test-config-id', name: 'cmd' });
+
+    expect(node.on).toHaveBeenCalledWith('input', expect.any(Function));
+
+    const inputHandler = node._handlers['input'];
+    const msg = { payload: { tunnelId: 'tunnel-001', command: 'kill' } };
+    inputHandler.call(node, msg);
+
+    expect(mockSendCommand).toHaveBeenCalledWith(PORT, 'tunnel-001', 'kill', {});
+    expect(node.send).toHaveBeenCalledTimes(1);
+    expect(node.send).toHaveBeenCalledWith([msg, null]);
+    expect(msg.payload).toBe(true);
+    expect(msg.sent).toBe(true);
+    expect(msg.tunnelId).toBe('tunnel-001');
+    expect(msg.command).toBe('kill');
+  });
+
+  test('sends command to output 1 when sendCommand returns false', () => {
+    mockSendCommand.mockReturnValue(false);
+
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelCommand = RED._registeredTypes['wstunnel command'];
+    const node = {};
+    WSTunnelCommand.call(node, { wstunnel: 'test-config-id', name: 'cmd' });
+
+    const inputHandler = node._handlers['input'];
+    const msg = { payload: { tunnelId: 'tunnel-001', command: 'kill' } };
+    inputHandler.call(node, msg);
+
+    expect(node.send).toHaveBeenCalledTimes(1);
+    expect(node.send).toHaveBeenCalledWith([null, msg]);
+    expect(msg.payload).toBe(false);
+    expect(msg.sent).toBe(false);
+    expect(msg.error).toBe('Tunnel not found or not connected');
+  });
+
+  test('sends to output 1 when tunnelId is missing', () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelCommand = RED._registeredTypes['wstunnel command'];
+    const node = {};
+    WSTunnelCommand.call(node, { wstunnel: 'test-config-id', name: 'cmd' });
+
+    const inputHandler = node._handlers['input'];
+    const msg = { payload: { command: 'kill' } };
+    inputHandler.call(node, msg);
+
+    expect(mockSendCommand).not.toHaveBeenCalled();
+    expect(node.send).toHaveBeenCalledTimes(1);
+    expect(node.send).toHaveBeenCalledWith([null, msg]);
+    expect(msg.payload).toBe(false);
+    expect(msg.sent).toBe(false);
+    expect(msg.error).toBe('Missing tunnelId or command');
+    expect(node.error).toHaveBeenCalledWith('Missing tunnelId or command');
+  });
+
+  test('sends to output 1 when command is missing', () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelCommand = RED._registeredTypes['wstunnel command'];
+    const node = {};
+    WSTunnelCommand.call(node, { wstunnel: 'test-config-id', name: 'cmd' });
+
+    const inputHandler = node._handlers['input'];
+    const msg = { payload: { tunnelId: 'tunnel-001' } };
+    inputHandler.call(node, msg);
+
+    expect(mockSendCommand).not.toHaveBeenCalled();
+    expect(node.send).toHaveBeenCalledTimes(1);
+    expect(node.send).toHaveBeenCalledWith([null, msg]);
+    expect(msg.payload).toBe(false);
+    expect(msg.sent).toBe(false);
+    expect(msg.error).toBe('Missing tunnelId or command');
+  });
+
+  test('reads tunnelId and command from msg top-level properties', () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelCommand = RED._registeredTypes['wstunnel command'];
+    const node = {};
+    WSTunnelCommand.call(node, { wstunnel: 'test-config-id', name: 'cmd' });
+
+    const inputHandler = node._handlers['input'];
+    const msg = { tunnelId: 't-42', command: 'restart', payload: {} };
+    inputHandler.call(node, msg);
+
+    expect(mockSendCommand).toHaveBeenCalledWith(PORT, 't-42', 'restart', {});
+    expect(node.send).toHaveBeenCalledWith([msg, null]);
+    expect(msg.tunnelId).toBe('t-42');
+    expect(msg.command).toBe('restart');
+  });
+
+  test('passes args from msg to sendCommand', () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelCommand = RED._registeredTypes['wstunnel command'];
+    const node = {};
+    WSTunnelCommand.call(node, { wstunnel: 'test-config-id', name: 'cmd' });
+
+    const inputHandler = node._handlers['input'];
+    const msg = { payload: { tunnelId: 't-007', command: 'exec', args: { cmd: 'ls' } } };
+    inputHandler.call(node, msg);
+
+    expect(mockSendCommand).toHaveBeenCalledWith(PORT, 't-007', 'exec', { cmd: 'ls' });
+  });
+});

package/test/wstunnel-metrics-input.test.js

@@ -0,0 +1,234 @@
+/**
+ * wstunnel server — Metrics Input (Regression Test)
+ *
+ * Tests that the wstunnel server node emits a metrics snapshot on its output
+ * when any message is received on its input.
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+const PORT = 1880;
+
+const mockSnapshot = {
+  label: 'tunnel',
+  ts: new Date().toISOString(),
+  active_tunnels: 2,
+  active_tunnel_ids: ['tunnel-001', 'tunnel-002'],
+  active_streams: 5,
+  bytes_in_total: 1024000,
+  bytes_out_total: 512000,
+  backpressure_events_total: 3,
+  buffered_bytes_total: 4096,
+  buffered_bytes_per_tunnel: { 'tunnel-001': 2048, 'tunnel-002': 2048 },
+  frame_too_large_total: 0,
+  tunnel_disconnect_total: 1,
+  heartbeat_timeout_total: 0,
+  stream_stall_cleanup_total: 0,
+  event_loop_lag_ms: { p50: 1.2, p99: 8.5 },
+  tunnels_detail: {
+    'tunnel-001': {
+      connectedAt: 1725974400000,
+      remoteAddress: '192.168.1.10',
+      streamCount: 3,
+      peakStreamCount: 5,
+      bytesIn: 600000,
+      bytesOut: 300000,
+      agentVersion: '1.0.0',
+    },
+  },
+};
+
+const mockStopWebSocketServer = jest.fn(() => Promise.resolve());
+const mockStartWebSocketServer = jest.fn((opts) => {
+  return Promise.resolve({
+    [opts.port]: {
+      webSocketServer: {
+        on: jest.fn(),
+        clients: new Set(),
+      },
+      websocketTunnels: {},
+    },
+  });
+});
+
+const mockGetMetrics = jest.fn(() => ({
+  snapshot: jest.fn(() => mockSnapshot),
+}));
+
+const mockLogger = {
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn(),
+  trace: jest.fn(),
+};
+const mockSetLogContext = jest.fn();
+const mockSetLogLevel = jest.fn();
+
+function createMockRED() {
+  const registeredTypes = {};
+  return {
+    nodes: {
+      createNode: jest.fn((node) => {
+        if (!node.id) node.id = 'node-' + Math.random().toString(36).slice(2, 9);
+        node.status = jest.fn();
+        node.send = 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: {
+          name: 'test-tunnel',
+          host: 'localhost',
+          port: PORT,
+          path: '',
+          tunnelIdHeaderName: 'x-tunnel-id',
+          logLevel: 'info',
+        },
+      })),
+    },
+    _registeredTypes: registeredTypes,
+  };
+}
+
+describe('wstunnel server — metrics input', () => {
+  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;
+    utilsModule.getMetrics = mockGetMetrics;
+  });
+
+  beforeEach(() => {
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockGetMetrics.mockClear();
+    mockGetMetrics.mockReturnValue({ snapshot: jest.fn(() => mockSnapshot) });
+    mockLogger.info.mockClear();
+    mockLogger.error.mockClear();
+    mockLogger.debug.mockClear();
+  });
+
+  test('emits metrics snapshot when input message is received', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = { id: 'testNode' };
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const inputHandler = node._handlers['input'];
+    expect(inputHandler).toBeDefined();
+
+    const msg = { payload: {} };
+    inputHandler.call(node, msg);
+
+    expect(mockGetMetrics).toHaveBeenCalled();
+    expect(node.send).toHaveBeenCalledTimes(1);
+    expect(node.send).toHaveBeenCalledWith(msg);
+    expect(msg.event).toBe('metrics');
+    expect(msg.serverPort).toBe(PORT);
+    expect(msg.payload).toEqual(mockSnapshot);
+  });
+
+  test('snapshot contains all expected fields', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = { id: 'testNode' };
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const inputHandler = node._handlers['input'];
+    const msg = {};
+    inputHandler.call(node, msg);
+
+    const snapshot = msg.payload;
+    expect(snapshot).toHaveProperty('active_tunnels');
+    expect(snapshot).toHaveProperty('active_tunnel_ids');
+    expect(snapshot).toHaveProperty('active_streams');
+    expect(snapshot).toHaveProperty('bytes_in_total');
+    expect(snapshot).toHaveProperty('bytes_out_total');
+    expect(snapshot).toHaveProperty('event_loop_lag_ms');
+    expect(snapshot).toHaveProperty('tunnels_detail');
+    expect(snapshot).toHaveProperty('ts');
+  });
+
+  test('returns zeroed snapshot when no tunnels are active', async () => {
+    const zeroSnapshot = {
+      label: 'tunnel',
+      ts: new Date().toISOString(),
+      active_tunnels: 0,
+      active_tunnel_ids: [],
+      active_streams: 0,
+      bytes_in_total: 0,
+      bytes_out_total: 0,
+      backpressure_events_total: 0,
+      buffered_bytes_total: 0,
+      buffered_bytes_per_tunnel: {},
+      frame_too_large_total: 0,
+      tunnel_disconnect_total: 0,
+      heartbeat_timeout_total: 0,
+      stream_stall_cleanup_total: 0,
+      event_loop_lag_ms: { p50: 0, p99: 0 },
+      tunnels_detail: {},
+    };
+    mockGetMetrics.mockReturnValue({ snapshot: jest.fn(() => zeroSnapshot) });
+
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = { id: 'testNode' };
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const inputHandler = node._handlers['input'];
+    const msg = {};
+    inputHandler.call(node, msg);
+
+    expect(msg.payload.active_tunnels).toBe(0);
+    expect(msg.payload.active_tunnel_ids).toEqual([]);
+    expect(msg.payload.tunnels_detail).toEqual({});
+  });
+
+  test('msg.event is "metrics" to distinguish from connect/disconnect', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    const node = { id: 'testNode' };
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const inputHandler = node._handlers['input'];
+    const msg = {};
+    inputHandler.call(node, msg);
+
+    expect(msg.event).toBe('metrics');
+    expect(msg.event).not.toBe('connect');
+    expect(msg.event).not.toBe('disconnect');
+  });
+});