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

package/test/rwt-001-port-exclusivity.test.js

@@ -0,0 +1,171 @@
+/**
+ * RWT-001 — Exclusive Server Ownership of a Port
+ *
+ * A replacement managed WebSocket server must not be started on a port until
+ * the previously managed server on that port has completed its shutdown.
+ */
+
+const path = require('path');
+
+const WS_TUNNEL_PATH = path.join(__dirname, '..', 'nodes', 'wsTunnel.js');
+
+// Track call order across mocks
+let callLog = [];
+
+// Mock stopWebSocketServer
+const mockStopWebSocketServer = jest.fn((port) => {
+  callLog.push({ fn: 'stopWebSocketServer', port });
+  return new Promise((resolve) => {
+    setImmediate(() => {
+      callLog.push({ fn: 'stopWebSocketServer-resolved', port });
+      resolve();
+    });
+  });
+});
+
+// Mock startWebSocketServer
+const mockStartWebSocketServer = jest.fn((opts) => {
+  callLog.push({ fn: 'startWebSocketServer', port: opts.port });
+  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((id) => ({
+        options: {
+          name: 'test-tunnel',
+          host: 'localhost',
+          port: 1880,
+          path: '',
+          tunnelIdHeaderName: 'x-tunnel-id',
+          logLevel: 'info',
+        },
+      })),
+    },
+    _registeredTypes: registeredTypes,
+  };
+}
+
+describe('RWT-001 — Exclusive Server Ownership of a Port', () => {
+  let originalModules;
+
+  beforeAll(() => {
+    originalModules = {
+      stopWebSocketServer: require('@remotelinker/reverse-ws-tunnel/server').stopWebSocketServer,
+    };
+
+    // Replace the module exports before requiring wsTunnel
+    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(() => {
+    callLog = [];
+    mockStopWebSocketServer.mockClear();
+    mockStartWebSocketServer.mockClear();
+    mockLogger.info.mockClear();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  afterAll(() => {
+    // Restore original modules
+    const serverModule = require('@remotelinker/reverse-ws-tunnel/server');
+    serverModule.stopWebSocketServer = originalModules.stopWebSocketServer;
+  });
+
+  test('stopWebSocketServer is called before startWebSocketServer on node creation', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Get the registered WSTunnelServer constructor
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    expect(WSTunnelServer).toBeDefined();
+
+    // Create a mock node config
+    const nodeConfig = {
+      wstunnel: 'test-config-id',
+      name: 'test-server',
+    };
+
+    // Instantiate the node
+    const node = {};
+    WSTunnelServer.call(node, nodeConfig);
+
+    // Wait for the constructor promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // Verify stopWebSocketServer was called
+    expect(mockStopWebSocketServer).toHaveBeenCalled();
+
+    // Verify startWebSocketServer was called
+    expect(mockStartWebSocketServer).toHaveBeenCalled();
+
+    // Verify ordering: stopWebSocketServer must complete before startWebSocketServer
+    const stopIndex = callLog.findIndex((e) => e.fn === 'stopWebSocketServer-resolved');
+    const startIndex = callLog.findIndex((e) => e.fn === 'startWebSocketServer');
+
+    expect(stopIndex).toBeGreaterThanOrEqual(0);
+    expect(startIndex).toBeGreaterThanOrEqual(0);
+    expect(stopIndex).toBeLessThan(startIndex);
+  });
+
+  test('the correct port is passed to both stop and start', 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 the constructor promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const stopCall = mockStopWebSocketServer.mock.calls[0];
+    const startCall = mockStartWebSocketServer.mock.calls[0];
+
+    expect(stopCall[0]).toBe(1880);
+    expect(startCall[0].port).toBe(1880);
+  });
+});

package/test/rwt-001-port-release.test.js

@@ -0,0 +1,58 @@
+/**
+ * RWT-001 — Port Release Guarantee (Deterministic)
+ *
+ * stopWebSocketServer(port) must release the port before resolving.
+ * A replacement server must bind to the same port without EADDRINUSE.
+ */
+
+const { startWebSocketServer, stopWebSocketServer } = require('@remotelinker/reverse-ws-tunnel/server');
+
+const TEST_PORT = 18999;
+
+describe('RWT-001 — Port release after stopWebSocketServer', () => {
+  afterEach(async () => {
+    await stopWebSocketServer(TEST_PORT);
+  });
+
+  test('port is available immediately after stopWebSocketServer resolves', async () => {
+    const state1 = await startWebSocketServer({
+      port: TEST_PORT,
+      tunnelIdHeaderName: 'x-tunnel-id',
+    });
+
+    expect(state1[TEST_PORT]).toBeDefined();
+    expect(state1[TEST_PORT].webSocketServer).toBeDefined();
+
+    await stopWebSocketServer(TEST_PORT);
+
+    const state2 = await startWebSocketServer({
+      port: TEST_PORT,
+      tunnelIdHeaderName: 'x-tunnel-id',
+    });
+
+    expect(state2[TEST_PORT]).toBeDefined();
+    expect(state2[TEST_PORT].webSocketServer).toBeDefined();
+
+    await stopWebSocketServer(TEST_PORT);
+  });
+
+  test('rapid stop-then-start cycle does not produce EADDRINUSE', async () => {
+    const state1 = await startWebSocketServer({
+      port: TEST_PORT,
+      tunnelIdHeaderName: 'x-tunnel-id',
+    });
+
+    expect(state1[TEST_PORT]).toBeDefined();
+
+    for (let i = 0; i < 3; i++) {
+      await stopWebSocketServer(TEST_PORT);
+      const state = await startWebSocketServer({
+        port: TEST_PORT,
+        tunnelIdHeaderName: 'x-tunnel-id',
+      });
+      expect(state[TEST_PORT]).toBeDefined();
+    }
+
+    await stopWebSocketServer(TEST_PORT);
+  });
+});

package/test/rwt-002-shutdown-completion.test.js

@@ -0,0 +1,226 @@
+/**
+ * RWT-002 — Node Shutdown Must Signal Completion
+ *
+ * When a WSTunnelServer node receives a Node-RED close event, its shutdown
+ * handler must always signal completion by invoking done(), including failure paths.
+ */
+
+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) => {
+  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((id) => ({
+        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('RWT-002 — Node Shutdown Must Signal Completion', () => {
+  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();
+    mockSetLogContext.mockClear();
+    mockSetLogLevel.mockClear();
+  });
+
+  test('done() is called on successful stopWebSocketServer', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Wait for the constructor promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    // Simulate the close event
+    node._handlers.close.call(node, false, done);
+
+    // Wait for the close handler promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(done).toHaveBeenCalledTimes(1);
+  });
+
+  test('done() is called on failed stopWebSocketServer', async () => {
+    mockStopResolved = false;
+
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Wait for the constructor promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    // Simulate the close event
+    node._handlers.close.call(node, false, done);
+
+    // Wait for the close handler promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(done).toHaveBeenCalledTimes(1);
+  });
+
+  test('done() is called when no server state exists', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Create a node without waiting for server setup
+    const node = {};
+    RED.nodes.createNode = jest.fn((n, config) => {
+      n.status = jest.fn();
+      n.on = jest.fn((event, handler) => {
+        n._handlers = n._handlers || {};
+        n._handlers[event] = handler;
+      });
+    });
+
+    const WSTunnelServer = RED._registeredTypes['wstunnel server'];
+    WSTunnelServer.call(node, { wstunnel: 'test-config-id', name: 'test-server' });
+
+    // Don't wait for server setup — close immediately
+    const done = jest.fn();
+    node._handlers.close.call(node, false, done);
+
+    // The close handler calls done() synchronously when no server state exists
+    // A single microtask flush is sufficient
+    await Promise.resolve();
+
+    expect(done).toHaveBeenCalledTimes(1);
+  });
+
+  test('done() is never called more than once', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    // Wait for the constructor promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const node = createNode(RED);
+    const done = jest.fn();
+
+    node._handlers.close.call(node, false, done);
+
+    // Wait for the close handler promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(done).toHaveBeenCalledTimes(1);
+  });
+
+  test('cleanup completes before done() is called', async () => {
+    const RED = createMockRED();
+    const tunnelModule = require(WS_TUNNEL_PATH);
+    tunnelModule(RED);
+
+    const node = createNode(RED);
+
+    // Wait for the constructor promise chain (mockStopWebSocketServer resolves via setImmediate)
+    await new Promise((resolve) => setImmediate(resolve));
+
+    const done = jest.fn();
+
+    // Call close handler — stopWebSocketServer starts but hasn't resolved yet
+    node._handlers.close.call(node, false, done);
+
+    // done() must NOT be called synchronously (before the promise chain resolves)
+    // The mock resolves via setImmediate, which hasn't fired yet at this point
+    expect(done).not.toHaveBeenCalled();
+
+    // Flush the promise chain
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // Now done() should have been called
+    expect(done).toHaveBeenCalledTimes(1);
+  });
+});

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