@n1k1t/mock-server 0.1.59 → 0.1.61

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,148 @@
+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),
+  });
+});