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

package/test/ki-002-tunnel-id-header-default.test.js

@@ -0,0 +1,60 @@
+/**
+ * KI-002 — tunnelIdHeaderName Default Mismatch (Regression Test)
+ *
+ * This test proves that the HTML editor default for tunnelIdHeaderName
+ * ('') does not match the constructor default ('x-tunnel-id').
+ *
+ * Expected behavior after fix:
+ *   - HTML default is 'x-tunnel-id', matching the constructor and documentation.
+ *
+ * Current (defective) behavior:
+ *   - HTML default is '', which is inconsistent.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const HTML_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.html');
+const JS_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+describe('KI-002 — tunnelIdHeaderName default consistency (regression)', () => {
+  let htmlContent;
+  let jsContent;
+
+  beforeAll(() => {
+    htmlContent = fs.readFileSync(HTML_PATH, 'utf8');
+    jsContent = fs.readFileSync(JS_PATH, 'utf8');
+  });
+
+  test('HTML wstunnel registration default for tunnelIdHeaderName is "x-tunnel-id"', () => {
+    const match = htmlContent.match(
+      /tunnelIdHeaderName:\s*\{\s*value:\s*['"]([^'"]*)['"]\s*\}/
+    );
+    expect(match).not.toBeNull();
+
+    // ASSERTION: HTML default must be 'x-tunnel-id'
+    // This FAILS with current code because HTML default is ''
+    expect(match[1]).toBe('x-tunnel-id');
+  });
+
+  test('constructor default for tunnelIdHeaderName is "x-tunnel-id"', () => {
+    const match = jsContent.match(
+      /tunnelIdHeaderName:\s*n\.tunnelIdHeaderName\s*\|\|\s*['"]([^'"]*)['"]/
+    );
+    expect(match).not.toBeNull();
+    expect(match[1]).toBe('x-tunnel-id');
+  });
+
+  test('HTML and constructor defaults for tunnelIdHeaderName are identical', () => {
+    const htmlMatch = htmlContent.match(
+      /tunnelIdHeaderName:\s*\{\s*value:\s*['"]([^'"]*)['"]\s*\}/
+    );
+    const jsMatch = jsContent.match(
+      /tunnelIdHeaderName:\s*n\.tunnelIdHeaderName\s*\|\|\s*['"]([^'"]*)['"]/
+    );
+
+    expect(htmlMatch).not.toBeNull();
+    expect(jsMatch).not.toBeNull();
+    expect(htmlMatch[1]).toBe(jsMatch[1]);
+  });
+});

package/test/ki-003-debug-log-level.test.js

@@ -0,0 +1,180 @@
+/**
+ * KI-003 — Leftover Debug Log Statement (Regression Test)
+ *
+ * This test proves that the close handler logs a [DEBUG] message at info level
+ * instead of using logger.debug() without the [DEBUG] prefix.
+ *
+ * Expected behavior after fix:
+ *   - Close handler logs at debug level (not info)
+ *   - Message does not contain [DEBUG] prefix
+ *
+ * Current (defective) behavior:
+ *   - Close handler logs at info level with [DEBUG] prefix
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+// Mock stopWebSocketServer
+const mockStopWebSocketServer = jest.fn(() => Promise.resolve());
+
+// 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,
+  };
+}
+
+function createNode(RED) {
+  const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+  const node = {};
+  WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+  return node;
+}
+
+describe('KI-003 — close handler debug log level (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();
+    mockLogger.debug.mockClear();
+    mockLogger.warn.mockClear();
+    mockLogger.error.mockClear();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  test('close handler does NOT log [DEBUG] at info level', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Both mocks are pre-resolved; microtask flush is sufficient
+    await Promise.resolve();
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    mockLogger.info.mockClear();
+
+    node._handlers.close.call(node, false, done);
+
+    // Close handler logs synchronously; microtask flush ensures done() path is reached
+    await Promise.resolve();
+
+    // ASSERTION: info must NOT be called with [DEBUG] prefix
+    // This FAILS with current code because line 117 uses logger.info('[DEBUG]...')
+    const infoCalls = mockLogger.info.mock.calls.map((c) => c[0]);
+    expect(infoCalls.some((msg) => msg.includes('[DEBUG]'))).toBe(false);
+  });
+
+  test('close handler logs close message at debug level', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Both mocks are pre-resolved; microtask flush is sufficient
+    await Promise.resolve();
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    mockLogger.debug.mockClear();
+
+    node._handlers.close.call(node, false, done);
+
+    // Close handler logs synchronously; microtask flush ensures done() path is reached
+    await Promise.resolve();
+
+    // ASSERTION: debug must be called with close message
+    // This FAILS with current code because the message is at info level, not debug
+    const debugCalls = mockLogger.debug.mock.calls.map((c) => c[0]);
+    expect(debugCalls.some((msg) => msg.includes('Close called for node'))).toBe(true);
+  });
+
+  test('close message does not contain [DEBUG] prefix', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Both mocks are pre-resolved; microtask flush is sufficient
+    await Promise.resolve();
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    mockLogger.debug.mockClear();
+
+    node._handlers.close.call(node, false, done);
+
+    // Close handler logs synchronously; microtask flush ensures done() path is reached
+    await Promise.resolve();
+
+    // ASSERTION: debug message must not contain [DEBUG] prefix
+    const debugCalls = mockLogger.debug.mock.calls.map((c) => c[0]);
+    const closeMsg = debugCalls.find((msg) => msg.includes('Close called for node'));
+    if (closeMsg) {
+      expect(closeMsg).not.toContain('[DEBUG]');
+    }
+  });
+});

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);
+  });
+});