@n1k1t/mock-server 0.1.60 → 0.1.61

package/src/server/models/router.spec.ts

@@ -0,0 +1,50 @@
+import { Router } from './router';
+
+// Test generated using Keploy
+test('should set default transports when no transports are provided', () => {
+  const mockServer = {
+    providers: {
+      register: jest.fn(),
+      default: {} // mocked default provider
+    },
+    transports: new Map([['default', {}]]) // mocked transports
+  };
+
+  const router = new Router(<any>mockServer);
+  const pattern = 'route-pattern';
+  const configuration = { provider: {} }; // mocked provider
+
+  const result = router.register(pattern, <any>configuration);
+
+  expect(mockServer.providers.register).toHaveBeenCalledWith(configuration.provider);
+  expect(result.get(pattern)).toEqual({
+    provider: configuration.provider,
+    transports: { default: {} } // default transport set
+  });
+});
+
+// Test generated using Keploy
+test('match should yield default provider and transport for non-matching pattern', () => {
+  const mockServer = {
+    providers: {
+      register: jest.fn(),
+      default: {} // mocked default provider
+    },
+    transports: new Map([['transport2', {}]]) // mocked transports
+  };
+  const router = new Router(<any>mockServer);
+  const pattern = 'route/*';
+  const configuration = {
+    provider: {},
+    transports: ['transport1']
+  };
+  router.register(pattern, <any>configuration);
+
+  const result = Array.from(router.match('transport2', 'random/path'));
+  expect(result).toHaveLength(1);
+  expect(result[0]).toEqual({
+    provider: mockServer.providers.default,
+    transport: {}
+  });
+});
+

package/src/server/models/router.ts

@@ -0,0 +1,79 @@
+import minimatch from 'minimatch';
+import _ from 'lodash';
+
+import type { MockServer, TDefaultServerContext } from '../index';
+import type { IServerContext } from '../types';
+import type { Transport } from './transports';
+import type { Provider } from './providers';
+
+export interface IRouteContext<TTransportType extends string> {
+  transports: Partial<Record<TTransportType, Transport>>;
+  provider: Provider<any>;
+}
+
+export interface IRouteMatchResult<
+  K extends string,
+  T extends Transport = Transport
+> extends Pick<IRouteContext<K>, 'provider'> {
+  transport: T;
+}
+
+export class Router<TContext extends IServerContext<any>> extends Map<string, IRouteContext<TContext['transport']>> {
+  constructor(private server: MockServer) {
+    super();
+  }
+
+  public register(
+    pattern: string,
+    configuration: {
+      provider: Provider<any>;
+      transports?: TContext['transport'][] | Partial<Record<TContext['transport'], Transport>>;
+    }
+  ): this {
+    this.server.providers.register(configuration.provider);
+
+    const types = Array.isArray(configuration.transports)
+      ? configuration.transports
+      : configuration.transports
+        ? <TContext['transport'][]>Object.keys(configuration.transports)
+        : [...this.server.transports.keys()];
+
+    return this.set(pattern, {
+      provider: configuration.provider,
+
+      transports: types.reduce<IRouteContext<TContext['transport']>['transports']>(
+        (acc, type) => _.set(
+          acc,
+          type,
+          Array.isArray(configuration.transports)
+            ? this.server.transports.get(type)
+            : configuration.transports?.[type] ?? this.server.transports.get(type)
+        ),
+        {}
+      ),
+    });
+  }
+
+  public *match<T extends Transport>(
+    transport: TContext['transport'],
+    path: string
+  ): Generator<IRouteMatchResult<TContext['transport'], T>> {
+    for (const [pattern, route] of this.entries()) {
+      if (minimatch(path, pattern)) {
+        yield {
+          provider: route.provider,
+          transport: <T>route.transports[transport],
+        };
+      }
+    }
+
+    yield {
+      provider: this.server.providers.default,
+      transport: <T>this.server.transports.get(transport),
+    };
+  }
+
+  static build<TContext extends IServerContext<any> = TDefaultServerContext>(server: MockServer): Router<TContext> {
+    return new Router<TContext>(server);
+  }
+}

package/src/server/models/service.ts

@@ -0,0 +1,5 @@
+import type { MockServer } from '../index';
+
+export abstract class Service {
+  constructor(protected server: MockServer<any, any>) {}
+}

package/src/server/models/transports/index.ts

@@ -0,0 +1,2 @@
+export * from './storage';
+export * from './model';

package/src/server/models/transports/model.ts

@@ -0,0 +1,9 @@
+import type { Executor } from '../executor';
+import type { Provider } from '../providers';
+
+export abstract class Transport<TExecutor extends Executor = Executor> {
+  public TContext!: TExecutor['TContext'];
+
+  public abstract executor: TExecutor;
+  public abstract compileContext(provider: Provider<any>, ...args: unknown[]): Promise<TExecutor['TRequestContext']>;
+}

package/src/server/models/transports/storage.spec.ts

@@ -0,0 +1,14 @@
+import { TransportsStorage } from './storage';
+import { Transport } from './model';
+
+// Test generated using Keploy
+it('should store the transport and return the instance', () => {
+  const storage = new TransportsStorage();
+  const transportType = 'http';
+  const transport = <Transport><unknown>{ id: 'transport1' }; // Assume Transport has an id field
+
+  const result = storage.register(transportType, transport);
+
+  expect(storage.get(transportType)).toBe(transport);
+  expect(result).toBe(storage);
+});

package/src/server/models/transports/storage.ts

@@ -0,0 +1,13 @@
+import type { IServerContext } from '../../types';
+import type { Transport } from './model';
+
+import { Logger } from '../../../logger';
+
+const logger = Logger.build('Server.Models.TransportsStorage');
+
+export class TransportsStorage<TContext extends IServerContext<any>> extends Map<TContext['transport'], Transport> {
+  public register(type: TContext['transport'], transport: Transport): this {
+    logger.info(`Transport [${type}] has registered`);
+    return this.set(type, transport);
+  }
+}

package/src/server/services/analytics.service.spec.ts

@@ -0,0 +1,38 @@
+import { AnalyticsService } from './analytics.service';
+
+// Test generated using Keploy
+test("calculateRedisUsage_noRedisConfig_returnsZeroUsage", async () => {
+  const mockServer = { databases: { redis: null } };
+  const analyticsService = new AnalyticsService(<any>mockServer);
+
+  const result = await analyticsService.calculateRedisUsage();
+
+  expect(result).toEqual({ count: 0, bytes: 0 });
+});
+
+// Test generated using Keploy
+test("calculateRedisUsage_errorDuringScan_rejectsWithError", async () => {
+  const mockStream = {
+    once: jest.fn((event, handler) => {
+      if (event === 'error') handler(new Error('Scan Error'));
+    }),
+    on: jest.fn(),
+    pause: jest.fn(),
+    resume: jest.fn(),
+    close: jest.fn(),
+  };
+  const mockServer = {
+    databases: {
+      redis: {
+        scanStream: jest.fn(() => mockStream),
+        options: { keyPrefix: '' }
+      }
+    }
+  };
+  const analyticsService = new AnalyticsService(<any>mockServer);
+
+  await expect(analyticsService.calculateRedisUsage()).rejects.toThrow('Scan Error');
+  expect(mockStream.close).toHaveBeenCalled();
+});
+
+

package/src/server/services/analytics.service.ts

@@ -0,0 +1,58 @@
+import _ from 'lodash';
+
+import { Service } from '../models';
+import { Logger } from '../../logger';
+
+export interface IRedisUsage {
+  count: number;
+  bytes: number;
+}
+
+const logger = Logger.build('Services.Analytics');
+
+export class AnalyticsService extends Service {
+  public async calculateRedisUsage(prefix?: string): Promise<IRedisUsage> {
+    if (!this.server.databases.redis) {
+      return { count: 0, bytes: 0 };
+    }
+
+    return new Promise<IRedisUsage>((resolve, reject) => {
+      const match = `${this.server.databases.redis!.options.keyPrefix ?? ''}${prefix ?? ''}*`;
+      const stream = this.server.databases.redis!.scanStream({ match });
+
+      const result: IRedisUsage = { count: 0, bytes: 0 };
+
+      stream.once('end', () => resolve(result));
+      stream.once('error', (error) => {
+        logger.error('Got error while scan execution', error?.stack ?? error);
+        stream.close();
+
+        reject(error);
+      });
+
+      stream.on('data', async (keys: string[]) => {
+        stream.pause();
+
+        result.count += keys.length;
+
+        const usage = await Promise
+          .all(keys.map(async (key) => this.server.databases.redis!.call('MEMORY', 'USAGE', key)))
+          .catch((error) => {
+            logger.error('Got error while fetching memory usage', error?.stack ?? error);
+            stream.close();
+
+            reject(error);
+            return [];
+          });
+
+        usage.forEach((bytes) => result.bytes += Number(bytes));
+
+        stream.resume();
+      });
+    });
+  }
+
+  static build(server: Service['server']) {
+    return new AnalyticsService(server);
+  }
+}

package/src/server/services/index.ts

@@ -0,0 +1,2 @@
+export * from './analytics.service';
+export * from './metrics.service';

package/src/server/services/metrics.service.spec.ts

@@ -0,0 +1,42 @@
+import { MetricsService } from './metrics.service';
+import { Service } from '../models';
+
+// Test generated using Keploy
+class MockService {
+  exchanges = { io: { publish: jest.fn() }};
+}
+
+test('should register a valid containers metric point and maintain correct limit', () => {
+  const mockServer = new MockService();
+  const service = new MetricsService(<any>mockServer, { limit: 2 });
+
+  service.register('containers', { count: 1 });
+  service.register('containers', { count: 2 });
+  service.register('containers', { count: 3 });
+
+  expect(service.points.containers.length).toBe(2); // Should only keep the last 2 entries
+  expect(service.points.containers[0].values.count).toBe(2);
+  expect(service.points.containers[1].values.count).toBe(3);
+  expect(mockServer.exchanges.io.publish).toHaveBeenCalledTimes(3);
+  expect(mockServer.exchanges.io.publish).toHaveBeenCalledWith('metric:registered', expect.objectContaining({ name: 'containers' }));
+});
+
+// Test generated using Keploy
+test('should throw an error for invalid metric name', () => {
+  const mockServer = new MockService();
+  const service = new MetricsService(<any>mockServer);
+
+  expect(() => service.register<any>('invalidName', { count: 1 })).toThrow('Invalid metric name');
+});
+
+
+// Test generated using Keploy
+test('build method should initialize MetricsService correctly', () => {
+  const mockServer = new MockService();
+  const service = MetricsService.build(<any>mockServer, { limit: 5 });
+
+  expect(service).toBeInstanceOf(MetricsService);
+  expect(service['options']?.limit).toBe(5);
+});
+
+

package/src/server/services/metrics.service.ts

@@ -0,0 +1,46 @@
+import _ from 'lodash';
+
+import { Service } from '../models';
+import { cast } from '../../utils';
+
+export type TMetricPoint<K extends string = string> = {
+  timestamp: number;
+  values: Record<K, number>;
+}
+
+export class MetricsService extends Service {
+  private limit = this.options?.limit ?? 300;
+
+  public points = {
+    containers: cast<TMetricPoint<'count'>[]>([]),
+    memory: cast<TMetricPoint<'mbs'>[]>([]),
+    cache: cast<TMetricPoint<'redis_mbs' | 'redis_count'>[]>([]),
+    rate: cast<TMetricPoint<'count'>[]>([]),
+  };
+
+  constructor(server: Service['server'], private options?: { limit?: number }) {
+    super(server);
+  }
+
+  public register<K extends keyof MetricsService['points']>(
+    name: K,
+    values: MetricsService['points'][K][0]['values'],
+  ): this {
+    if (!this.points[name]) {
+      throw new Error('Invalid metric name');
+    }
+
+    const group: TMetricPoint[] = this.points[name];
+    const point: TMetricPoint = { timestamp: Date.now(), values };
+
+    group.push(point);
+    group.splice(0, _.clamp(group.length - this.limit, 0, Infinity));
+
+    this.server.exchanges.io.publish('metric:registered', { name, point });
+    return this;
+  }
+
+  static build(server: Service['server'], options?: MetricsService['options']) {
+    return new MetricsService(server, options);
+  }
+}

package/src/server/transports/http.transport/context.ts

@@ -0,0 +1,72 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import _ from 'lodash';
+
+import { IServerContext } from '../../types';
+import { metaStorage } from '../../../meta';
+import { Logger } from '../../../logger';
+import {
+  extractHttpIncommingContext,
+  IRequestContextIncoming,
+  Provider,
+  RequestContext,
+  RequestContextSnapshot,
+} from '../../models';
+
+const logger = Logger.build('Server.Transports.Http.Context');
+
+export class HttpRequestContext extends RequestContext<IServerContext<{
+  transport: 'http';
+  event: 'connection';
+}>> {
+  public snapshot = this.compileSnapshot();
+  public history = this.compileHistory();
+
+  public meta = metaStorage.generate({
+    ...(this.incoming.headers['x-request-id'] && { requestId: String(this.incoming.headers['x-request-id']) }),
+  });
+
+  constructor(
+    public provider: Provider,
+    public incoming: IRequestContextIncoming,
+    public request: IncomingMessage,
+    public response: ServerResponse
+  ) {
+    super(provider, { transport: 'http', event: 'connection' });
+  }
+
+  public handle(): this {
+    logger.info('Incoming HTTP request', `[${this.incoming.method} ${this.incoming.path}]`);
+    return super.handle();
+  }
+
+  public complete(): this {
+    logger.info(
+      `Incoming HTTP request [${this.incoming.method} ${this.incoming.path}] has finished`,
+      `with status [${this.outgoing?.status ?? 200}] in [${Date.now() - this.timestamp}ms]`
+    );
+
+    return super.complete();
+  }
+
+  public compileSnapshot(): RequestContextSnapshot {
+    const snapshot = super.compileSnapshot();
+
+    snapshot.outgoing.status = 200;
+    snapshot.incoming.headers = _.omit(snapshot.incoming.headers, ['transfer-encoding']);
+
+    return snapshot.assign({
+      ...(this.incoming.headers['x-use-mock-seed'] && {
+        seed: Number(this.incoming.headers['x-use-mock-seed']),
+      }),
+
+      ...(this.incoming.headers['x-use-mock-state'] && {
+        state: JSON.parse(Buffer.from(String(this.incoming.headers['x-use-mock-state']), 'base64').toString()),
+      }),
+    });
+  };
+
+  static async build(provider: Provider, request: IncomingMessage, response: ServerResponse) {
+    const incoming = await extractHttpIncommingContext(request);
+    return new HttpRequestContext(provider, incoming, request, response);
+  }
+}

package/src/server/transports/http.transport/executor.ts

@@ -0,0 +1,156 @@
+import axios, { AxiosError, AxiosRequestConfig } from 'axios';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import _ from 'lodash';
+
+import type { Expectation, IExpectationSchemaForward } from '../../../expectations';
+import type { HttpRequestContext } from './context';
+
+import { Logger } from '../../../logger';
+import {
+  extractPayloadType,
+  parsePayload,
+  Executor,
+  ExecutorManualError,
+  IRequestContextOutgoing,
+  IRequestContextIncoming,
+  IExecutorExecOptions,
+} from '../../models';
+
+const logger = Logger.build('Server.Transports.Http.Executor');
+
+export class HttpExecutor extends Executor<HttpRequestContext> {
+  public async exec(context: HttpRequestContext, options?: IExecutorExecOptions) {
+    await super.exec(context, options).catch((error) => {
+      if (error instanceof ExecutorManualError) {
+        return null;
+      }
+
+      logger.error('Got unexpected error while execution', error?.stack ?? error);
+    });
+
+    return context.complete();
+  }
+
+  public async match(context: HttpRequestContext): Promise<Expectation<any> | null> {
+    const expectation = context.provider.storages.expectations.match(context.snapshot);
+
+    if (!expectation && context.hasStatuses(['handling'])) {
+      context.assign({
+        outgoing: await this.reply(context, {
+          type: 'plain',
+          status: 404,
+
+          dataRaw: Buffer.from('Expectation was not found'),
+          headers: {},
+        }),
+      });
+
+      return null;
+    }
+
+    return expectation;
+  }
+
+  public async forward(
+    context: HttpRequestContext,
+    incoming: IRequestContextIncoming,
+    configuration: IExpectationSchemaForward
+  ) {
+    const options = await this
+      .compileForwardingConfiguration(context, incoming, configuration)
+      .catch((error) => {
+        context.snapshot.assign({
+          error: { code: 'UNKNOWN', message: error?.message ?? 'Unknown' },
+          outgoing: { type: 'plain', status: 502, headers: {} },
+        });
+
+        logger.error('Got error while execution [compileForwardingConfiguration] method', error?.stack ?? error);
+        throw error;
+      });
+
+    const response = await axios
+      .request<Buffer>(options)
+      .catch((error: AxiosError<Buffer>) => {
+        if (!error.response) {
+          context.snapshot.assign({
+            error: _.pick(error, ['message', 'code']),
+            outgoing: { type: 'plain', status: 502, headers: {} },
+          });
+
+          logger.error('Got error while forwaring', error?.stack ?? error);
+          throw error;
+        }
+
+        return error.response;
+      });
+
+    const type = extractPayloadType(response.headers) ?? 'plain';
+    const data = parsePayload(type, response.data);
+
+    return {
+      incoming,
+      outgoing: {
+        type: type,
+
+        status: response.status,
+        headers: response.headers,
+
+        data,
+        dataRaw: response.data,
+      },
+    };
+  }
+
+  public async reply(context: HttpRequestContext, outgoing: IRequestContextOutgoing) {
+    outgoing.headers = _.omitBy(
+      Object.assign(_.omit(outgoing.headers, ['transfer-encoding']), {
+        'content-type': outgoing.headers['content-type'] ?? (
+          outgoing.type === 'json' ? 'application/json' : outgoing.type === 'xml' ? 'application/xml' : undefined
+        ),
+
+        ...(outgoing.dataRaw && { 'content-length': String(outgoing.dataRaw.length) }),
+      }),
+      _.isNil
+    );
+
+    context.response.writeHead(outgoing.status, outgoing.headers);
+    context.response.write(outgoing.dataRaw ?? '');
+    context.response.end();
+
+    return outgoing;
+  }
+
+  /** Compiles Axios request configuration to forward */
+  protected async compileForwardingConfiguration(
+    context: HttpRequestContext,
+    incoming: IRequestContextIncoming,
+    configuration: IExpectationSchemaForward
+  ): Promise<AxiosRequestConfig> {
+    const url = new URL(configuration.url ?? incoming.path, configuration.baseUrl);
+    const isSecured = url.protocol.includes('https');
+
+    return {
+      timeout: configuration.timeout ?? 30000,
+
+      method: incoming.method,
+      headers: Object.assign(incoming.headers, {
+        connection: 'close',
+
+        ...(configuration.options?.overrideHost !== false && { host: url.host }),
+        ...(incoming.dataRaw && { 'content-length': String(incoming.dataRaw.length) }),
+      }),
+
+      ...(configuration.url && { url: configuration.url }),
+      ...(configuration.baseUrl && { baseURL: configuration.baseUrl, url: incoming.path }),
+
+      data: incoming.dataRaw,
+      params: context.incoming.query,
+      responseType: 'arraybuffer',
+
+      ...((configuration.proxy && !isSecured) && { proxy: configuration.proxy }),
+      ...((configuration.proxy && isSecured) && {
+        httpsAgent: new HttpsProxyAgent(`http://${configuration.proxy.host}:${configuration.proxy.port}`),
+      }),
+    };
+  }
+}

package/src/server/transports/http.transport/index.ts

@@ -0,0 +1,53 @@
+import { IncomingMessage, ServerResponse } from 'http';
+
+import { Provider, Router, Transport } from '../../models';
+import { HttpRequestContext } from './context';
+import { HttpExecutor } from './executor';
+import { metaStorage } from '../../../meta';
+import { Logger } from '../../../logger';
+
+export * from './executor';
+export * from './context';
+
+const logger = Logger.build('Server.Transports.Http');
+
+export const buildHttpListener = (router: Router<HttpRequestContext['TContext']>) =>
+  async (request: IncomingMessage, response: ServerResponse) => {
+    for (const { provider, transport } of router.match<HttpTransport>('http', request.url ?? '')) {
+      const context = await transport
+        .compileContext(provider, request, response)
+        .catch((error) => logger.error('Got error while context compilation', error?.stack ?? error));
+
+      if (!context) {
+        return response.destroy();
+      }
+      if (!context.hasStatuses(['registered', 'handling'])) {
+        break;
+      }
+
+      const expectation = await metaStorage
+        .wrap(context.meta, () => transport.executor.match(context))
+        .catch((error) => logger.error('Got error while expectation matching', error?.stack ?? error));
+
+      if (!context.hasStatuses(['registered', 'handling'])) {
+        break;
+      }
+      if (!expectation) {
+        continue;
+      }
+
+      await metaStorage
+        .wrap(context.meta, () => transport.executor.exec(context.handle(), { expectation }))
+        .catch((error) => logger.error('Got error while execution', error?.stack ?? error));
+
+      break;
+    }
+  }
+
+export class HttpTransport extends Transport<HttpExecutor> {
+  public executor = new HttpExecutor();
+
+  public compileContext(provider: Provider, request: IncomingMessage, response: ServerResponse) {
+    return HttpRequestContext.build(provider, request, response);
+  }
+}

package/src/server/transports/index.ts

@@ -0,0 +1,3 @@
+export * from './http.transport';
+export * from './ws.transport';
+export * from './internal';