@service-bridge/node 0.1.3

package/sdk/src/grpc-client.test.ts

@@ -0,0 +1,422 @@
+// @ts-nocheck
+import { describe, expect, it, mock } from "bun:test";
+import { EventEmitter } from "node:events";
+
+type UnaryCallback = (err: unknown, res?: unknown) => void;
+type ReportCallback = (err: unknown) => void;
+type WorkerCallback = (err: unknown, res?: unknown) => void;
+type LookupCallback = (
+  err: unknown,
+  res?: {
+    found?: boolean;
+    canonical_name?: string;
+    endpoints?: {
+      endpoints?: Array<{
+        endpoint: string;
+        transport?: string;
+        instance_id?: string;
+        weight?: number;
+      }>;
+    };
+  },
+) => void;
+
+const grpcState = {
+  publishCalls: [] as unknown[],
+  workerCalls: [] as unknown[],
+  reportCallStartCalls: [] as unknown[],
+  reportCallCalls: [] as unknown[],
+  lookupCalls: [] as unknown[],
+  publishImpl: (_req: unknown, cb: UnaryCallback) =>
+    cb(null, { message_id: "msg-1" }),
+  registerJobImpl: (_req: unknown, cb: UnaryCallback) =>
+    cb(null, { id: "job-1" }),
+  registerWorkflowImpl: (_req: unknown, cb: UnaryCallback) =>
+    cb(null, { id: "wf-1" }),
+  reportCallStartImpl: (_req: unknown, cb: ReportCallback) => cb(null),
+  reportCallImpl: (_req: unknown, cb: ReportCallback) => cb(null),
+  lookupImpl: (_req: { fn_name: string }, cb: LookupCallback) =>
+    cb(null, { found: false }),
+  workerHandleImpl: (
+    _req: unknown,
+    _meta: unknown,
+    _opts: unknown,
+    cb: WorkerCallback,
+  ) =>
+    cb(null, {
+      success: true,
+      output: Buffer.from(JSON.stringify({ ok: true })),
+    }),
+  reset() {
+    this.publishCalls = [];
+    this.workerCalls = [];
+    this.reportCallStartCalls = [];
+    this.reportCallCalls = [];
+    this.lookupCalls = [];
+    this.publishImpl = (_req: unknown, cb: UnaryCallback) =>
+      cb(null, { message_id: "msg-1" });
+    this.registerJobImpl = (_req: unknown, cb: UnaryCallback) =>
+      cb(null, { id: "job-1" });
+    this.registerWorkflowImpl = (_req: unknown, cb: UnaryCallback) =>
+      cb(null, { id: "wf-1" });
+    this.reportCallStartImpl = (_req: unknown, cb: ReportCallback) => cb(null);
+    this.reportCallImpl = (_req: unknown, cb: ReportCallback) => cb(null);
+    this.lookupImpl = (_req: { fn_name: string }, cb: LookupCallback) =>
+      cb(null, { found: false });
+    this.workerHandleImpl = (
+      _req: unknown,
+      _meta: unknown,
+      _opts: unknown,
+      cb: WorkerCallback,
+    ) =>
+      cb(null, {
+        success: true,
+        output: Buffer.from(JSON.stringify({ ok: true })),
+      });
+  },
+};
+
+class FakeMetadata {
+  store = new Map<string, unknown[]>();
+
+  add(key: string, value: unknown) {
+    const normalized = key.toLowerCase();
+    const list = this.store.get(normalized) ?? [];
+    list.push(value);
+    this.store.set(normalized, list);
+  }
+
+  get(key: string) {
+    return this.store.get(key.toLowerCase()) ?? [];
+  }
+}
+
+class FakeControlPlaneClient {
+  close() {}
+
+  LookupFunction(
+    req: { fn_name: string },
+    _meta: unknown,
+    _opts: unknown,
+    cb: LookupCallback,
+  ) {
+    grpcState.lookupCalls.push(req);
+    grpcState.lookupImpl(req, cb);
+  }
+
+  Publish(req: unknown, _meta: unknown, _opts: unknown, cb: UnaryCallback) {
+    grpcState.publishCalls.push(req);
+    grpcState.publishImpl(req, cb);
+  }
+
+  RegisterJob(req: unknown, _meta: unknown, _opts: unknown, cb: UnaryCallback) {
+    grpcState.registerJobImpl(req, cb);
+  }
+
+  RegisterWorkflow(
+    req: unknown,
+    _meta: unknown,
+    _opts: unknown,
+    cb: UnaryCallback,
+  ) {
+    grpcState.registerWorkflowImpl(req, cb);
+  }
+
+  ReportCallStart(
+    req: unknown,
+    _meta: unknown,
+    _opts: unknown,
+    cb: ReportCallback,
+  ) {
+    grpcState.reportCallStartCalls.push(req);
+    grpcState.reportCallStartImpl(req, cb);
+  }
+
+  ReportCall(req: unknown, _meta: unknown, _opts: unknown, cb: ReportCallback) {
+    grpcState.reportCallCalls.push(req);
+    grpcState.reportCallImpl(req, cb);
+  }
+
+  ReportLog(_req: unknown, _meta: unknown, _opts: unknown, cb: ReportCallback) {
+    cb(null);
+  }
+
+  Heartbeat(_req: unknown, _meta: unknown, _opts: unknown, cb: ReportCallback) {
+    cb(null);
+  }
+
+  RegisterFunction(
+    _req: unknown,
+    _meta: unknown,
+    _opts: unknown,
+    cb: ReportCallback,
+  ) {
+    cb(null);
+  }
+
+  RegisterConsumerGroup(
+    _req: unknown,
+    _meta: unknown,
+    _opts: unknown,
+    cb: ReportCallback,
+  ) {
+    cb(null);
+  }
+
+  RegisterGroupMember(
+    _req: unknown,
+    _meta: unknown,
+    _opts: unknown,
+    cb: ReportCallback,
+  ) {
+    cb(null);
+  }
+
+  AppendStream(
+    _req: unknown,
+    _meta: unknown,
+    _opts: unknown,
+    cb: ReportCallback,
+  ) {
+    cb(null);
+  }
+
+  WatchRun(_req: unknown, _meta: unknown) {
+    return new EventEmitter();
+  }
+}
+
+class FakeWorkerClient {
+  endpoint: string;
+
+  constructor(endpoint: string) {
+    this.endpoint = endpoint;
+  }
+
+  close() {}
+
+  Handle(req: unknown, meta: unknown, opts: unknown, cb: WorkerCallback) {
+    grpcState.workerCalls.push({ endpoint: this.endpoint, req, meta, opts });
+    grpcState.workerHandleImpl(req, meta, opts, cb);
+  }
+}
+
+/** A no-op Channel stub — FakeWorkerClient ignores channelOverride. */
+class FakeChannel {
+  close() {}
+  getConnectivityState() {
+    return 0;
+  }
+}
+
+mock.module("@grpc/grpc-js", () => ({
+  status: {
+    CANCELLED: 1,
+    UNKNOWN: 2,
+    DEADLINE_EXCEEDED: 4,
+    NOT_FOUND: 5,
+    RESOURCE_EXHAUSTED: 8,
+    FAILED_PRECONDITION: 9,
+    UNAVAILABLE: 14,
+  },
+  Metadata: FakeMetadata,
+  Channel: FakeChannel,
+  loadPackageDefinition() {
+    return {
+      servicebridge: {
+        ServiceBridge: FakeControlPlaneClient,
+        ServiceBridgeWorker: FakeWorkerClient,
+      },
+    };
+  },
+  credentials: {
+    createInsecure() {
+      return {};
+    },
+    createSsl() {
+      return {};
+    },
+  },
+  Server: class {},
+  ServerCredentials: {
+    createSsl() {
+      return {};
+    },
+    createInsecure() {
+      return {};
+    },
+  },
+}));
+
+const sdk = await import("./grpc-client");
+
+async function flushMicrotasks() {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+const TEST_WORKER_TLS = {
+  caCert: "-----BEGIN CERTIFICATE-----\nMIIB\n-----END CERTIFICATE-----",
+  cert: "-----BEGIN CERTIFICATE-----\nMIIB\n-----END CERTIFICATE-----",
+  key: "-----BEGIN EC PRIVATE KEY-----\nMIIB\n-----END EC PRIVATE KEY-----",
+};
+
+const sb = (opts?: Record<string, unknown>) =>
+  sdk.servicebridge("127.0.0.1:14445", "service-key", "caller", {
+    workerTLS: TEST_WORKER_TLS,
+    ...opts,
+  });
+
+/** Configure a canonical function for lookup. */
+function configureLookup(
+  canonicalName: string,
+  endpoints: Array<{ endpoint: string }>,
+) {
+  const prev = grpcState.lookupImpl;
+  grpcState.lookupImpl = (req, cb) => {
+    if (req.fn_name === canonicalName) {
+      cb(null, {
+        found: true,
+        canonical_name: canonicalName,
+        endpoints: {
+          endpoints: endpoints.map((e) => ({
+            ...e,
+            transport: "tls",
+            weight: 1,
+          })),
+        },
+      });
+    } else {
+      prev(req, cb);
+    }
+  };
+}
+
+describe("servicebridge sdk", () => {
+  it("throws when function has no endpoints (LookupFunction returns not found)", async () => {
+    grpcState.reset();
+    const client = sb();
+    await flushMicrotasks();
+
+    // lookupImpl returns { found: false } by default
+    await expect(client.rpc("svc/echo", { value: 1 })).rejects.toThrow(
+      "No endpoints available for RPC: svc/echo",
+    );
+    client.stop();
+  });
+
+  it("rpc after stop() throws no endpoints error", async () => {
+    grpcState.reset();
+    const client = sb();
+    await flushMicrotasks();
+    client.stop();
+
+    await expect(client.rpc("svc/echo", { value: 1 })).rejects.toThrow(
+      "No endpoints available for RPC: svc/echo",
+    );
+  });
+
+  it("publishes events with trace context from AsyncLocalStorage", async () => {
+    grpcState.reset();
+    const client = sb();
+    // Wait for _controlReady.then(() => { isOnline = true }) to fire.
+    await flushMicrotasks();
+
+    const messageId = await sdk.runWithTraceContext(
+      { traceId: "trace-1", spanId: "span-1" },
+      () =>
+        client.event(
+          "order.created",
+          { value: 1 },
+          {
+            headers: { source: "test" },
+            idempotencyKey: "idem-1",
+          },
+        ),
+    );
+
+    expect(messageId).toBe("msg-1");
+    expect(grpcState.publishCalls).toHaveLength(1);
+    expect(grpcState.publishCalls[0]).toMatchObject({
+      topic: "order.created",
+      trace_id: "trace-1",
+      parent_span_id: "span-1",
+      producer_service: "caller",
+      idempotency_key: "idem-1",
+      headers: { source: "test" },
+    });
+    client.stop();
+  });
+
+  it("queues offline events and flushes them once online", async () => {
+    grpcState.reset();
+    const client = sb();
+
+    // Call event() synchronously — isOnline is still false (microtask from
+    // _controlReady.then() has not run yet). Do NOT await so no microtasks fire.
+    const offlineResultPromise = client.event("offline.topic", { value: 1 });
+    expect(grpcState.publishCalls).toHaveLength(0);
+
+    // Now await the promise. This yields, lets _controlReady.then() run first
+    // (M1 before M2 in the microtask queue), which sets isOnline=true and
+    // flushes the offline queue before the test continuation resumes.
+    const offlineResult = await offlineResultPromise;
+    expect(offlineResult).toBe("");
+    expect(grpcState.publishCalls).toHaveLength(1);
+    expect(grpcState.publishCalls[0]).toMatchObject({ topic: "offline.topic" });
+    client.stop();
+  });
+
+  it("rejects ambiguous rpc aliases", async () => {
+    grpcState.reset();
+    const client = sb();
+    await flushMicrotasks();
+
+    // Seed both canonical names into the local registry via warm-up rpc calls.
+    configureLookup("svc-a/echo", [{ endpoint: "127.0.0.1:5001" }]);
+    configureLookup("svc-b/echo", [{ endpoint: "127.0.0.1:5002" }]);
+
+    await client.rpc("svc-a/echo", { value: 1 });
+    await client.rpc("svc-b/echo", { value: 1 });
+
+    // Both canonical names share short name "echo" → alias map marks it ambiguous.
+    await expect(client.rpc("echo", { value: 1 })).rejects.toThrow(
+      'RPC target "echo" is ambiguous; use canonical service/fn',
+    );
+    client.stop();
+  });
+
+  it("retries rpc on connection error and succeeds on the next attempt", async () => {
+    grpcState.reset();
+
+    let handleCallCount = 0;
+    grpcState.workerHandleImpl = (
+      _req: unknown,
+      _meta: unknown,
+      _opts: unknown,
+      cb: WorkerCallback,
+    ) => {
+      handleCallCount++;
+      if (handleCallCount === 1) {
+        cb({ code: 14, message: "unavailable" });
+        return;
+      }
+      cb(null, {
+        success: true,
+        output: Buffer.from(JSON.stringify({ ok: true })),
+      });
+    };
+
+    configureLookup("svc/echo", [
+      { endpoint: "127.0.0.1:5001" },
+      { endpoint: "127.0.0.1:5002" },
+    ]);
+
+    const client = sb({ retries: 1, retryDelay: 1 });
+    await flushMicrotasks();
+
+    const result = await client.rpc("svc/echo", { value: 1 });
+    expect(result).toEqual({ ok: true });
+    expect(grpcState.workerCalls).toHaveLength(2);
+    client.stop();
+  });
+});