@n1k1t/mock-server 0.1.61 → 0.1.62

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

@@ -1,50 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

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

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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

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

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

@@ -1,42 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

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