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

package/test/rwt-003-runtime-editor-compatibility.test.js

@@ -0,0 +1,113 @@
+/**
+ * RWT-003 — Node Runtime/Editor Compatibility
+ *
+ * Every Node-RED node type exposed by the package must have a corresponding
+ * editor definition, and the runtime and editor definitions must refer to the
+ * same node type.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const JS_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+const HTML_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.html');
+
+function extractJsRegisterTypes(jsContent) {
+  const regex = /RED\.nodes\.registerType\(\s*['"](.+?)['"]/g;
+  const types = [];
+  let match;
+  while ((match = regex.exec(jsContent)) !== null) {
+    types.push(match[1]);
+  }
+  return types;
+}
+
+function extractHtmlTemplateNames(htmlContent) {
+  const regex = /data-template-name="(.+?)"/g;
+  const types = [];
+  let match;
+  while ((match = regex.exec(htmlContent)) !== null) {
+    types.push(match[1]);
+  }
+  return types;
+}
+
+function extractHtmlHelpNames(htmlContent) {
+  const regex = /data-help-name="(.+?)"/g;
+  const types = [];
+  let match;
+  while ((match = regex.exec(htmlContent)) !== null) {
+    types.push(match[1]);
+  }
+  return types;
+}
+
+function extractHtmlRegisterTypes(htmlContent) {
+  const regex = /RED\.nodes\.registerType\(\s*['"](.+?)['"]/g;
+  const types = [];
+  let match;
+  while ((match = regex.exec(htmlContent)) !== null) {
+    types.push(match[1]);
+  }
+  return types;
+}
+
+describe('RWT-003 — Node Runtime/Editor Compatibility', () => {
+  let jsContent;
+  let htmlContent;
+
+  beforeAll(() => {
+    jsContent = fs.readFileSync(JS_PATH, 'utf8');
+    htmlContent = fs.readFileSync(HTML_PATH, 'utf8');
+  });
+
+  test('js and html register the same node types', () => {
+    const jsTypes = extractJsRegisterTypes(jsContent);
+    const htmlTypes = extractHtmlRegisterTypes(htmlContent);
+
+    // Filter out commented-out registrations in HTML
+    // HTML comments are <!-- ... -->, so we need to remove them first
+    const uncommentedHtml = htmlContent.replace(/<!--[\s\S]*?-->/g, '');
+    const activeHtmlTypes = extractHtmlRegisterTypes(uncommentedHtml);
+
+    expect(jsTypes.sort()).toEqual(activeHtmlTypes.sort());
+  });
+
+  test('every registered type has a corresponding data-template-name', () => {
+    const uncommentedHtml = htmlContent.replace(/<!--[\s\S]*?-->/g, '');
+    const htmlTypes = extractHtmlTemplateNames(uncommentedHtml);
+    const jsTypes = extractJsRegisterTypes(jsContent);
+
+    for (const jsType of jsTypes) {
+      expect(htmlTypes).toContain(jsType);
+    }
+  });
+
+  test('every registered type has a corresponding data-help-name', () => {
+    const uncommentedHtml = htmlContent.replace(/<!--[\s\S]*?-->/g, '');
+    const helpTypes = extractHtmlHelpNames(uncommentedHtml);
+    const jsTypes = extractJsRegisterTypes(jsContent);
+
+    for (const jsType of jsTypes) {
+      expect(helpTypes).toContain(jsType);
+    }
+  });
+
+  test('template-name and help-name match for each type', () => {
+    const uncommentedHtml = htmlContent.replace(/<!--[\s\S]*?-->/g, '');
+    const templateTypes = extractHtmlTemplateNames(uncommentedHtml);
+    const helpTypes = extractHtmlHelpNames(uncommentedHtml);
+
+    expect(templateTypes.sort()).toEqual(helpTypes.sort());
+  });
+
+  test('currently supported node types are wstunnel, wstunnel server, and wstunnel command', () => {
+    const uncommentedHtml = htmlContent.replace(/<!--[\s\S]*?-->/g, '');
+    const jsTypes = extractJsRegisterTypes(jsContent);
+    const templateTypes = extractHtmlTemplateNames(uncommentedHtml);
+
+    const expectedTypes = ['wstunnel', 'wstunnel server', 'wstunnel command'];
+    expect(jsTypes.sort()).toEqual(expectedTypes.sort());
+    expect(templateTypes.sort()).toEqual(expectedTypes.sort());
+  });
+});

package/test/rwt-004-persisted-config-compatibility.test.js

@@ -0,0 +1,140 @@
+/**
+ * RWT-004 — Persisted Flow Configuration Compatibility
+ *
+ * Existing Node-RED flows using the currently supported wstunnel configuration
+ * properties must remain loadable after a package upgrade, and their persisted
+ * configuration values must retain their existing behavior.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const JS_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+const HTML_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.html');
+const FLOWS_PATH = path.join(__dirname, '..', 'data', 'flows.json');
+
+const EXPECTED_PROPERTIES = [
+  'name',
+  'host',
+  'port',
+  'path',
+  'tunnelIdHeaderName',
+  'logLevel',
+];
+
+function extractJsOptions(jsContent) {
+  // Match the options object in WSTunnelNode constructor
+  // Pattern: this.options = { ... }
+  const regex = /this\.options\s*=\s*\{([^}]+)\}/s;
+  const match = jsContent.match(regex);
+  if (!match) return [];
+
+  const optionsBlock = match[1];
+  const propRegex = /(\w+)\s*:/g;
+  const props = [];
+  let propMatch;
+  while ((propMatch = propRegex.exec(optionsBlock)) !== null) {
+    props.push(propMatch[1]);
+  }
+  return props;
+}
+
+function extractHtmlDefaults(htmlContent) {
+  // Find the wstunnel config node registration defaults
+  // Pattern: RED.nodes.registerType('wstunnel', { ... defaults: { ... } })
+  const uncommentedHtml = htmlContent.replace(/<!--[\s\S]*?-->/g, '');
+
+  // Find the wstunnel registration (not wstunnel server)
+  // Use a more precise approach: find the defaults block by counting braces
+  const typeIndex = uncommentedHtml.indexOf("RED.nodes.registerType('wstunnel',");
+  if (typeIndex === -1) return [];
+
+  const defaultsIndex = uncommentedHtml.indexOf('defaults:', typeIndex);
+  if (defaultsIndex === -1) return [];
+
+  // Find the opening brace of defaults
+  const openBraceIndex = uncommentedHtml.indexOf('{', defaultsIndex);
+  if (openBraceIndex === -1) return [];
+
+  // Count braces to find the matching closing brace
+  let depth = 1;
+  let i = openBraceIndex + 1;
+  while (i < uncommentedHtml.length && depth > 0) {
+    if (uncommentedHtml[i] === '{') depth++;
+    if (uncommentedHtml[i] === '}') depth--;
+    i++;
+  }
+
+  const defaultsBlock = uncommentedHtml.substring(openBraceIndex + 1, i - 1);
+
+  // Extract property names (keys that have colon followed by {)
+  const propRegex = /(\w+)\s*:\s*\{/g;
+  const props = [];
+  let propMatch;
+  while ((propMatch = propRegex.exec(defaultsBlock)) !== null) {
+    props.push(propMatch[1]);
+  }
+  return props;
+}
+
+function extractFlowProperties(flowsContent) {
+  const flows = JSON.parse(flowsContent);
+  const wstunnelNode = flows.find((f) => f.type === 'wstunnel');
+  if (!wstunnelNode) return [];
+  return Object.keys(wstunnelNode).filter((k) => k !== 'id' && k !== 'type');
+}
+
+describe('RWT-004 — Persisted Flow Configuration Compatibility', () => {
+  let jsContent;
+  let htmlContent;
+
+  beforeAll(() => {
+    jsContent = fs.readFileSync(JS_PATH, 'utf8');
+    htmlContent = fs.readFileSync(HTML_PATH, 'utf8');
+  });
+
+  test('WSTunnelNode constructor defines all expected properties', () => {
+    const jsProps = extractJsOptions(jsContent);
+
+    for (const prop of EXPECTED_PROPERTIES) {
+      expect(jsProps).toContain(prop);
+    }
+  });
+
+  test('html registration defines all expected properties', () => {
+    const htmlProps = extractHtmlDefaults(htmlContent);
+
+    for (const prop of EXPECTED_PROPERTIES) {
+      expect(htmlProps).toContain(prop);
+    }
+  });
+
+  test('js and html define the same set of properties', () => {
+    const jsProps = extractJsOptions(jsContent);
+    const htmlProps = extractHtmlDefaults(htmlContent);
+
+    expect(jsProps.sort()).toEqual(htmlProps.sort());
+  });
+
+  test('flows.json contains all expected persisted properties', () => {
+    if (!fs.existsSync(FLOWS_PATH)) {
+      // Skip if flows.json doesn't exist (e.g., in CI)
+      return;
+    }
+
+    const flowsContent = fs.readFileSync(FLOWS_PATH, 'utf8');
+    const flowProps = extractFlowProperties(flowsContent);
+
+    for (const prop of EXPECTED_PROPERTIES) {
+      expect(flowProps).toContain(prop);
+    }
+  });
+
+  test('no expected property has been removed from the options object', () => {
+    const jsProps = extractJsOptions(jsContent);
+
+    // This test will fail if any expected property is removed
+    expect(jsProps).toEqual(expect.arrayContaining(EXPECTED_PROPERTIES));
+    expect(jsProps.length).toBe(EXPECTED_PROPERTIES.length);
+  });
+});

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