qrusty-client 0.10.0 → 0.12.0

package/live_test.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+/**
+ * Qrusty Node.js Live Client Tests
+ *
+ * Starts a real qrusty server and exercises QrustyClient (HTTP) and
+ * WsSession (WebSocket) against it, including cross-mode scenarios.
+ *
+ * Usage:
+ *   node integrations/nodeclient/live_test.js [--binary PATH] [--port PORT]
+ *
+ * Exit codes: 0 pass, 1 failure, 2 setup failure.
+ */
+
+const assert = require("assert");
+const { spawn, execSync } = require("child_process");
+const http = require("http");
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+const { QrustyClient, WsSession } = require("./index");
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+const REPO_ROOT = path.resolve(__dirname, "..", "..");
+const DEFAULT_BINARY = path.join(REPO_ROOT, "target", "debug", "qrusty");
+const DEFAULT_PORT = 17787;
+
+// ---------------------------------------------------------------------------
+// CLI args
+// ---------------------------------------------------------------------------
+function parseArgs() {
+  const args = { binary: DEFAULT_BINARY, port: DEFAULT_PORT };
+  for (let i = 2; i < process.argv.length; i++) {
+    if (process.argv[i] === "--binary" && process.argv[i + 1]) {
+      args.binary = process.argv[++i];
+    }
+    if (process.argv[i] === "--port" && process.argv[i + 1]) {
+      args.port = parseInt(process.argv[++i], 10);
+    }
+  }
+  // Resolve target-specific binary path
+  if (!fs.existsSync(args.binary)) {
+    try {
+      const hostTarget = execSync("rustc -vV", { encoding: "utf8" })
+        .split("\n")
+        .find((l) => l.startsWith("host:"))
+        ?.split(":")[1]
+        ?.trim();
+      if (hostTarget) {
+        const alt = path.join(
+          REPO_ROOT,
+          "target",
+          hostTarget,
+          "debug",
+          "qrusty",
+        );
+        if (fs.existsSync(alt)) args.binary = alt;
+      }
+    } catch {
+      // ignore
+    }
+  }
+  return args;
+}
+
+// ---------------------------------------------------------------------------
+// Server lifecycle
+// ---------------------------------------------------------------------------
+function startServer(binary, port, dataDir) {
+  const env = {
+    ...process.env,
+    BIND_ADDR: `0.0.0.0:${port}`,
+    DATA_PATH: dataDir,
+  };
+  return spawn(binary, [], {
+    env,
+    stdio: ["ignore", "ignore", "ignore"],
+  });
+}
+
+function waitForHealth(baseUrl, timeoutMs = 15000) {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs;
+    const poll = () => {
+      if (Date.now() > deadline) {
+        return reject(new Error(`Server at ${baseUrl} not healthy in time`));
+      }
+      http
+        .get(`${baseUrl}/health`, (res) => {
+          if (res.statusCode === 200) return resolve();
+          setTimeout(poll, 250);
+        })
+        .on("error", () => setTimeout(poll, 250));
+    };
+    poll();
+  });
+}
+
+function stopServer(proc) {
+  return new Promise((resolve) => {
+    proc.on("close", resolve);
+    proc.kill("SIGTERM");
+    setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+        // already dead
+      }
+    }, 5000);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Test runner
+// ---------------------------------------------------------------------------
+let passed = 0;
+let failed = 0;
+let queueCounter = 0;
+
+function uniqueQueue(prefix = "nodeq") {
+  return `${prefix}-${++queueCounter}`;
+}
+
+async function runTest(name, fn) {
+  try {
+    await fn();
+    console.log(`  PASS  ${name}`);
+    passed++;
+  } catch (err) {
+    console.log(`  FAIL  ${name}`);
+    console.log(`        ${err.message}`);
+    failed++;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function receiveOne(session, queue, timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`timeout waiting for delivery on ${queue}`)),
+      timeoutMs,
+    );
+    const iter = session.subscribe(queue)[Symbol.asyncIterator]();
+    iter.next().then((result) => {
+      clearTimeout(timer);
+      resolve(result.value);
+    }, reject);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+  const args = parseArgs();
+  if (!fs.existsSync(args.binary)) {
+    console.error(
+      `ERROR: binary not found at ${args.binary}. Run 'cargo build' first.`,
+    );
+    process.exit(2);
+  }
+
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "qrusty-node-live-"));
+  const baseUrl = `http://127.0.0.1:${args.port}`;
+  const wsUrl = `ws://127.0.0.1:${args.port}`;
+  const proc = startServer(args.binary, args.port, dataDir);
+
+  try {
+    await waitForHealth(baseUrl);
+    console.log(`Server started at ${baseUrl}\n`);
+
+    const client = new QrustyClient(baseUrl);
+
+    // ======================= HTTP Tests ===========================
+    console.log("HTTP Client Tests:");
+
+    await runTest("health", async () => {
+      const h = await client.health();
+      assert.ok(h.includes("OK"));
+    });
+
+    await runTest("createQueue and listQueues", async () => {
+      const q = uniqueQueue();
+      await client.createQueue(q);
+      // /queues only lists queues with messages, so publish one first
+      await client.publish(q, 1, "test");
+      const list = await client.listQueues();
+      assert.ok(list.includes(q));
+    });
+
+    await runTest("publish returns id", async () => {
+      const q = uniqueQueue();
+      await client.createQueue(q);
+      const result = await client.publish(q, 100, { x: 1 });
+      assert.ok(result.id);
+    });
+
+    await runTest("consume delivers highest priority", async () => {
+      const q = uniqueQueue();
+      await client.createQueue(q);
+      await client.publish(q, 10, "low");
+      await client.publish(q, 50, "high");
+      await client.publish(q, 30, "mid");
+      const msg = await client.consume(q, "test");
+      // ConsumeResponse only has {id, payload, retry_count} — verify via payload
+      assert.strictEqual(msg.payload, "high");
+    });
+
+    await runTest("consume empty returns null", async () => {
+      const q = uniqueQueue();
+      await client.createQueue(q);
+      const msg = await client.consume(q, "test");
+      assert.strictEqual(msg, null);
+    });
+
+    await runTest("ack removes message", async () => {
+      const q = uniqueQueue();
+      await client.createQueue(q);
+      await client.publish(q, 1, "msg");
+      const msg = await client.consume(q, "test");
+      await client.ack(q, msg.id, "test");
+      const stats = await client.queueStats(q);
+      assert.strictEqual(stats.locked, 0);
+      assert.strictEqual(stats.available, 0);
+    });
+
+    await runTest("nack requeues message", async () => {
+      const q = uniqueQueue();
+      await client.createQueue(q);
+      await client.publish(q, 1, "msg");
+      const msg = await client.consume(q, "test");
+      await client.nack(q, msg.id, "test");
+      const stats = await client.queueStats(q);
+      assert.strictEqual(stats.locked, 0);
+      assert.strictEqual(stats.available, 1);
+    });
+
+    await runTest("purge queue", async () => {
+      const q = uniqueQueue();
+      await client.createQueue(q);
+      await client.publish(q, 1, "a");
+      await client.publish(q, 2, "b");
+      await client.purge(q);
+      const stats = await client.queueStats(q);
+      assert.strictEqual(stats.available, 0);
+    });
+
+    await runTest("delete queue", async () => {
+      const q = uniqueQueue();
+      await client.createQueue(q);
+      await client.deleteQueue(q);
+      const list = await client.listQueues();
+      assert.ok(!list.includes(q));
+    });
+
+    // ======================= WS Tests ===========================
+    console.log("\nWebSocket Client Tests:");
+
+    await runTest("ws publish and subscribe", async () => {
+      const q = uniqueQueue("wsq");
+      await client.createQueue(q);
+
+      const session = new WsSession(wsUrl);
+      await session.connect();
+      try {
+        const id = await session.publish(q, "hello-ws", 42);
+        assert.ok(id);
+
+        // Small delay to let subscribe frame reach server before delivery
+        const receivePromise = receiveOne(session, q);
+        await sleep(100);
+        const msg = await receivePromise;
+        assert.strictEqual(msg.queue, q);
+        assert.strictEqual(msg.payload, "hello-ws");
+        assert.strictEqual(msg.priority, 42);
+      } finally {
+        await session.close();
+      }
+    });
+
+    await runTest("ws ack clears locked", async () => {
+      const q = uniqueQueue("wsq");
+      await client.createQueue(q);
+
+      const session = new WsSession(wsUrl);
+      await session.connect();
+      try {
+        await session.publish(q, "ack-test", 1);
+        const receivePromise = receiveOne(session, q);
+        await sleep(100);
+        const msg = await receivePromise;
+        await session.ack(msg.queue, msg.id);
+      } finally {
+        await session.close();
+      }
+
+      const stats = await client.queueStats(q);
+      assert.strictEqual(stats.locked, 0);
+      assert.strictEqual(stats.available, 0);
+    });
+
+    // ======================= Cross-Mode Tests ===========================
+    console.log("\nCross-Mode Tests:");
+
+    await runTest("HTTP publish -> WS subscribe", async () => {
+      const q = uniqueQueue("cross");
+      await client.createQueue(q);
+
+      const session = new WsSession(wsUrl);
+      await session.connect();
+      try {
+        const receivePromise = receiveOne(session, q);
+        await sleep(200); // Let subscribe settle
+        await client.publish(q, 77, "from-http");
+        const msg = await receivePromise;
+        assert.strictEqual(msg.queue, q);
+        assert.strictEqual(msg.priority, 77);
+      } finally {
+        await session.close();
+      }
+    });
+
+    await runTest("WS publish -> HTTP consume", async () => {
+      const q = uniqueQueue("cross");
+      await client.createQueue(q);
+
+      const session = new WsSession(wsUrl);
+      await session.connect();
+      try {
+        await session.publish(q, "from-ws", 88);
+      } finally {
+        await session.close();
+      }
+
+      const msg = await client.consume(q, "test");
+      assert.ok(msg);
+      assert.strictEqual(msg.payload, "from-ws");
+    });
+
+    // ======================= Summary ===========================
+    console.log(`\n${"=".repeat(50)}`);
+    console.log(`RESULTS: ${passed} passed, ${failed} failed`);
+    console.log("=".repeat(50));
+
+    process.exit(failed > 0 ? 1 : 0);
+  } finally {
+    await stopServer(proc);
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  }
+}
+
+main().catch((err) => {
+  console.error(`Setup error: ${err.message}`);
+  process.exit(2);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qrusty-client",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Node.js client for the qrusty priority queue server API.",
   "main": "index.js",
   "author": "Gordon Greene <greeng3@obscure-reference.com>",
@@ -10,7 +10,8 @@
     "docs": "jsdoc -c jsdoc.json"
   },
   "dependencies": {
-    "axios": "^1.13.5"
+    "axios": "^1.13.5",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "jest": "30.2.0",