@n1k1t/mock-server 0.1.61 → 0.1.62

package/src/server/models/context/utils.ts

@@ -1,99 +0,0 @@
-import { IncomingMessage, ServerResponse } from 'http';
-import { parse as parseQueryString } from 'querystring';
-import { XMLBuilder, XMLParser } from 'fast-xml-parser';
-import { parse as parseUrl } from 'url';
-import bodyParser from 'body-parser';
-import _ from 'lodash';
-
-import { IRequestContextIncoming } from './types';
-import { TRequestPayloadType } from '../../types';
-import { parseJsonSafe } from '../../../utils';
-
-const xmlParser = new XMLParser({
-  ignoreAttributes: false,
-});
-
-const xmlBuilder = new XMLBuilder({
-  ignoreAttributes: false,
-});
-
-const parseQuerySearch = (queryString: string): Record<string, unknown> =>
-  Object.entries(parseQueryString(queryString)).reduce((acc, [key, value]) => {
-    const valueAsJson = _.flatten([value]).map(arrValue => {
-      const parsingArrayValueAsJsonResult = parseJsonSafe(arrValue ?? '');
-      return parsingArrayValueAsJsonResult.status === 'OK' ? parsingArrayValueAsJsonResult.result : arrValue;
-    });
-
-    return _.set(acc, key, valueAsJson?.length === 1 ? valueAsJson[0] : valueAsJson);
-  }, {});
-
-
-export const extractPayloadType = (headers: IncomingMessage['headers']): TRequestPayloadType | null => {
-  const contentTypeKey = Object.keys(headers).find((key) => key.toLowerCase() === 'content-type');
-  const contextType = _.flatten([_.get(headers, contentTypeKey ?? '', '')]).join(',').toLowerCase();
-
-  if (contextType.includes('application/json')) {
-    return 'json'
-  }
-  if (contextType.includes('/xml')) {
-    return 'xml'
-  }
-
-  return null;
-}
-
-export const parsePayload = (type: TRequestPayloadType, payload: Buffer): object | undefined => {
-  if (type === 'json') {
-    const parsed = parseJsonSafe(payload.toString());
-    return parsed.status === 'OK' ? parsed.result : undefined;
-  }
-  if (type === 'xml') {
-    return xmlParser.parse(payload) ?? undefined;
-  }
-
-  return undefined;
-}
-
-export const serializePayload = (type: TRequestPayloadType, payload: object | null): Buffer | undefined => {
-  if (type === 'json') {
-    return Buffer.from(JSON.stringify(payload));
-  }
-  if (type === 'xml') {
-    return Buffer.from(xmlBuilder.build(payload ?? {}));
-  }
-
-  return undefined;
-}
-
-export const extractHttpIncommingContext = async (request: IncomingMessage): Promise<IRequestContextIncoming> => {
-  const { pathname, query: rawQuery } = parseUrl(request.url ?? '');
-
-  const type = extractPayloadType(request.headers) ?? 'plain';
-  const query = parseQuerySearch(rawQuery ?? '');
-
-  const headers = Object
-    .entries(request.headers)
-    .map(([name, values]) => [name.toLowerCase(), _.flatten([values]).map((value) => String(value)).sort().join(',')])
-    .reduce((acc, [name, value]) => _.set(acc, name, value), {});
-
-  const dataRaw = await new Promise<Buffer | null>((resolve, reject) =>
-    bodyParser.raw({ limit: '10mb', type: '*/*' })(request, new ServerResponse(request), (error) =>
-      error
-        ? reject(error)
-        : resolve(Buffer.isBuffer(_.get(request, 'body')) ? _.get(request, 'body') : null)
-    )
-  );
-
-  return {
-    type,
-
-    method: String(request.method ?? 'GET').toUpperCase(),
-    path: pathname ?? '/',
-
-    headers,
-    query,
-
-    data: dataRaw ? parsePayload(type, dataRaw) : undefined,
-    dataRaw: dataRaw ?? undefined,
-  };
-}

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

@@ -1,28 +0,0 @@
-import { Endpoint } from './endpoint';
-
-// Test generated using Keploy
-it('should assign HTTP configuration correctly', () => {
-  const endpoint = Endpoint.build();
-  const httpConfig = { method: 'GET', path: '/test' };
-  const result = endpoint.bindToHttp(httpConfig);
-  expect(result.http).toEqual(httpConfig);
-  expect(result).toBe(endpoint);
-});
-
-// Test generated using Keploy
-it('should assign IO configuration correctly', () => {
-  const endpoint = Endpoint.build();
-  const ioConfig = { path: '/test/socket' };
-  const result = endpoint.bindToIo(ioConfig);
-  expect(result.io).toEqual(ioConfig);
-  expect(result).toBe(endpoint);
-});
-
-// Test generated using Keploy
-it('should assign handler correctly', () => {
-  const endpoint = Endpoint.build();
-  const handler = jest.fn();
-  const result = endpoint.assignHandler(handler);
-  expect(result.handler).toBe(handler);
-  expect(result).toBe(endpoint);
-});

package/src/server/models/endpoint.ts

@@ -1,69 +0,0 @@
-import type { InternalHttpRequestContext, InternalSocketIoRequestContext } from '../transports';
-import type { SetRequiredKeys, TFunction } from '../../../types';
-
-export interface IEndpointResponse<T> {
-  code: 'OK' | 'INTERNAL_ERROR' | 'VALIDATION_ERROR' | 'NOT_FOUND';
-  timestamp: number;
-
-  data: T;
-}
-
-export interface IEndpointInput {
-  incoming?: {
-    query?: any;
-    data?: any;
-  };
-
-  outgoing?: any;
-}
-
-export interface IEndpointSchema<TInput extends IEndpointInput> {
-  incoming: {
-    data?: NonNullable<TInput['incoming']>['data'];
-    query?: NonNullable<TInput['incoming']>['query'];
-  };
-
-  outgoing: IEndpointResponse<TInput['outgoing']>;
-}
-
-export class Endpoint<
-  TInput extends IEndpointInput = {},
-  TSchema extends IEndpointSchema<TInput> = IEndpointSchema<TInput>
-> {
-  public TSchema!: TSchema;
-  public TCompiled!: SetRequiredKeys<Endpoint<TInput, TSchema>, 'handler'>;
-
-  public handler?: TFunction<any, [
-    (InternalHttpRequestContext<TSchema['outgoing']['data']> | InternalSocketIoRequestContext<TSchema['outgoing']['data']>) & {
-      incoming: TSchema['incoming'];
-    }
-  ]>;
-
-  public http?: {
-    method: string;
-    path: string;
-  };
-
-  public io?: {
-    path: string;
-  };
-
-  public bindToHttp<This extends NonNullable<Endpoint<TInput, TSchema>['http']>>(http: This) {
-    return Object.assign(this, { http });
-  }
-
-  public bindToIo<Q extends NonNullable<Endpoint<TInput, TSchema>['io']>>(io: Q) {
-    return Object.assign(this, { io });
-  }
-
-  public assignHandler<Q extends NonNullable<Endpoint<TInput, TSchema>['handler']>>(handler: Q) {
-    return Object.assign(this, { handler });
-  }
-
-  static build<
-    TInput extends IEndpointInput = {},
-    TSchema extends IEndpointSchema<TInput> = IEndpointSchema<TInput>
-  >(): Endpoint<TInput, TSchema> {
-    return new Endpoint<TInput, TSchema>();
-  }
-}

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

@@ -1 +0,0 @@
-export * from './socket-io';

package/src/server/models/exchanges/socket-io.spec.ts

@@ -1,13 +0,0 @@
-import { buildSocketIoExchange } from './socket-io';
-
-// Test generated using Keploy
-test('should emit the correct event with payload', () => {
-  const mockEmit = jest.fn();
-  const io = { emit: mockEmit };
-  const exchangeService = buildSocketIoExchange<any>(io);
-
-  exchangeService.publish('testEvent', { key: 'value' });
-
-  expect(mockEmit).toHaveBeenCalledWith('testEvent', { key: 'value' });
-});
-

package/src/server/models/exchanges/socket-io.ts

@@ -1,14 +0,0 @@
-import type { Server } from 'socket.io';
-
-export interface ISocketIoExchangeService<TSchema extends object> {
-  publish: <K extends keyof TSchema & string>(
-    channel: K,
-    payload: TSchema[K]
-  ) => unknown;
-}
-
-export const buildSocketIoExchange = <TSchema extends object>(
-  io: Pick<Server, 'emit'>
-): ISocketIoExchangeService<TSchema> => ({
-  publish: (eventName: string, ...payload: unknown[]) => io.emit(eventName, ...payload),
-});

package/src/server/models/executor/errors/index.spec.ts

@@ -1,23 +0,0 @@
-import { ExecutorManualError } from '../errors';
-
-// Test generated using Keploy
-test('should initialize error message with the provided code', () => {
-  const errorCode = 'MANUAL_ERROR';
-  const error = new ExecutorManualError(<any>errorCode);
-  expect(error.message).toBe(`Executor manual error [${errorCode}]`);
-});
-
-// Test generated using Keploy
-test('should return true when the code matches', () => {
-  const errorCode = 'ERROR_CODE';
-  const error = new ExecutorManualError(<any>errorCode);
-  expect(error.is(<any>errorCode)).toBe(true);
-});
-
-// Test generated using Keploy
-test('should create an instance with the correct code', () => {
-  const errorCode = 'BUILD_ERROR';
-  const error = ExecutorManualError.build(<any>errorCode);
-  expect(error instanceof ExecutorManualError).toBe(true);
-  expect(error.code).toBe(errorCode);
-});

package/src/server/models/executor/errors/index.ts

@@ -1,15 +0,0 @@
-import { IRequestContextIncoming } from '../../context';
-
-export class ExecutorManualError extends Error {
-  constructor(public code: Extract<IRequestContextIncoming['error'], string>) {
-    super(`Executor manual error [${code}]`);
-  }
-
-  public is<K extends Extract<IRequestContextIncoming['error'], string>>(code: K): this is this & { code: K } {
-    return this.code === code;
-  }
-
-  static build(code: Extract<IRequestContextIncoming['error'], string>) {
-    return new ExecutorManualError(code);
-  }
-}

package/src/server/models/executor/index.spec.ts

@@ -1,148 +0,0 @@
-import { Executor } from './index';
-
-// Test generated using Keploy
-class TestExecutor extends Executor<any> {
-  forward() {
-    return Promise.resolve(null);
-  }
-
-  reply() {
-    return Promise.resolve(null);
-  }
-}
-
-test('test_exec_noExpectationNoOutgoing_unregistersHistory', async () => {
-  const context = {
-    provider: {
-      storages: {
-        expectations: {
-          match: jest.fn().mockResolvedValue(null),
-        },
-        history: {
-          unregister: jest.fn(),
-        }
-      },
-      server: {
-        exchanges: {
-          io: { publish: jest.fn() }
-        },
-        services: {
-          metrics: { register: jest.fn() }
-        }
-      }
-    },
-    snapshot: {},
-    hasStatuses: jest.fn().mockReturnValue(false)
-  };
-
-  const executor = new TestExecutor();
-  const result = await executor.exec(context);
-
-  expect(result).toBe(context);
-  expect(context.provider.storages.history.unregister).toHaveBeenCalled();
-});
-
-// Test generated using Keploy
-test('test_exec_expectationMatched_updatesContext', async () => {
-  const mockExpectation = <any>{
-    request: {
-      manipulate: jest.fn((snapshot) => Object.assign(snapshot, { manipulated: true })),
-    },
-    increaseExecutionsCounter: jest.fn(() => mockExpectation),
-    toPlain: jest.fn(),
-    name: 'TestExpectation',
-    id: 'exp123',
-  };
-
-  const context = {
-    provider: {
-      storages: {
-        expectations: {
-          match: jest.fn().mockResolvedValue(mockExpectation),
-        },
-        history: {
-          unregister: jest.fn(),
-        }
-      },
-      server: {
-        exchanges: {
-          io: { publish: jest.fn() }
-        },
-        services: {
-          metrics: { register: jest.fn() }
-        }
-      }
-    },
-    assign: jest.fn(),
-    snapshot: {},
-    history: {
-      hasStatus: jest.fn(() => false),
-      switchStatus: jest.fn(),
-    },
-    hasStatuses: jest.fn().mockReturnValue(false)
-  };
-
-  const executor = new TestExecutor();
-  const result = await executor.exec(context);
-
-  expect(result).toBe(context);
-  expect(context.assign).toHaveBeenCalledWith({
-    snapshot: { manipulated: true },
-    expectation: mockExpectation
-  });
-  expect(mockExpectation.increaseExecutionsCounter).toHaveBeenCalled();
-  expect(context.provider.server.exchanges.io.publish)
-    .toHaveBeenCalledWith('expectation:updated', mockExpectation.toPlain());
-});
-
-// Test generated using Keploy
-test('test_exec_withForwardingEnabled_handlingForward', async () => {
-  const mockExpectation = <any>{
-    request: { manipulate: jest.fn((snapshot) => Object.assign(snapshot, { manipulated: true })) },
-    increaseExecutionsCounter: jest.fn(() => mockExpectation),
-    toPlain: jest.fn(),
-    name: 'TestExpectation',
-    id: 'exp123',
-    forward: true,
-  };
-
-  const context = {
-    provider: {
-      storages: {
-        expectations: {
-          match: jest.fn().mockResolvedValue(mockExpectation),
-        },
-        history: {
-          unregister: jest.fn(),
-        }
-      },
-      server: {
-        exchanges: {
-          io: { publish: jest.fn() }
-        },
-        services: {
-          metrics: { register: jest.fn() }
-        }
-      }
-    },
-    assign: jest.fn(),
-    snapshot: { incoming: {}, outgoing: {}, assign: jest.fn(), forwarded: {} },
-    history: {
-      hasStatus: jest.fn(() => false),
-      switchStatus: jest.fn(),
-    },
-    hasStatuses: jest.fn().mockReturnValue(true)
-  };
-
-  const handleForwardingMock = jest.spyOn(TestExecutor.prototype, <never>'handleForwarding');
-  handleForwardingMock.mockResolvedValueOnce(<never>{ outgoing: { content: "forwarded" } });
-
-  const executor = new TestExecutor();
-  await executor.exec(context);
-
-  expect(handleForwardingMock).toHaveBeenCalled();
-  expect(context.snapshot.assign).toHaveBeenCalledWith({
-    outgoing: { content: "forwarded" },
-    forwarded: expect.any(Object),
-  });
-});