@redflow/client 0.0.1

package/tests/fixtures/worker-crash.ts

@@ -0,0 +1,42 @@
+import { RedisClient } from "bun";
+import { defineWorkflow, startWorker } from "../../src/index";
+
+const url = process.env.REDIS_URL;
+const prefix = process.env.REDFLOW_PREFIX;
+const workflowName = process.env.TEST_WORKFLOW;
+const queue = process.env.TEST_QUEUE;
+const step1Key = process.env.TEST_STEP1_KEY;
+
+if (!url || !prefix || !workflowName || !queue || !step1Key) {
+  console.error("Missing env: REDIS_URL/REDFLOW_PREFIX/TEST_WORKFLOW/TEST_QUEUE/TEST_STEP1_KEY");
+  process.exit(2);
+}
+
+const redis = new RedisClient(url);
+
+defineWorkflow(
+  {
+    name: workflowName,
+    queue,
+    retries: { maxAttempts: 3 },
+  },
+  async ({ step }) => {
+    await step.run({ name: "step1" }, async () => {
+      await redis.incr(step1Key);
+      return { ok: true };
+    });
+
+    // Simulate a hard crash after step is persisted.
+    process.exit(1);
+  },
+);
+
+await startWorker({
+  url,
+  prefix,
+  queues: [queue],
+  runtime: { leaseMs: 200, blmoveTimeoutSec: 0.2, reaperIntervalMs: 50 },
+});
+
+// Keep alive.
+await new Promise(() => {});

package/tests/fixtures/worker-recover.ts

@@ -0,0 +1,63 @@
+import { RedisClient } from "bun";
+import { createClient, defineWorkflow, startWorker } from "../../src/index";
+
+const url = process.env.REDIS_URL;
+const prefix = process.env.REDFLOW_PREFIX;
+const workflowName = process.env.TEST_WORKFLOW;
+const queue = process.env.TEST_QUEUE;
+const step1Key = process.env.TEST_STEP1_KEY;
+const runId = process.env.TEST_RUN_ID;
+
+if (!url || !prefix || !workflowName || !queue || !step1Key || !runId) {
+  console.error("Missing env: REDIS_URL/REDFLOW_PREFIX/TEST_WORKFLOW/TEST_QUEUE/TEST_STEP1_KEY/TEST_RUN_ID");
+  process.exit(2);
+}
+
+const redis = new RedisClient(url);
+const client = createClient({ redis, prefix });
+
+defineWorkflow(
+  {
+    name: workflowName,
+    queue,
+    retries: { maxAttempts: 3 },
+  },
+  async ({ step }) => {
+    await step.run({ name: "step1" }, async () => {
+      await redis.incr(step1Key);
+      return { ok: true };
+    });
+
+    await step.run({ name: "step2" }, async () => true);
+    return { ok: true };
+  },
+);
+
+const worker = await startWorker({
+  url,
+  prefix,
+  queues: [queue],
+  runtime: { leaseMs: 200, reaperIntervalMs: 50, blmoveTimeoutSec: 0.2 },
+});
+
+const deadline = Date.now() + 10_000;
+while (Date.now() < deadline) {
+  const run = await client.getRun(runId);
+  if (run?.status === "succeeded") {
+    await worker.stop();
+    redis.close();
+    process.exit(0);
+  }
+  if (run?.status === "failed") {
+    console.error("run failed", run.error);
+    await worker.stop();
+    redis.close();
+    process.exit(3);
+  }
+  await new Promise((r) => setTimeout(r, 50));
+}
+
+console.error("timeout waiting for run to complete");
+await worker.stop();
+redis.close();
+process.exit(4);

package/tests/helpers/getFreePort.ts

@@ -0,0 +1,18 @@
+import net from "node:net";
+
+export function getFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        server.close(() => reject(new Error("Failed to allocate port")));
+        return;
+      }
+      const port = addr.port;
+      server.close(() => resolve(port));
+    });
+  });
+}

package/tests/helpers/redisTestServer.ts

@@ -0,0 +1,77 @@
+import { RedisClient } from "bun";
+import { getFreePort } from "./getFreePort";
+
+export type RedisTestServer = {
+  url: string;
+  port: number;
+  stop(): Promise<void>;
+};
+
+/**
+ * If REDIS_URL is set (e.g. in CI with a service container), use it directly
+ * instead of spawning a child process — bun test kills spawned processes.
+ */
+export async function startRedisTestServer(): Promise<RedisTestServer> {
+  if (process.env.REDIS_URL) {
+    const url = process.env.REDIS_URL;
+    const port = Number(new URL(url).port) || 6379;
+
+    const client = new RedisClient(url);
+    const pong = await client.ping();
+    client.close();
+    if (pong !== "PONG") throw new Error(`External Redis at ${url} is not responding`);
+
+    return { url, port, async stop() {} };
+  }
+
+  const port = await getFreePort();
+  const url = `redis://127.0.0.1:${port}`;
+
+  const proc = Bun.spawn([
+    "redis-server",
+    "--port",
+    String(port),
+    "--bind",
+    "127.0.0.1",
+    "--save",
+    "",
+    "--appendonly",
+    "no",
+  ], {
+    stdout: "ignore",
+    stderr: "pipe",
+  });
+
+  const client = new RedisClient(url);
+
+  const started = Date.now();
+  while (true) {
+    try {
+      const pong = await client.ping();
+      if (pong === "PONG") break;
+    } catch {
+      // retry
+    }
+
+    if (Date.now() - started > 5000) {
+      const stderr = await new Response(proc.stderr).text().catch(() => "");
+      console.log('kill');
+      proc.kill("SIGKILL");
+      client.close();
+      throw new Error(`Redis failed to start. stderr:\n${stderr}`);
+    }
+
+    await new Promise((r) => setTimeout(r, 50));
+  }
+
+  client.close();
+
+  return {
+    url,
+    port,
+    async stop() {
+      proc.kill("SIGTERM");
+      await proc.exited.catch(() => {});
+    },
+  };
+}

package/tests/helpers/waitFor.ts

@@ -0,0 +1,16 @@
+export async function waitFor(
+  fn: () => Promise<boolean> | boolean,
+  options?: { timeoutMs?: number; intervalMs?: number; label?: string },
+): Promise<void> {
+  const timeoutMs = options?.timeoutMs ?? 5000;
+  const intervalMs = options?.intervalMs ?? 50;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    if (await fn()) return;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+
+  const label = options?.label ? `: ${options.label}` : "";
+  throw new Error(`waitFor timeout${label}`);
+}