@bonsae/nrg 0.19.0 → 0.20.0

package/test/server/integration/index.js

@@ -0,0 +1,375 @@
+// src/test/server/integration/runtime.ts
+import http from "http";
+import os from "os";
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { registerTypes } from "@bonsae/nrg/server";
+
+// src/test/server/integration/recorder.ts
+var Recorder = class {
+  #sent = /* @__PURE__ */ new Map();
+  #received = /* @__PURE__ */ new Map();
+  #waiters = [];
+  recordSent(id, port, msg) {
+    this.#push("sent", id, { port, msg });
+  }
+  recordReceived(id, msg) {
+    if (!id) return;
+    this.#push("received", id, { port: 0, msg });
+  }
+  /** Snapshot of all messages on a channel for a node (optionally one port). */
+  snapshot(channel, id, port) {
+    return this.#filter(channel, id, port).map((c) => c.msg);
+  }
+  /** Resolve the message at `index` on a channel, awaiting it if not yet seen. */
+  next(channel, id, port, index, timeoutMs) {
+    const existing = this.#filter(channel, id, port);
+    if (existing.length > index) return Promise.resolve(existing[index].msg);
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        channel,
+        id,
+        port,
+        index,
+        settle: (msg) => {
+          clearTimeout(timer);
+          resolve(msg);
+        }
+      };
+      const timer = setTimeout(() => {
+        this.#waiters = this.#waiters.filter((w) => w !== waiter);
+        const where = port === void 0 ? "" : ` on port ${port}`;
+        reject(
+          new Error(
+            `Timed out after ${timeoutMs}ms waiting for ${channel} message #${index} from node ${id}${where}`
+          )
+        );
+      }, timeoutMs);
+      this.#waiters.push(waiter);
+    });
+  }
+  clear() {
+    this.#sent.clear();
+    this.#received.clear();
+    this.#waiters = [];
+  }
+  #map(channel) {
+    return channel === "sent" ? this.#sent : this.#received;
+  }
+  #filter(channel, id, port) {
+    const list = this.#map(channel).get(id) ?? [];
+    return port === void 0 ? list : list.filter((c) => c.port === port);
+  }
+  #push(channel, id, captured) {
+    const map = this.#map(channel);
+    const list = map.get(id) ?? [];
+    list.push(captured);
+    map.set(id, list);
+    for (let i = this.#waiters.length - 1; i >= 0; i--) {
+      const w = this.#waiters[i];
+      if (w.channel !== channel || w.id !== id) continue;
+      const filtered = this.#filter(channel, id, w.port);
+      if (filtered.length > w.index) {
+        this.#waiters.splice(i, 1);
+        w.settle(filtered[w.index].msg);
+      }
+    }
+  }
+};
+
+// src/core/server/nodes/utils.ts
+import { Kind } from "@sinclair/typebox";
+function setupContext(context, store) {
+  return {
+    get: (key) => new Promise(
+      (resolve, reject) => context.get(
+        key,
+        store,
+        (error, value) => error ? reject(error) : resolve(value)
+      )
+    ),
+    set: (key, value) => new Promise(
+      (resolve, reject) => context.set(
+        key,
+        value,
+        store,
+        (error) => error ? reject(error) : resolve()
+      )
+    ),
+    keys: () => new Promise(
+      (resolve, reject) => context.keys(store, (error, k) => error ? reject(error) : resolve(k))
+    )
+  };
+}
+
+// src/test/server/integration/flow.ts
+var seq = 0;
+function genId(prefix) {
+  seq += 1;
+  return `${prefix}${seq.toString(36)}`;
+}
+function tick() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+var NodeRef = class {
+  id;
+  type;
+  isConfig;
+  name;
+  config;
+  credentials;
+  wires = [];
+  #flow;
+  #readCursor = /* @__PURE__ */ new Map();
+  constructor(flow, type, isConfig, config, opts) {
+    this.#flow = flow;
+    this.type = type;
+    this.isConfig = isConfig;
+    this.config = config;
+    this.credentials = opts.credentials;
+    this.id = opts.id ?? genId("n");
+    this.name = opts.name ?? "";
+  }
+  /** Wire this node's output `port` to `target`'s input. */
+  wire(target, port = 0) {
+    while (this.wires.length <= port) this.wires.push([]);
+    this.wires[port].push(target.id);
+    return this;
+  }
+  /** Deliver a message to this node's input (Node-RED's upstream path). */
+  async receive(msg) {
+    const node = this.#flow.runtimeNode(this.id);
+    if (!node) {
+      throw new Error(
+        `Node "${this.id}" (${this.type}) is not deployed \u2014 call flow.deploy() first`
+      );
+    }
+    node.receive(msg);
+    await tick();
+  }
+  /** Snapshot of everything this node has emitted (optionally one port). */
+  sent(port) {
+    return this.#flow.recorder.snapshot("sent", this.id, port);
+  }
+  /** Snapshot of everything delivered to this node's input. */
+  received(port) {
+    return this.#flow.recorder.snapshot("received", this.id, port);
+  }
+  /**
+   * Promise-based access to this node's context stores (`node` / `flow` /
+   * `global`) — preset values before `receive`, and assert them afterward.
+   */
+  get context() {
+    const rn = this.#flow.runtimeNode(this.id);
+    if (!rn) {
+      throw new Error(
+        `Node "${this.id}" (${this.type}) is not deployed \u2014 call flow.deploy() first`
+      );
+    }
+    const ctx = rn.context();
+    return {
+      node: setupContext(ctx),
+      flow: setupContext(ctx.flow),
+      global: setupContext(ctx.global)
+    };
+  }
+  /**
+   * Consume the next un-read message this node emitted (FIFO cursor), awaiting
+   * it if not yet sent. Call repeatedly to walk multiple emissions.
+   */
+  async read(port, opts = {}) {
+    const cursor = this.#readCursor.get(port) ?? 0;
+    const msg = await this.#flow.recorder.next(
+      "sent",
+      this.id,
+      port,
+      cursor,
+      opts.timeout ?? 5e3
+    );
+    this.#readCursor.set(port, cursor + 1);
+    return msg;
+  }
+};
+var Flow = class {
+  recorder;
+  #RED;
+  #flowId = genId("flow");
+  #nodes = [];
+  constructor(RED, recorder) {
+    this.#RED = RED;
+    this.recorder = recorder;
+  }
+  /** Add any node — regular or config (detected via `category === "config"`). */
+  addNode(Cls, config = {}, opts = {}) {
+    const isConfig = Cls.category === "config";
+    const ref = new NodeRef(this, Cls.type, isConfig, config, opts);
+    this.#nodes.push(ref);
+    return ref;
+  }
+  /** Build the flow JSON and deploy it; resolves once the flow has started. */
+  async deploy() {
+    this.recorder.clear();
+    const flows = this.#buildFlows();
+    await this.#RED.runtime.flows.setFlows({
+      flows: { flows },
+      deploymentType: "full"
+    });
+    await this.#waitForDeploy();
+  }
+  /** Drop the built nodes and clear captured messages (reset between tests). */
+  async clear() {
+    this.#nodes = [];
+    this.recorder.clear();
+    await this.#RED.runtime.flows.setFlows({
+      flows: { flows: [] },
+      deploymentType: "full"
+    });
+  }
+  runtimeNode(id) {
+    return this.#RED.nodes.getNode(id);
+  }
+  #buildFlows() {
+    const flows = [
+      { id: this.#flowId, type: "tab", label: "nrg-integration" }
+    ];
+    for (const ref of this.#nodes) {
+      const base = {
+        id: ref.id,
+        type: ref.type,
+        name: ref.name,
+        ...this.#serializeConfig(ref.config),
+        ...ref.credentials ? { credentials: ref.credentials } : {}
+      };
+      flows.push(
+        ref.isConfig ? base : {
+          ...base,
+          z: this.#flowId,
+          wires: ref.wires.length ? ref.wires : [[]]
+        }
+      );
+    }
+    return flows;
+  }
+  /** NodeRef config values serialize to the referenced node's id (a real NodeRef). */
+  #serializeConfig(config) {
+    const out = {};
+    for (const [key, value] of Object.entries(config)) {
+      out[key] = value instanceof NodeRef ? value.id : value;
+    }
+    return out;
+  }
+  async #waitForDeploy() {
+    const target = this.#nodes.find((n) => !n.isConfig);
+    if (!target) return;
+    const deadline = Date.now() + 5e3;
+    while (Date.now() < deadline && !this.#RED.nodes.getNode(target.id)) {
+      await new Promise((resolve) => setTimeout(resolve, 15));
+    }
+    if (!this.#RED.nodes.getNode(target.id)) {
+      throw new Error("Flow deploy did not complete within 5s");
+    }
+    for (const ref of this.#nodes) {
+      if (ref.isConfig) continue;
+      const rn = this.#RED.nodes.getNode(ref.id);
+      if (rn) this.#wrapSend(rn, ref.id);
+    }
+    await tick();
+  }
+  #wrapSend(rn, id) {
+    const recorder = this.recorder;
+    const original = rn.send.bind(rn);
+    rn.send = (arg) => {
+      if (Array.isArray(arg)) {
+        arg.forEach((m, port) => {
+          if (m != null) recorder.recordSent(id, port, m);
+        });
+      } else if (arg != null) {
+        recorder.recordSent(id, 0, arg);
+      }
+      return original(arg);
+    };
+  }
+};
+
+// src/test/server/integration/runtime.ts
+function requireNodeRed() {
+  const req = createRequire(path.join(process.cwd(), "package.json"));
+  let entry;
+  try {
+    entry = req.resolve("node-red");
+  } catch {
+    throw new Error(
+      "Integration tests need Node-RED installed. Add `node-red` as a devDependency."
+    );
+  }
+  return req(entry);
+}
+function headlessSettings(userDir, overrides) {
+  return {
+    // keep RED.httpAdmin a valid router (so node registration's route setup is
+    // safe) but never serve the editor UI
+    disableEditor: true,
+    httpNodeRoot: false,
+    userDir,
+    flowFile: path.join(userDir, "flows.json"),
+    credentialSecret: "nrg-integration-test",
+    logging: { console: { level: "fatal", metrics: false, audit: false } },
+    functionGlobalContext: {},
+    ...overrides
+  };
+}
+async function startRuntime(options) {
+  const RED = requireNodeRed();
+  const userDir = fs.mkdtempSync(path.join(os.tmpdir(), "nrg-integration-"));
+  const server = http.createServer();
+  await new Promise(
+    (resolve) => server.listen(0, "127.0.0.1", () => resolve())
+  );
+  RED.init(server, headlessSettings(userDir, options.settings));
+  const recorder = new Recorder();
+  RED.hooks.add(
+    "onReceive",
+    (event) => recorder.recordReceived(event.destination?.id, event.msg)
+  );
+  await registerTypes(options.nodes)(
+    RED
+  );
+  await RED.start();
+  await new Flow(RED, recorder).deploy();
+  return new Runtime(RED, server, userDir, recorder);
+}
+var Runtime = class {
+  #RED;
+  #server;
+  #userDir;
+  #recorder;
+  constructor(RED, server, userDir, recorder) {
+    this.#RED = RED;
+    this.#server = server;
+    this.#userDir = userDir;
+    this.#recorder = recorder;
+  }
+  /** Start a fresh flow to build, deploy, drive and inspect. */
+  flow() {
+    return new Flow(this.#RED, this.#recorder);
+  }
+  /** Stop Node-RED, close the server and remove the temp user dir. */
+  async stop() {
+    try {
+      await this.#RED.stop();
+    } catch {
+    }
+    await new Promise((resolve) => this.#server.close(() => resolve()));
+    try {
+      fs.rmSync(this.#userDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+};
+export {
+  Flow,
+  NodeRef,
+  Runtime,
+  startRuntime
+};

package/test/server/unit/config.js

@@ -7,7 +7,11 @@ var defaultConfig = {
     }
   },
   test: {
-    testTimeout: 3e4
+    testTimeout: 3e4,
+    // unit tests live under tests/server/unit; integration tests live under
+    // tests/server/integration and run via their own config — the two tiers are
+    // separated by folder, so no exclude is needed
+    include: ["tests/server/unit/**/*.test.ts"]
   }
 };
 export {

package/test/server/unit/index.js

@@ -504,7 +504,10 @@ function attachHelpers(node, nodeRedNode, NodeClass) {
     },
     errored() {
       return nodeRedNode.error.mock.calls.map((c) => c[0]);
-    }
+    },
+    // expose the node's own (already promise-wrapped) context stores; the
+    // node keeps using the same object internally, callable form included
+    context: node.context
   };
   return Object.assign(node, helpers);
 }

package/tsconfig/test/server/integration.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../base.json",
+  "compilerOptions": {
+    "lib": ["ESNext"]
+  }
+}

package/types/test-client-e2e.d.ts

@@ -89,6 +89,7 @@ export declare const defaultConfig: {
 	testTimeout: number;
 	hookTimeout: number;
 	globalSetup: string[];
+	include: string[];
 };
 export declare function setup(options?: SetupOptions): Promise<void>;
 export declare function teardown(): Promise<void>;