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

package/test/ki-004-console-error-usage.test.js

@@ -0,0 +1,144 @@
+/**
+ * KI-004 — console.error in Production Code (Regression Test)
+ *
+ * This test proves that the stop-failure error path uses console.error()
+ * instead of logger.error(), bypassing log level filtering and context.
+ *
+ * Expected behavior after fix:
+ *   - Stop failure is logged via logger.error(), not console.error()
+ *
+ * Current (defective) behavior:
+ *   - Stop failure is logged via console.error()
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+// Mock state
+let mockStopResolved = true;
+
+// Mock stopWebSocketServer
+const mockStopWebSocketServer = jest.fn((port) => {
+  return new Promise((resolve, reject) => {
+    setImmediate(() => {
+      if (mockStopResolved) {
+        resolve();
+      } else {
+        reject(new Error('Stop failed'));
+      }
+    });
+  });
+});
+
+// Mock startWebSocketServer
+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();
+
+// 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('KI-004 — error logging mechanism (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(() => {
+    mockStopResolved = true;
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockLogger.info.mockClear();
+    mockLogger.debug.mockClear();
+    mockLogger.error.mockClear();
+    mockLogger.warn.mockClear();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  test('stop failure is logged via logger.error, not console.error', async () => {
+    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' });
+
+    // Wait for constructor to succeed and set instances[id].state
+    // mockStopWebSocketServer resolves via setImmediate
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // Now make stop fail
+    mockStopResolved = false;
+
+    const done = jest.fn();
+    mockLogger.error.mockClear();
+
+    node._handlers.close.call(node, false, done);
+
+    // Wait for close handler promise chain
+    // mockStopWebSocketServer rejects via setImmediate
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // ASSERTION: logger.error must be called with the error message
+    // This FAILS with current code because console.error is used instead
+    expect(mockLogger.error).toHaveBeenCalled();
+    const errorCalls = mockLogger.error.mock.calls.map((c) => c[0]);
+    expect(errorCalls.some((msg) => msg.includes('Error stopping server'))).toBe(true);
+  });
+});

package/test/m-3-concurrent-deployment.test.js

@@ -0,0 +1,227 @@
+/**
+ * M-3 — Concurrent Deployment on Same Port (Regression Test)
+ *
+ * Documents the interleaving when two wstunnel server nodes target the same
+ * port. The second node fails with EADDRINUSE because the library's
+ * startWebSocketServer (synchronous) creates a new WebSocket.Server which
+ * throws if the port is already bound.
+ *
+ * Observable behavior:
+ *   1. Node A succeeds; Node A stores state in instances[nodeA].
+ *   2. Node B fails; Node B has no state (instances[nodeB] stays empty).
+ *   3. Node A close → calls stopWebSocketServer → cleans up.
+ *   4. Node B close → no-op (no state to clean up).
+ *
+ * RWT-001 is NOT violated: the second node never starts. The library
+ * throws EADDRINUSE, which is caught by .catch().
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+// Track which ports have been "started" — second call on same port throws
+let startedPorts = new Set();
+
+// Mock stopWebSocketServer — resolves via setImmediate (no-op, no state check)
+const mockStopWebSocketServer = jest.fn(() =>
+  new Promise((resolve) => setImmediate(resolve))
+);
+
+// Mock startWebSocketServer — succeeds first call, throws EADDRINUSE for duplicate port
+const mockStartWebSocketServer = jest.fn((opts) => {
+  const portKey = String(opts.port);
+  if (startedPorts.has(portKey)) {
+    throw new Error(`EADDRINUSE: port ${opts.port} already in use`);
+  }
+  startedPorts.add(portKey);
+  return {
+    [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(),
+};
+
+const mockSetLogContext = jest.fn();
+const mockSetLogLevel = jest.fn();
+
+function createMockRED() {
+  const registeredTypes = {};
+  return {
+    nodes: {
+      createNode: jest.fn((node, config) => {
+        if (!node.id) node.id = 'node-' + Math.random().toString(36).slice(2, 9);
+        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('M-3 — Concurrent deployment on same port', () => {
+  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(() => {
+    startedPorts = new Set();
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockLogger.info.mockClear();
+    mockLogger.error.mockClear();
+    mockLogger.debug.mockClear();
+    mockLogger.warn.mockClear();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  test('second node on same port fails with EADDRINUSE', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+
+    // Node A — succeeds
+    const nodeA = { id: 'nodeA' };
+    WSTunnelServer.call(nodeA, { wstunnel: 'test-config-id', name: 'server-A' });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // Clear logs after Node A construction
+    mockLogger.error.mockClear();
+
+    // Node B — fails (same port)
+    const nodeB = { id: 'nodeB' };
+    WSTunnelServer.call(nodeB, { wstunnel: 'test-config-id', name: 'server-B' });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // Node A started successfully — no error logged after its construction
+    const startErrors = mockLogger.error.mock.calls.filter((c) =>
+      c[0].includes('Error starting WebSocketServer')
+    );
+    expect(startErrors.length).toBe(1);
+    expect(startErrors[0][0]).toContain('1880');
+  });
+
+  test('node B close handler is a no-op after failed start', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+
+    const nodeA = { id: 'nodeA' };
+    WSTunnelServer.call(nodeA, { wstunnel: 'test-config-id', name: 'server-A' });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const nodeB = { id: 'nodeB' };
+    WSTunnelServer.call(nodeB, { wstunnel: 'test-config-id', name: 'server-B' });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const stopCountBefore = mockStopWebSocketServer.mock.calls.length;
+
+    // Close Node B — should be a no-op (no state stored)
+    const doneB = jest.fn();
+    nodeB._handlers.close.call(nodeB, false, doneB);
+    await Promise.resolve();
+
+    expect(doneB).toHaveBeenCalledTimes(1);
+    expect(mockStopWebSocketServer.mock.calls.length).toBe(stopCountBefore);
+  });
+
+  test('node A close calls stopWebSocketServer and cleans up', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+
+    const nodeA = { id: 'nodeA' };
+    WSTunnelServer.call(nodeA, { wstunnel: 'test-config-id', name: 'server-A' });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const nodeB = { id: 'nodeB' };
+    WSTunnelServer.call(nodeB, { wstunnel: 'test-config-id', name: 'server-B' });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    mockStopWebSocketServer.mockClear();
+
+    // Close Node A — should call stopWebSocketServer
+    const doneA = jest.fn();
+    nodeA._handlers.close.call(nodeA, false, doneA);
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(doneA).toHaveBeenCalledTimes(1);
+    expect(mockStopWebSocketServer).toHaveBeenCalledWith(1880);
+  });
+
+  test('total stop calls = 2 from construction + 1 from node A close', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+
+    const nodeA = { id: 'nodeA' };
+    WSTunnelServer.call(nodeA, { wstunnel: 'test-config-id', name: 'server-A' });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const nodeB = { id: 'nodeB' };
+    WSTunnelServer.call(nodeB, { wstunnel: 'test-config-id', name: 'server-B' });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // 2 stop calls from construction (both no-ops)
+    const constructionStopCalls = mockStopWebSocketServer.mock.calls.length;
+    expect(constructionStopCalls).toBe(2);
+
+    // Close both nodes
+    const doneA = jest.fn();
+    const doneB = jest.fn();
+    nodeA._handlers.close.call(nodeA, false, doneA);
+    nodeB._handlers.close.call(nodeB, false, doneB);
+
+    await new Promise((resolve) => setImmediate(resolve));
+    await Promise.resolve();
+
+    // Total: 2 (construction) + 1 (Node A close) = 3
+    expect(mockStopWebSocketServer.mock.calls.length).toBe(constructionStopCalls + 1);
+    expect(doneA).toHaveBeenCalledTimes(1);
+    expect(doneB).toHaveBeenCalledTimes(1);
+  });
+});

package/test/output-events.test.js

@@ -0,0 +1,241 @@
+/**
+ * wstunnel server — Output Events (Regression Test)
+ *
+ * Tests that the wstunnel server node emits connect and disconnect events
+ * on its output when tunnels register (CONFIG handshake) and close.
+ */
+
+const path = require('path');
+const { EventEmitter } = require('events');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+const PORT = 1880;
+const TUNNEL_ID = 'test-tunnel-uuid-001';
+
+let serverHandlers = {};
+let mockTunnels = {};
+
+const mockStopWebSocketServer = jest.fn(() => Promise.resolve());
+
+const mockStartWebSocketServer = jest.fn((opts) => {
+  serverHandlers = {};
+  mockTunnels = {};
+  return Promise.resolve({
+    [opts.port]: {
+      webSocketServer: {
+        on: jest.fn((event, handler) => {
+          serverHandlers[event] = handler;
+        }),
+        clients: new Set(),
+      },
+      websocketTunnels: mockTunnels,
+    },
+  });
+});
+
+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,
+  };
+}
+
+function createMockWs(remoteAddress = '192.168.1.10') {
+  const ws = new EventEmitter();
+  ws._socket = { remoteAddress, remotePort: 54321 };
+  ws.readyState = 1;
+  return ws;
+}
+
+describe('wstunnel server — output events', () => {
+  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(() => {
+    serverHandlers = {};
+    mockTunnels = {};
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockLogger.info.mockClear();
+    mockLogger.error.mockClear();
+    mockLogger.debug.mockClear();
+  });
+
+  test('emits connect event when tunnel registers via CONFIG', 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 mockWs = createMockWs('10.0.0.1');
+    const connectedAt = Date.now();
+
+    mockTunnels[TUNNEL_ID] = { ws: mockWs };
+
+    serverHandlers['connection'](mockWs);
+
+    mockWs.emit('message', Buffer.from('config'));
+
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(node.send).toHaveBeenCalledTimes(1);
+    expect(node.send).toHaveBeenCalledWith({
+      event: 'connect',
+      tunnelId: TUNNEL_ID,
+      remoteAddress: '10.0.0.1',
+      connectedAt: expect.any(Number),
+      serverPort: PORT,
+    });
+  });
+
+  test('emits disconnect event when registered tunnel closes', 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 mockWs = createMockWs('10.0.0.2');
+    mockTunnels[TUNNEL_ID] = { ws: mockWs };
+
+    serverHandlers['connection'](mockWs);
+    mockWs.emit('message', Buffer.from('config'));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    node.send.mockClear();
+
+    mockWs.emit('close');
+
+    expect(node.send).toHaveBeenCalledTimes(1);
+    expect(node.send).toHaveBeenCalledWith({
+      event: 'disconnect',
+      tunnelId: TUNNEL_ID,
+      remoteAddress: '10.0.0.2',
+      serverPort: PORT,
+    });
+  });
+
+  test('does not emit events for connections without CONFIG', 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 mockWs = createMockWs('10.0.0.3');
+
+    serverHandlers['connection'](mockWs);
+
+    mockWs.emit('close');
+
+    expect(node.send).not.toHaveBeenCalled();
+  });
+
+  test('connect event 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 mockWs = createMockWs('172.16.0.5');
+    mockTunnels[TUNNEL_ID] = { ws: mockWs };
+
+    serverHandlers['connection'](mockWs);
+    mockWs.emit('message', Buffer.from('config'));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const sentMsg = node.send.mock.calls[0][0];
+    expect(sentMsg).toHaveProperty('event', 'connect');
+    expect(sentMsg).toHaveProperty('tunnelId', TUNNEL_ID);
+    expect(sentMsg).toHaveProperty('remoteAddress', '172.16.0.5');
+    expect(sentMsg).toHaveProperty('connectedAt');
+    expect(typeof sentMsg.connectedAt).toBe('number');
+    expect(sentMsg).toHaveProperty('serverPort', PORT);
+  });
+
+  test('disconnect event is not emitted for unconfirmed connections', 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 mockWs = createMockWs('10.0.0.4');
+
+    serverHandlers['connection'](mockWs);
+
+    mockWs.emit('message', Buffer.from('config'));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    node.send.mockClear();
+
+    mockWs.emit('close');
+
+    expect(node.send).not.toHaveBeenCalled();
+  });
+});