@omnitronix/rng-client-core 1.0.9 → 1.1.1

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

@@ -0,0 +1,324 @@
+import { RngClient } from '../rng-client';
+import { RngClientConfig } from '../interfaces/client-interfaces';
+
+// Mock the RngClientCore
+jest.mock('../core/rng-client-core', () => ({
+  RngClientCore: jest.fn().mockImplementation(() => ({
+    getRandomNumber: jest.fn(),
+    getRandomFloat: jest.fn(),
+    getSingleNumber: jest.fn(),
+    getBatchNumbers: jest.fn(),
+    getSingleFloat: jest.fn(),
+    getBatchFloats: jest.fn(),
+    getBatchNumbersWithSeeds: jest.fn(),
+    getBatchFloatWithSeeds: jest.fn(),
+  })),
+}));
+
+// Mock the RingBuffer
+jest.mock('../ring-buffer/ring-buffer', () => {
+  const mockRngClientCore = {
+    getBatchNumbersWithSeeds: jest.fn().mockResolvedValue({
+      result: [
+        { value: 1, seed: 1 },
+        { value: 2, seed: 2 },
+      ],
+    }),
+  };
+
+  return {
+    RingBuffer: jest.fn().mockImplementation(({ _clientCore }) => ({
+      getNumbersByRange: jest.fn().mockResolvedValue(null),
+      getStats: jest.fn().mockResolvedValue(undefined),
+      fillUpBuffer: jest.fn().mockResolvedValue(undefined),
+      pullNumberByBuffer: jest.fn().mockResolvedValue([]),
+      clientCore: mockRngClientCore,
+    })),
+    FILL_UP_BUFFER_DELAY: 5,
+  };
+});
+
+// Mock the RingStorage
+jest.mock('../ring-buffer/ring-storage', () => ({
+  RingStorage: jest.fn().mockImplementation(() => ({
+    addItemsToBuffer: jest.fn().mockResolvedValue(undefined),
+    getFromBuffer: jest.fn().mockResolvedValue(null),
+    saveBuffer: jest.fn().mockResolvedValue(undefined),
+    getStats: jest.fn().mockResolvedValue(undefined),
+  })),
+  StorageType: {
+    IN_MEMORY: 'in_memory',
+    REDIS: 'redis',
+  },
+}));
+
+describe('RngClient grpc', () => {
+  let rngClient: RngClient;
+  let mockRngClientCore: any;
+
+  const mockConfig: RngClientConfig = {
+    serverUrl: 'http://localhost:3001',
+    grpcUrl: 'localhost:50051',
+    clientMethod: 'grpc',
+  };
+
+  beforeEach(() => {
+    // Mock setTimeout to prevent async calls
+    jest.spyOn(global, 'setTimeout').mockImplementation((_fn) => {
+      // Don't execute the function
+      return 0 as any;
+    });
+
+    const { RngClientCore } = require('../core/rng-client-core');
+    mockRngClientCore = {
+      getRandomNumber: jest.fn(),
+      getRandomFloat: jest.fn(),
+      getSingleNumber: jest.fn(),
+      getBatchNumbers: jest.fn(),
+      getSingleFloat: jest.fn(),
+      getBatchFloats: jest.fn(),
+      getBatchNumbersWithSeeds: jest.fn(),
+      getBatchFloatWithSeeds: jest.fn(),
+    };
+    RngClientCore.mockImplementation(() => mockRngClientCore);
+
+    rngClient = new RngClient(mockConfig);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  describe('getSingleNumber', () => {
+    it('should call clientCore.getSingleNumber with correct parameters', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getSingleNumber.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getSingleNumber(1, 100, 12345);
+
+      expect(mockRngClientCore.getSingleNumber).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+      expect(result).toEqual({
+        value: mockResponse.result,
+        seed: mockResponse.seed,
+      });
+    });
+
+    it('should call clientCore.getSingleNumber without seed', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getSingleNumber.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getSingleNumber(1, 100);
+
+      expect(mockRngClientCore.getSingleNumber).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        seed: undefined,
+      });
+      expect(result).toEqual({
+        value: mockResponse.result,
+        seed: mockResponse.seed,
+      });
+    });
+  });
+
+  describe('getBatchNumbers', () => {
+    it('should call clientCore.getBatchNumbers 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',
+      };
+
+      mockRngClientCore.getBatchNumbers.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getBatchNumbers(1, 100, 5, 12345);
+
+      expect(mockRngClientCore.getBatchNumbers).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        count: 5,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse.result);
+    });
+
+    it('should call clientCore.getBatchNumbers without seed', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: [1, 2, 3, 4, 5],
+        min: 1,
+        max: 100,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getBatchNumbers.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getBatchNumbers(1, 100, 5);
+
+      expect(mockRngClientCore.getBatchNumbers).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        count: 5,
+        seed: undefined,
+      });
+      expect(result).toEqual(mockResponse.result);
+    });
+  });
+
+  describe('getSingleFloat', () => {
+    it('should call clientCore.getSingleFloat with correct parameters', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getSingleFloat.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getSingleFloat(12345);
+
+      expect(mockRngClientCore.getSingleFloat).toHaveBeenCalledWith({
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should call clientCore.getSingleFloat without seed', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getSingleFloat.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getSingleFloat();
+
+      expect(mockRngClientCore.getSingleFloat).toHaveBeenCalledWith({
+        seed: undefined,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getBatchFloats', () => {
+    it('should call clientCore.getBatchFloats 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',
+      };
+
+      mockRngClientCore.getBatchFloats.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getBatchFloats(5, 12345);
+
+      expect(mockRngClientCore.getBatchFloats).toHaveBeenCalledWith({
+        count: 5,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should call clientCore.getBatchFloats without seed', 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',
+      };
+
+      mockRngClientCore.getBatchFloats.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getBatchFloats(5);
+
+      expect(mockRngClientCore.getBatchFloats).toHaveBeenCalledWith({
+        count: 5,
+        seed: undefined,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getRandomNumber', () => {
+    it('should call clientCore.getRandomNumber with correct parameters', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getRandomNumber.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getRandomNumber(1, 100, 12345);
+
+      expect(mockRngClientCore.getRandomNumber).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getRandomFloat', () => {
+    it('should call clientCore.getRandomFloat with correct parameters', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getRandomFloat.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getRandomFloat(12345);
+
+      expect(mockRngClientCore.getRandomFloat).toHaveBeenCalledWith({
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+});

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

@@ -0,0 +1,296 @@
+import { RngClient } from '../rng-client';
+import { RngClientConfig } from '../interfaces/client-interfaces';
+
+// Mock the RngClientCore
+jest.mock('../core/rng-client-core', () => ({
+  RngClientCore: jest.fn().mockImplementation(() => ({
+    getRandomNumber: jest.fn(),
+    getRandomFloat: jest.fn(),
+    getSingleNumber: jest.fn(),
+    getBatchNumbers: jest.fn(),
+    getSingleFloat: jest.fn(),
+    getBatchFloats: jest.fn(),
+    getBatchNumbersWithSeeds: jest.fn(),
+    getBatchFloatWithSeeds: jest.fn(),
+  })),
+}));
+
+// Mock the RingBuffer
+jest.mock('../ring-buffer/ring-buffer', () => ({
+  RingBuffer: jest.fn().mockImplementation(() => ({
+    getNumbersByRange: jest.fn().mockResolvedValue(null),
+    getStats: jest.fn().mockResolvedValue(undefined),
+  })),
+}));
+
+// Mock the RingStorage
+jest.mock('../ring-buffer/ring-storage', () => ({
+  StorageType: {
+    IN_MEMORY: 'in_memory',
+    REDIS: 'redis',
+  },
+}));
+
+describe('RngClient', () => {
+  let rngClient: RngClient;
+  let mockRngClientCore: any;
+
+  const mockConfig: RngClientConfig = {
+    serverUrl: 'http://localhost:3001',
+    grpcUrl: 'localhost:50051',
+    clientMethod: 'rest',
+  };
+
+  beforeEach(() => {
+    const { RngClientCore } = require('../core/rng-client-core');
+    mockRngClientCore = {
+      getRandomNumber: jest.fn(),
+      getRandomFloat: jest.fn(),
+      getSingleNumber: jest.fn(),
+      getBatchNumbers: jest.fn(),
+      getSingleFloat: jest.fn(),
+      getBatchFloats: jest.fn(),
+      getBatchNumbersWithSeeds: jest.fn(),
+      getBatchFloatWithSeeds: jest.fn(),
+    };
+    RngClientCore.mockImplementation(() => mockRngClientCore);
+
+    rngClient = new RngClient(mockConfig);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getSingleNumber', () => {
+    it('should call clientCore.getSingleNumber with correct parameters', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getSingleNumber.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getSingleNumber(1, 100, 12345);
+
+      expect(mockRngClientCore.getSingleNumber).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+      expect(result).toEqual({
+        value: mockResponse.result,
+        seed: mockResponse.seed,
+      });
+    });
+
+    it('should call clientCore.getSingleNumber without seed', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getSingleNumber.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getSingleNumber(1, 100);
+
+      expect(mockRngClientCore.getSingleNumber).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        seed: undefined,
+      });
+      expect(result).toEqual({
+        value: mockResponse.result,
+        seed: mockResponse.seed,
+      });
+    });
+  });
+
+  describe('getBatchNumbers', () => {
+    it('should call clientCore.getBatchNumbers 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',
+      };
+
+      mockRngClientCore.getBatchNumbers.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getBatchNumbers(1, 100, 5, 12345);
+
+      expect(mockRngClientCore.getBatchNumbers).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        count: 5,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse.result);
+    });
+
+    it('should call clientCore.getBatchNumbers without seed', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: [1, 2, 3, 4, 5],
+        min: 1,
+        max: 100,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getBatchNumbers.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getBatchNumbers(1, 100, 5);
+
+      expect(mockRngClientCore.getBatchNumbers).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        count: 5,
+        seed: undefined,
+      });
+      expect(result).toEqual(mockResponse.result);
+    });
+  });
+
+  describe('getSingleFloat', () => {
+    it('should call clientCore.getSingleFloat with correct parameters', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getSingleFloat.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getSingleFloat(12345);
+
+      expect(mockRngClientCore.getSingleFloat).toHaveBeenCalledWith({
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should call clientCore.getSingleFloat without seed', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getSingleFloat.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getSingleFloat();
+
+      expect(mockRngClientCore.getSingleFloat).toHaveBeenCalledWith({
+        seed: undefined,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getBatchFloats', () => {
+    it('should call clientCore.getBatchFloats 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',
+      };
+
+      mockRngClientCore.getBatchFloats.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getBatchFloats(5, 12345);
+
+      expect(mockRngClientCore.getBatchFloats).toHaveBeenCalledWith({
+        count: 5,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should call clientCore.getBatchFloats without seed', 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',
+      };
+
+      mockRngClientCore.getBatchFloats.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getBatchFloats(5);
+
+      expect(mockRngClientCore.getBatchFloats).toHaveBeenCalledWith({
+        count: 5,
+        seed: undefined,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getRandomNumber', () => {
+    it('should call clientCore.getRandomNumber with correct parameters', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 42,
+        min: 1,
+        max: 100,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getRandomNumber.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getRandomNumber(1, 100, 12345);
+
+      expect(mockRngClientCore.getRandomNumber).toHaveBeenCalledWith({
+        min: 1,
+        max: 100,
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getRandomFloat', () => {
+    it('should call clientCore.getRandomFloat with correct parameters', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        seed: 12345,
+        result: 0.75,
+        min: 0,
+        max: 1,
+        createdAt: '2023-01-01T00:00:00Z',
+      };
+
+      mockRngClientCore.getRandomFloat.mockResolvedValue(mockResponse);
+
+      const result = await rngClient.getRandomFloat(12345);
+
+      expect(mockRngClientCore.getRandomFloat).toHaveBeenCalledWith({
+        seed: 12345,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+});

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

@@ -0,0 +1,80 @@
+import { RngClientConfig } from "../interfaces/client-interfaces";
+import { RngClientInterface } from "../http/rng-client.interface";
+import { HttpRngClient } from "../http/http-rng-client";
+import { GrpcRngClient } from "../grpc/grpc-rng-client";
+import {
+  RngBatchFloatRequest,
+  RngBatchRequest,
+  RngBatchResponse,
+  RngBatchResponseWithSeeds,
+  RngSingleFloatRequest,
+  RngSingleRequest,
+  RngSingleResponse,
+} from "../http/http-client.types";
+
+export class RngClientCore {
+  private readonly config: RngClientConfig;
+  private readonly rngClient: RngClientInterface;
+
+  constructor(config: RngClientConfig) {
+    this.config = config;
+
+    if (config.clientMethod === "grpc") {
+      this.rngClient = new GrpcRngClient(config.grpcUrl);
+    } else {
+      this.rngClient = new HttpRngClient(config.serverUrl);
+    }
+  }
+
+  public async getRandomNumber(
+    request: RngSingleRequest
+  ): Promise<RngSingleResponse> {
+    return this.rngClient.getSingleNumber(request);
+  }
+
+  public async getSingleNumber(
+    request: RngSingleRequest
+  ): Promise<RngSingleResponse> {
+    return this.rngClient.getSingleNumber(request);
+  }
+
+  public async getRandomFloat(
+    request: RngSingleFloatRequest
+  ): Promise<RngSingleResponse> {
+    const response = await this.rngClient.getSingleFloat(request);
+
+    return response;
+  }
+
+  public async getSingleFloat(
+    request: RngSingleFloatRequest
+  ): Promise<RngSingleResponse> {
+    const response = await this.rngClient.getSingleFloat(request);
+
+    return response;
+  }
+
+  public async getBatchFloats(
+    request: RngBatchFloatRequest
+  ): Promise<RngBatchResponse> {
+    return this.rngClient.getBatchFloats(request);
+  }
+
+  public async getBatchNumbers(
+    data: RngBatchRequest
+  ): Promise<RngBatchResponse> {
+    return this.rngClient.getBatchNumbers(data);
+  }
+
+  public async getBatchNumbersWithSeeds(
+    request: RngBatchRequest
+  ): Promise<RngBatchResponseWithSeeds> {
+    return this.rngClient.getBatchNumbersWithSeeds(request);
+  }
+
+  public async getBatchFloatWithSeeds(
+    request: RngSingleFloatRequest
+  ): Promise<RngBatchResponseWithSeeds> {
+    return this.rngClient.getBatchFloatWithSeeds(request);
+  }
+}