@forwardimpact/librpc 0.1.77

package/test/auth.test.js

@@ -0,0 +1,94 @@
+import { test, describe, beforeEach } from "node:test";
+import assert from "node:assert";
+
+import { createAuth, HmacAuth } from "../index.js";
+
+describe("Auth", () => {
+  describe("HmacAuth", () => {
+    test("should throw if secret is missing or too short", () => {
+      assert.throws(() => new HmacAuth(), /Secret must be a non-empty string/);
+      assert.throws(
+        () => new HmacAuth("short"),
+        /Secret must be at least 32 characters long/,
+      );
+    });
+
+    test("should generate and verify valid tokens", () => {
+      const secret = "test-secret-that-is-at-least-32-characters-long";
+      const auth = new HmacAuth(secret);
+      const serviceId = "test-service";
+
+      const token = auth.generateToken(serviceId);
+      assert.ok(token);
+
+      const result = auth.verifyToken(token);
+      assert.strictEqual(result.isValid, true);
+      assert.strictEqual(result.serviceId, serviceId);
+    });
+
+    test("should reject expired tokens", async () => {
+      const secret = "test-secret-that-is-at-least-32-characters-long";
+      // 1 second lifetime
+      const auth = new HmacAuth(secret, 1);
+      const serviceId = "test-service";
+
+      const token = auth.generateToken(serviceId);
+
+      // Wait for token to expire (1.1 seconds)
+      await new Promise((resolve) => setTimeout(resolve, 1100));
+
+      const result = auth.verifyToken(token);
+      assert.strictEqual(result.isValid, false);
+      assert.match(result.error, /Token has expired/);
+    });
+
+    test("should reject invalid signatures", () => {
+      const secret = "test-secret-that-is-at-least-32-characters-long";
+      const auth = new HmacAuth(secret);
+      const serviceId = "test-service";
+
+      const token = auth.generateToken(serviceId);
+
+      // Tamper with the token (it's base64 encoded)
+      const decoded = Buffer.from(token, "base64").toString("utf8");
+      const parts = decoded.split(":");
+      // Change serviceId part
+      parts[0] = "other-service";
+      const tamperedToken = Buffer.from(parts.join(":")).toString("base64");
+
+      const result = auth.verifyToken(tamperedToken);
+      assert.strictEqual(result.isValid, false);
+      assert.match(result.error, /Invalid token signature/);
+    });
+  });
+
+  describe("createAuth", () => {
+    let originalEnv;
+
+    beforeEach(() => {
+      originalEnv = process.env.SERVICE_SECRET;
+    });
+
+    test("should throw if SERVICE_SECRET is missing", () => {
+      delete process.env.SERVICE_SECRET;
+      assert.throws(
+        () => createAuth("test"),
+        /SERVICE_SECRET environment variable is required/,
+      );
+    });
+
+    test("should create Interceptor with valid secret", () => {
+      process.env.SERVICE_SECRET =
+        "test-secret-that-is-at-least-32-characters-long";
+      const interceptor = createAuth("test");
+      assert.ok(interceptor);
+
+      // Cleanup
+      if (originalEnv) {
+        process.env.SERVICE_SECRET = originalEnv;
+      } else {
+        delete process.env.SERVICE_SECRET;
+      }
+    });
+  });
+});

package/test/client.test.js

@@ -0,0 +1,138 @@
+import { test, describe, beforeEach, mock } from "node:test";
+import assert from "node:assert";
+import { PassThrough } from "stream";
+
+import { Client } from "../index.js";
+import {
+  createMockGrpcFn,
+  createMockObserverFn,
+  createMockAuthFn,
+  createMockLogger,
+} from "@forwardimpact/libharness";
+
+describe("Client", () => {
+  let mockConfig;
+  let mockGrpcFn;
+  let mockAuthFn;
+  let mockLogFn;
+  let mockObserverFn;
+  let mockClientInstance;
+
+  beforeEach(() => {
+    mockConfig = {
+      name: "memory", // Use a valid service name that exists in definitions
+      host: "0.0.0.0",
+      port: 5000,
+    };
+
+    mockClientInstance = {
+      TestMethod: mock.fn((_req, _meta, cb) => cb(null, { result: "success" })),
+      StreamMethod: mock.fn((_req, _meta) => {
+        const stream = new PassThrough({ objectMode: true });
+        process.nextTick(() => {
+          stream.emit("metadata", {});
+          stream.write({ result: "chunk1" });
+          stream.write({ result: "chunk2" });
+          stream.end();
+        });
+        return stream;
+      }),
+    };
+
+    mockGrpcFn = createMockGrpcFn({
+      grpc: {
+        Metadata: class {},
+        makeGenericClientConstructor: mock.fn(() => {
+          return function () {
+            return mockClientInstance;
+          };
+        }),
+      },
+    });
+
+    mockAuthFn = createMockAuthFn();
+
+    mockLogFn = createMockLogger();
+
+    mockObserverFn = createMockObserverFn();
+  });
+
+  test("should require config parameter", () => {
+    assert.throws(
+      () =>
+        new Client(
+          null,
+          mockLogFn,
+          null,
+          mockObserverFn,
+          mockGrpcFn,
+          mockAuthFn,
+        ),
+      /config is required/,
+    );
+  });
+
+  test("should accept valid parameters", () => {
+    const client = new Client(
+      mockConfig,
+      mockLogFn,
+      null,
+      mockObserverFn,
+      mockGrpcFn,
+      mockAuthFn,
+    );
+
+    assert.ok(client);
+    assert.strictEqual(client.config, mockConfig);
+  });
+
+  test("callUnary should execute unary call", async () => {
+    const client = new Client(
+      mockConfig,
+      mockLogFn,
+      null,
+      mockObserverFn,
+      mockGrpcFn,
+      mockAuthFn,
+    );
+
+    const response = await client.callUnary("TestMethod", { some: "data" });
+    assert.deepStrictEqual(response, { result: "success" });
+    assert.strictEqual(mockClientInstance.TestMethod.mock.callCount(), 1);
+  });
+
+  test("callStream should execute streaming call", async () => {
+    const client = new Client(
+      mockConfig,
+      mockLogFn,
+      null,
+      mockObserverFn,
+      mockGrpcFn,
+      mockAuthFn,
+    );
+
+    const stream = client.callStream("StreamMethod", { some: "data" });
+
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+    }
+
+    assert.strictEqual(chunks.length, 2);
+    assert.deepStrictEqual(chunks[0], { result: "chunk1" });
+    assert.deepStrictEqual(chunks[1], { result: "chunk2" });
+    assert.strictEqual(mockClientInstance.StreamMethod.mock.callCount(), 1);
+  });
+
+  test("should accept tracer parameter", () => {
+    const client = new Client(
+      mockConfig,
+      mockLogFn,
+      {}, // tracer
+      mockObserverFn,
+      mockGrpcFn,
+      mockAuthFn,
+    );
+    assert.ok(client);
+  });
+});

package/test/server.test.js

@@ -0,0 +1,123 @@
+import { test, describe, beforeEach, mock } from "node:test";
+import assert from "node:assert";
+
+import { Server } from "../index.js";
+import {
+  createMockConfig,
+  createMockGrpcFn,
+  createMockObserverFn,
+  createMockAuthFn,
+  createMockLogger,
+  createMockTracer,
+} from "@forwardimpact/libharness";
+
+describe("Server", () => {
+  let mockService;
+  let mockConfig;
+  let mockGrpcFn;
+  let mockAuthFn;
+  let mockLogFn;
+  let mockObserverFn;
+
+  beforeEach(() => {
+    mockService = {
+      getHandlers: () => ({
+        TestMethod: async (_call) => ({ result: "test" }),
+      }),
+    };
+
+    mockConfig = createMockConfig("memory", { host: "0.0.0.0", port: 5000 });
+    mockGrpcFn = createMockGrpcFn();
+    mockAuthFn = createMockAuthFn();
+    mockLogFn = createMockLogger();
+    mockObserverFn = createMockObserverFn(mockLogFn);
+  });
+
+  test("should require service parameter", () => {
+    assert.throws(
+      () =>
+        new Server(
+          null,
+          mockConfig,
+          mockLogFn,
+          null,
+          mockObserverFn,
+          mockGrpcFn,
+          mockAuthFn,
+        ),
+      /service is required/,
+    );
+  });
+
+  test("should require config parameter", () => {
+    assert.throws(
+      () =>
+        new Server(
+          mockService,
+          null,
+          mockLogFn,
+          null,
+          mockObserverFn,
+          mockGrpcFn,
+          mockAuthFn,
+        ),
+      /config is required/,
+    );
+  });
+
+  test("should accept valid parameters", () => {
+    const server = new Server(
+      mockService,
+      mockConfig,
+      mockLogFn,
+      null,
+      mockObserverFn,
+      mockGrpcFn,
+      mockAuthFn,
+    );
+
+    assert.ok(server);
+    assert.strictEqual(server.config, mockConfig);
+  });
+
+  test("should call service methods during setup", async () => {
+    const getHandlersSpy = mock.fn(() => ({
+      TestMethod: async () => ({ result: "test" }),
+    }));
+
+    const spiedService = {
+      getHandlers: getHandlersSpy,
+    };
+
+    const server = new Server(
+      spiedService,
+      mockConfig,
+      mockLogFn,
+      null,
+      mockObserverFn,
+      mockGrpcFn,
+      mockAuthFn,
+    );
+
+    // Start the server to trigger setup
+    await server.start();
+
+    assert.strictEqual(getHandlersSpy.mock.callCount(), 1);
+  });
+
+  test("should accept tracer parameter", () => {
+    const mockTracer = createMockTracer();
+
+    const server = new Server(
+      mockService,
+      mockConfig,
+      mockLogFn,
+      mockTracer,
+      mockObserverFn,
+      mockGrpcFn,
+      mockAuthFn,
+    );
+
+    assert.ok(server);
+  });
+});