@omnitronix/rng-client-core 1.0.10 → 1.1.2

package/src/__tests__/grpc-rng-client.test.ts

@@ -0,0 +1,167 @@
+import { GrpcRngClient } from "../grpc/grpc-rng-client";
+
+// Mock the gRPC client
+const mockGrpcClient = {
+  Single: jest.fn(),
+  SingleBatch: jest.fn(),
+  Float: jest.fn(),
+  FloatBatch: jest.fn(),
+  SingleBatchWithSeeds: jest.fn(),
+  FloatBatchWithSeeds: jest.fn(),
+};
+
+// Mock gRPC modules
+jest.mock("@grpc/grpc-js", () => ({
+  loadPackageDefinition: jest.fn(() => ({
+    rng: {
+      RngService: jest.fn(() => mockGrpcClient),
+    },
+  })),
+  credentials: {
+    createInsecure: jest.fn(),
+  },
+}));
+
+jest.mock("@grpc/proto-loader", () => ({
+  loadSync: jest.fn(() => ({})),
+}));
+
+describe("GrpcRngClient", () => {
+  let grpcRngClient: GrpcRngClient;
+
+  beforeEach(() => {
+    grpcRngClient = new GrpcRngClient("localhost:50051");
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("getSingleNumber", () => {
+    it("should call Single method with correct parameters", async () => {
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockGrpcClient.Single.mockImplementation((request, callback) => {
+        callback(null, mockResponse);
+      });
+
+      const result = await grpcRngClient.getSingleNumber({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+
+      expect(mockGrpcClient.Single).toHaveBeenCalledWith(
+        {
+          min: 1,
+          max: 100,
+          seed: 12345,
+        },
+        expect.any(Function)
+      );
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe("getBatchNumbers", () => {
+    it("should call SingleBatch method with correct parameters", async () => {
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: [1, 2, 3, 4, 5],
+        min: 1,
+        max: 100,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockGrpcClient.SingleBatch.mockImplementation((request, callback) => {
+        callback(null, mockResponse);
+      });
+
+      const result = await grpcRngClient.getBatchNumbers({
+        min: 1,
+        max: 100,
+        count: 5,
+        seed: 12345,
+      });
+
+      expect(mockGrpcClient.SingleBatch).toHaveBeenCalledWith(
+        {
+          min: 1,
+          max: 100,
+          count: 5,
+          seed: 12345,
+        },
+        expect.any(Function)
+      );
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe("getSingleFloat", () => {
+    it("should call Float method with correct parameters", async () => {
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockGrpcClient.Float.mockImplementation((request, callback) => {
+        callback(null, mockResponse);
+      });
+
+      const result = await grpcRngClient.getSingleFloat({
+        seed: 12345,
+      });
+
+      expect(mockGrpcClient.Float).toHaveBeenCalledWith(
+        {
+          seed: 12345,
+        },
+        expect.any(Function)
+      );
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe("getBatchFloats", () => {
+    it("should call FloatBatch method with correct parameters", async () => {
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: [0.1, 0.2, 0.3, 0.4, 0.5],
+        min: 0,
+        max: 1,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockGrpcClient.FloatBatch.mockImplementation((request, callback) => {
+        callback(null, mockResponse);
+      });
+
+      const result = await grpcRngClient.getBatchFloats({
+        count: 5,
+        seed: 12345,
+      });
+
+      expect(mockGrpcClient.FloatBatch).toHaveBeenCalledWith(
+        {
+          count: 5,
+          seed: 12345,
+        },
+        expect.any(Function)
+      );
+      expect(result).toEqual(mockResponse);
+    });
+  });
+});

package/src/__tests__/rng-client-core.integration.test.ts

@@ -0,0 +1,117 @@
+import { RngClientCore } from "../core/rng-client-core";
+import { RngClientConfig } from "../interfaces/client-interfaces";
+
+// Mock the HTTP and gRPC clients
+jest.mock("../http/http-rng-client", () => ({
+  HttpRngClient: jest.fn().mockImplementation(() => ({
+    getSingleNumber: jest.fn(),
+    getBatchNumbers: jest.fn(),
+    getSingleFloat: jest.fn(),
+    getBatchFloats: jest.fn(),
+  })),
+}));
+
+jest.mock("../grpc/grpc-rng-client", () => ({
+  GrpcRngClient: jest.fn().mockImplementation(() => ({
+    getSingleNumber: jest.fn(),
+    getBatchNumbers: jest.fn(),
+    getSingleFloat: jest.fn(),
+    getBatchFloats: jest.fn(),
+  })),
+}));
+
+describe("RngClientCore Integration", () => {
+  let mockHttpClient: any;
+  let mockGrpcClient: any;
+
+  beforeEach(() => {
+    const { HttpRngClient } = require("../http/http-rng-client");
+    const { GrpcRngClient } = require("../grpc/grpc-rng-client");
+
+    mockHttpClient = {
+      getSingleNumber: jest.fn(),
+      getBatchNumbers: jest.fn(),
+      getSingleFloat: jest.fn(),
+      getBatchFloats: jest.fn(),
+    };
+
+    mockGrpcClient = {
+      getSingleNumber: jest.fn(),
+      getBatchNumbers: jest.fn(),
+      getSingleFloat: jest.fn(),
+      getBatchFloats: jest.fn(),
+    };
+
+    HttpRngClient.mockImplementation(() => mockHttpClient);
+    GrpcRngClient.mockImplementation(() => mockGrpcClient);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("REST client initialization", () => {
+    it('should initialize with HttpRngClient when clientMethod is "rest"', () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "rest",
+      };
+
+      new RngClientCore(config);
+
+      const { HttpRngClient } = require("../http/http-rng-client");
+      expect(HttpRngClient).toHaveBeenCalledWith("http://localhost:3001");
+    });
+  });
+
+  describe("gRPC client initialization", () => {
+    it('should initialize with GrpcRngClient when clientMethod is "grpc"', () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "grpc",
+      };
+
+      new RngClientCore(config);
+
+      const { GrpcRngClient } = require("../grpc/grpc-rng-client");
+      expect(GrpcRngClient).toHaveBeenCalledWith("localhost:50051");
+    });
+  });
+
+  describe("method delegation", () => {
+    it("should delegate getRandomNumber to the correct client", async () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "rest",
+      };
+
+      const clientCore = new RngClientCore(config);
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockHttpClient.getSingleNumber.mockResolvedValue(mockResponse);
+
+      const result = await clientCore.getRandomNumber({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+
+      expect(mockHttpClient.getSingleNumber).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+});

package/src/__tests__/rng-client-core.test.ts

@@ -0,0 +1,249 @@
+import { RngClientCore } from "../core/rng-client-core";
+import { RngClientConfig } from "../interfaces/client-interfaces";
+
+// Mock the HTTP and gRPC clients
+jest.mock("../http/http-rng-client", () => ({
+  HttpRngClient: jest.fn().mockImplementation(() => ({
+    getSingleNumber: jest.fn(),
+    getBatchNumbers: jest.fn(),
+    getSingleFloat: jest.fn(),
+    getBatchFloats: jest.fn(),
+  })),
+}));
+
+jest.mock("../grpc/grpc-rng-client", () => ({
+  GrpcRngClient: jest.fn().mockImplementation(() => ({
+    getSingleNumber: jest.fn(),
+    getBatchNumbers: jest.fn(),
+    getSingleFloat: jest.fn(),
+    getBatchFloats: jest.fn(),
+  })),
+}));
+
+describe("RngClientCore", () => {
+  let mockHttpClient: any;
+  let mockGrpcClient: any;
+
+  beforeEach(() => {
+    const { HttpRngClient } = require("../http/http-rng-client");
+    const { GrpcRngClient } = require("../grpc/grpc-rng-client");
+
+    mockHttpClient = {
+      getSingleNumber: jest.fn(),
+      getBatchNumbers: jest.fn(),
+      getSingleFloat: jest.fn(),
+      getBatchFloats: jest.fn(),
+    };
+
+    mockGrpcClient = {
+      getSingleNumber: jest.fn(),
+      getBatchNumbers: jest.fn(),
+      getSingleFloat: jest.fn(),
+      getBatchFloats: jest.fn(),
+    };
+
+    HttpRngClient.mockImplementation(() => mockHttpClient);
+    GrpcRngClient.mockImplementation(() => mockGrpcClient);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("REST client initialization", () => {
+    it('should initialize with HttpRngClient when clientMethod is "rest"', () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "rest",
+      };
+
+      new RngClientCore(config);
+
+      const { HttpRngClient } = require("../http/http-rng-client");
+      expect(HttpRngClient).toHaveBeenCalledWith("http://localhost:3001");
+    });
+  });
+
+  describe("gRPC client initialization", () => {
+    it('should initialize with GrpcRngClient when clientMethod is "grpc"', () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "grpc",
+      };
+
+      new RngClientCore(config);
+
+      const { GrpcRngClient } = require("../grpc/grpc-rng-client");
+      expect(GrpcRngClient).toHaveBeenCalledWith("localhost:50051");
+    });
+  });
+
+  describe("getRandomNumber", () => {
+    it("should call the correct client method", async () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "rest",
+      };
+
+      const clientCore = new RngClientCore(config);
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockHttpClient.getSingleNumber.mockResolvedValue(mockResponse);
+
+      const result = await clientCore.getRandomNumber({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+
+      expect(mockHttpClient.getSingleNumber).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe("getBatchNumbers", () => {
+    it("should call the correct client method", async () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "rest",
+      };
+
+      const clientCore = new RngClientCore(config);
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: [1, 2, 3, 4, 5],
+        min: 1,
+        max: 100,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockHttpClient.getBatchNumbers.mockResolvedValue(mockResponse);
+
+      const result = await clientCore.getBatchNumbers({
+        min: 1,
+        max: 100,
+        count: 5,
+        seed: 12345,
+      });
+
+      expect(mockHttpClient.getBatchNumbers).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        count: 5,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe("getSingleFloat", () => {
+    it("should call the correct client method", async () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "rest",
+      };
+
+      const clientCore = new RngClientCore(config);
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockHttpClient.getSingleFloat.mockResolvedValue(mockResponse);
+
+      const result = await clientCore.getSingleFloat({
+        seed: 12345,
+      });
+
+      expect(mockHttpClient.getSingleFloat).toHaveBeenCalledWith({
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe("getBatchFloats", () => {
+    it("should call the correct client method", async () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "rest",
+      };
+
+      const clientCore = new RngClientCore(config);
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: [0.1, 0.2, 0.3, 0.4, 0.5],
+        min: 0,
+        max: 1,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockHttpClient.getBatchFloats.mockResolvedValue(mockResponse);
+
+      const result = await clientCore.getBatchFloats({
+        count: 5,
+        seed: 12345,
+      });
+
+      expect(mockHttpClient.getBatchFloats).toHaveBeenCalledWith({
+        count: 5,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe("getRandomFloat", () => {
+    it("should call getSingleFloat with correct parameters", async () => {
+      const config: RngClientConfig = {
+        serverUrl: "http://localhost:3001",
+        grpcUrl: "localhost:50051",
+        clientMethod: "rest",
+      };
+
+      const clientCore = new RngClientCore(config);
+      const mockResponse = {
+        id: "test-id",
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: "2023-01-01T00:00:00Z",
+      };
+
+      mockHttpClient.getSingleFloat.mockResolvedValue(mockResponse);
+
+      const result = await clientCore.getRandomFloat({
+        seed: 12345,
+      });
+
+      expect(mockHttpClient.getSingleFloat).toHaveBeenCalledWith({
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+});