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

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