@n1k1t/mock-server 0.1.61 → 0.1.62

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

@@ -1,171 +0,0 @@
-import { IRequestContextIncoming, RequestContext } from './index';
-
-class TestRequestContext extends RequestContext {
-  public incoming: IRequestContextIncoming = {
-    type: 'plain',
-    path: '/',
-    method: 'NONE',
-    headers: {},
-  };
-
-  public snapshot = this.compileSnapshot();
-}
-
-// Test generated using Keploy
-test('switchStatus method should correctly change status and return the instance', () => {
-  const providerMock = { storages: { containers: {}, history: { register: jest.fn() } }, server: { databases: { redis: {} }, exchanges: { io: { publish: jest.fn() } } } };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-  const result = context.switchStatus('handling');
-  expect(context.status).toBe('handling');
-  expect(result).toBe(context);
-});
-
-
-// Test generated using Keploy
-test('compileSnapshot method should create a valid snapshot with proper properties', () => {
-  const providerMock = { storages: { containers: {}, history: { register: jest.fn() } }, server: { databases: { redis: {} }, exchanges: { io: { publish: jest.fn() } } } };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-  context.incoming = <any>{ type: 'testType' };
-
-  const snapshot = context.compileSnapshot();
-
-  expect(snapshot.transport).toBe(context.transport);
-  expect(snapshot.event).toBe(context.event);
-  expect(snapshot.flags).toEqual(context.flags);
-  expect(snapshot.incoming).toEqual(context.incoming);
-  expect(snapshot.outgoing.stream).toBeDefined();
-  expect(snapshot.incoming.stream).toBeDefined();
-});
-
-
-// Test generated using Keploy
-test('compileHistory method should register history with the correct snapshot', () => {
-  const providerMock = {
-    storages: {
-      containers: {},
-      history: {
-        register: jest.fn().mockReturnValue({})
-      }
-    },
-    server: {
-      databases: { redis: {} },
-      exchanges: { io: { publish: jest.fn() } }
-    }
-  };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-  context.incoming = <any>{ type: 'testType' };
-  const history = context.compileHistory();
-
-  expect(providerMock.storages.history.register).toHaveBeenCalledWith(expect.objectContaining({
-    timestamp: context.timestamp,
-    snapshot: expect.anything()
-  }));
-  expect(history).toBe((<jest.Mock>context.provider.storages.history.register).mock.results[0].value);
-});
-
-
-// Test generated using Keploy
-test('compileCacheConfiguration returns disabled when cache is not enabled or expectation is missing', () => {
-  const providerMock = {
-    storages: { containers: {} },
-    server: {
-      databases: { redis: null },
-      exchanges: { io: { publish: jest.fn() } }
-    }
-  };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-  context.snapshot = <any>{
-    cache: { isEnabled: false },
-    incoming: { type: 'GET' },
-    outgoing: {}
-  };
-
-  const result = context.compileCacheConfiguration();
-
-  expect(result).toEqual({ isEnabled: false });
-});
-
-
-// Test generated using Keploy
-test('hasStatuses method correctly identifies if current status is in the given list', () => {
-  const providerMock = {
-    storages: { containers: {}, history: { register: jest.fn() } },
-    server: { databases: { redis: {} }, exchanges: { io: { publish: jest.fn() } } }
-  };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-  context.switchStatus('completed');
-
-  const result = context.hasStatuses(['registered', 'completed']);
-
-  expect(result).toBe(true);
-});
-
-
-// Test generated using Keploy
-test('complete method completes streams and switches status to completed', () => {
-  const providerMock = {
-    storages: {
-      containers: {},
-      history: { register: jest.fn() }
-    },
-    server: {
-      databases: { redis: {} },
-      exchanges: { io: { publish: jest.fn() } }
-    }
-  };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-  context.incoming = <any>{ type: 'testType' };
-  context.snapshot = <any>{
-    outgoing: {}
-  };
-  context.complete();
-
-  expect(context.hasStatuses(['completed'])).toBe(true);
-  expect(context.streams.incoming.isStopped).toBe(true);
-  expect(context.streams.outgoing.isStopped).toBe(true);
-});
-
-// Test generated using Keploy
-test('assign method correctly assigns properties to the context', () => {
-  const providerMock = { storages: { containers: {}, history: { register: jest.fn() } }, server: { databases: { redis: {} }, exchanges: { io: { publish: jest.fn() } } } };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-  const payload = <any>{ incoming: { type: 'newType' }, outgoing: { type: 'newOutgoing' } };
-
-  context.assign(payload);
-
-  expect(context.incoming).toEqual(payload.incoming);
-  expect(context.outgoing).toEqual(payload.outgoing);
-});
-
-
-// Test generated using Keploy
-test('skip method switches status to skipped', () => {
-  const providerMock = { storages: { containers: {}, history: { register: jest.fn() } }, server: { databases: { redis: {} }, exchanges: { io: { publish: jest.fn() } } } };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-
-  context.skip();
-
-  expect(context.status).toBe('skipped');
-});
-
-
-// Test generated using Keploy
-test('handle method switches status to handling', () => {
-  const providerMock = { storages: { containers: {}, history: { register: jest.fn() } }, server: { databases: { redis: {} }, exchanges: { io: { publish: jest.fn() } } } };
-  const configurationMock = { transport: {}, event: {} };
-  const context = new TestRequestContext(<any>providerMock, configurationMock);
-
-  context.handle();
-
-  expect(context.status).toBe('handling');
-});
-
-

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

@@ -1,136 +0,0 @@
-import { ReplaySubject } from 'rxjs';
-import { Value } from '@n1k1t/typebox/value';
-import _ from 'lodash';
-
-import type { IRequestContextIncoming, IRequestContextOutgoing, TRequestContextCacheConfigurationCompiled } from './types';
-import type { IServerContext } from '../../types';
-import type { Expectation } from '../../../expectations';
-import type { Provider } from '../providers';
-import type { History } from '../history';
-
-import { RequestContextSnapshot } from './snapshot';
-import { metaStorage } from '../../../meta';
-import { cast } from '../../../utils';
-
-export * from './snapshot';
-export * from './types';
-export * from './utils';
-
-export abstract class RequestContext<TContext extends IServerContext<any> = IServerContext<any>> {
-  public TContext!: TContext;
-  public TShared!: keyof Pick<RequestContext, 'incoming' | 'outgoing' | 'snapshot' | 'expectation' | 'history'>;
-
-  public abstract incoming: IRequestContextIncoming;
-  public abstract snapshot: RequestContextSnapshot<TContext>;
-
-  public status = cast<'registered' | 'handling' | 'skipped' | 'completed'>('registered');
-
-  public streams = {
-    incoming: new ReplaySubject(Infinity, 5000),
-    outgoing: new ReplaySubject(Infinity, 5000),
-  };
-
-  public transport: TContext['transport'] = this.configuration.transport;
-  public event: TContext['event'] = this.configuration.event;
-  public flags: Partial<Record<TContext['flag'], boolean>> = {};
-
-  public expectation?: Expectation<any>;
-  public outgoing?: IRequestContextOutgoing;
-  public history?: History;
-
-  public timestamp = Date.now();
-  public meta = metaStorage.generate();
-
-  constructor(public provider: Provider<IServerContext<any>>, private configuration: Pick<TContext, 'transport' | 'event'>) {
-    this.streams.incoming.subscribe({ error: () => null, next: (data) => this.history?.pushMessage('incoming', data) });
-    this.streams.outgoing.subscribe({ error: () => null, next: (data) => this.history?.pushMessage('outgoing', data) });
-  }
-
-  public switchStatus(status: RequestContext['status']): this {
-    this.status = status;
-    return this;
-  }
-
-  public hasStatuses(status: RequestContext['status'][]): boolean {
-    return status.includes(this.status);
-  }
-
-  /** Compiles snapshot of own payload to work with expectations */
-  public compileSnapshot(): RequestContextSnapshot<TContext> {
-    const snapshot = RequestContextSnapshot.build<IServerContext<any>>({
-      transport: this.transport,
-
-      event: this.event,
-      flags: this.flags,
-
-      incoming: this.incoming,
-      outgoing: this.outgoing ?? { type: this.incoming.type, status: 0, headers: {} },
-
-      storage: this.provider.storages.containers,
-      cache: { isEnabled: this.provider.server.databases.redis !== null },
-    });
-
-    snapshot.incoming.stream = this.streams.incoming.asObservable();
-    snapshot.outgoing.stream = this.streams.outgoing.asObservable();
-
-    return snapshot;
-  };
-
-  /** Compiles history model with own snapshot for GUI */
-  public compileHistory(): History {
-    return this.provider.storages.history.register({
-      timestamp: this.timestamp,
-      snapshot: this.compileSnapshot().assign({ messages: [] }).clone(),
-    });
-  }
-
-  /** Compiles cache configuration using own snapshot and expectation */
-  public compileCacheConfiguration(): TRequestContextCacheConfigurationCompiled {
-    if (!this.snapshot.cache.isEnabled || !this.expectation?.forward?.cache) {
-      return { isEnabled: false };
-    }
-
-    const payload = this.snapshot.cache.key ?? _.pick(this.snapshot.incoming, ['path', 'method', 'data', 'query']);
-    const prefix = this.snapshot.cache.prefix ?? this.expectation?.forward?.cache?.prefix;
-    const key = typeof payload === 'object' ? Value.Hash(payload).toString() : String(payload);
-    const ttl = this.snapshot.cache.ttl ?? this.expectation.forward.cache.ttl ?? 3600;
-
-    return { prefix, ttl, key: `${prefix ?? ''}${key}`, isEnabled: true };
-  }
-
-  /** Provides payload parts into context */
-  public assign<T extends Partial<Pick<RequestContext<any>, RequestContext<any>['TShared']>>>(payload: T) {
-    return Object.assign(this, payload);
-  }
-
-  /** Marks context as skipped to prevent further handling in executors */
-  public skip() {
-    return this.switchStatus('skipped');
-  }
-
-  /** Marks context as handling */
-  public handle() {
-    return this.switchStatus('handling');
-  }
-
-  /** Marks context as completed, completes streams, provides outgoing payload from the own snapshot and publishes history */
-  public complete() {
-    if (this.hasStatuses(['completed'])) {
-      return this;
-    }
-
-    this.streams.incoming.complete();
-    this.streams.outgoing.complete();
-
-    if (!this.outgoing) {
-      this.outgoing = this.snapshot.outgoing;
-    }
-
-    if (this.history?.hasStatus('pending')) {
-      this.history.actualizeSnapshot(this.snapshot.assign({ outgoing: this.outgoing })).complete();
-      this.provider.server.exchanges.io.publish('history:updated', this.history.toPlain());
-    }
-
-    return this.switchStatus('completed');
-  }
-}

package/src/server/models/context/snapshot.spec.ts

@@ -1,84 +0,0 @@
-import { RequestContextSnapshot } from './snapshot';
-
-// Test generated using Keploy
-it('should correctly assign new values to the instance', () => {
-  const instance = new RequestContextSnapshot({
-    transport: 'http',
-    event: 'connect',
-    incoming: <any>{},
-    outgoing: <any>{},
-    storage: <any>{},
-    flags: {}
-  });
-
-  instance.assign({ transport: 'https', flags: { newFlag: true } });
-
-  expect(instance.transport).toBe('https');
-  expect(instance.flags?.newFlag).toBe(true);
-});
-
-// Test generated using Keploy
-it('should return only the specified keys', () => {
-  const instance = new RequestContextSnapshot({
-    transport: 'http',
-    event: 'connect',
-    incoming: <any>{},
-    outgoing: <any>{},
-    storage: <any>{},
-    flags: {}
-  });
-
-  const picked = instance.pick(['transport', 'flags']);
-  expect(picked).toEqual({
-    transport: 'http',
-    flags: {}
-  });
-});
-
-// Test generated using Keploy
-it('should omit specified keys', () => {
-  const instance = new RequestContextSnapshot({
-    transport: 'http',
-    event: 'connect',
-    incoming: <any>{},
-    outgoing: <any>{},
-    storage: <any>{},
-    flags: {}
-  });
-
-  const omitted = instance.omit(<never[]>['transport']);
-  expect(omitted.transport).toBeUndefined();
-  expect(omitted.event).toBe('connect');
-});
-
-// Test generated using Keploy
-it('should unset specified keys', () => {
-  const instance = new RequestContextSnapshot({
-    transport: 'http',
-    event: 'connect',
-    incoming: <any>{},
-    outgoing: <any>{},
-    storage: <any>{},
-    flags: {}
-  });
-
-  instance.unset(['transport']);
-  expect(instance.transport).toBeUndefined();
-});
-
-// Test generated using Keploy
-it('should clone the instance correctly', () => {
-  const instance = new RequestContextSnapshot({
-    transport: 'http',
-    event: 'connect',
-    incoming: <any>{},
-    outgoing: <any>{},
-    storage: <any>{},
-    flags: {}
-  });
-
-  const cloneInstance = instance.clone();
-  expect(cloneInstance).not.toBe(instance);
-  expect(cloneInstance.transport).toBe(instance.transport);
-});
-

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

@@ -1,148 +0,0 @@
-import rfdc from 'rfdc';
-import _ from 'lodash';
-
-import type { Container, ContainersStorage } from '../containers';
-import type { IServerContext } from '../../types';
-import type {
-  IRequestContextCacheConfiguration,
-  IRequestContextIncoming,
-  IRequestContextOutgoing,
-  IRequestContextMessage,
-  IRequestContextForwarded,
-} from './types';
-
-const clone = rfdc();
-
-export class RequestContextSnapshot<TContext extends IServerContext<any> = IServerContext<any>> {
-  public TPlain!: Omit<RequestContextSnapshot['configuration'], 'container' | 'storage' | 'forwarded'> & {
-    transport: TContext['transport'];
-
-    incoming: {
-      dataRaw?: string;
-    };
-
-    outgoing: {
-      dataRaw?: string;
-    };
-
-    forwarded?: Omit<IRequestContextForwarded, 'incoming' | 'outgoing'> & {
-      incoming: Omit<IRequestContextIncoming, 'dataRaw'> & {
-        dataRaw?: string;
-      };
-
-      outgoing?: Omit<IRequestContextOutgoing, 'dataRaw'> & {
-        dataRaw?: string;
-      };
-    };
-
-    container?: Container['TPlain'];
-    error?: RequestContextSnapshot['error'];
-  };
-
-  public transport: TContext['transport'] = this.configuration.transport;
-  public event: TContext['event'] = this.configuration.event;
-  public flags: Partial<Record<TContext['flag'], boolean>> = this.configuration.flags;
-
-  public storage: ContainersStorage = this.configuration.storage;
-
-  public cache: IRequestContextCacheConfiguration = this.configuration.cache ?? { isEnabled: false };
-  public state: object = this.configuration.state ?? {};
-
-  public incoming: IRequestContextIncoming = this.configuration.incoming;
-  public outgoing: IRequestContextOutgoing = this.configuration.outgoing;
-
-  public forwarded?: IRequestContextForwarded = this.configuration.forwarded;
-  public messages?: IRequestContextMessage[] = this.configuration.messages;
-
-  public container?: Container<any> = this.configuration.container;
-  public seed?: number = this.configuration.seed;
-
-  public error?: {
-    code?: string;
-    message?: string;
-    isManual?: boolean;
-  };
-
-  constructor(
-    private configuration:
-      & Pick<TContext, 'transport' | 'event'>
-      & Pick<RequestContextSnapshot, 'incoming' | 'outgoing' | 'event' | 'storage' | 'flags'>
-      & Partial<Pick<RequestContextSnapshot, 'messages' | 'state' | 'seed' | 'container' | 'forwarded' | 'error' | 'cache'>>
-  ) {}
-
-  public assign<T extends Partial<RequestContextSnapshot['configuration']>>(payload: T) {
-    return Object.assign(this, payload);
-  }
-
-  public pick<K extends keyof RequestContextSnapshot['configuration']>(keys: K[]): Pick<RequestContextSnapshot, K> {
-    return _.pick(this, keys);
-  }
-
-  public omit<K extends keyof RequestContextSnapshot['configuration']>(keys: K[]): Omit<RequestContextSnapshot, K> {
-    return <Omit<RequestContextSnapshot, K>>_.omit(this, keys);
-  }
-
-  public unset<K extends keyof RequestContextSnapshot['configuration']>(keys: K[]): Omit<RequestContextSnapshot, K> {
-    keys.forEach((key) => _.unset(this, key));
-    return <Omit<RequestContextSnapshot, K>>this;
-  }
-
-  public clone(): this {
-    return <this>RequestContextSnapshot.build({
-      ..._.omit(this, ['incoming', 'outgoing']),
-
-      incoming: Object.assign(clone(_.omit(this.incoming, ['stream', 'dataRaw'])), {
-        stream: this.incoming.stream,
-        dataRaw: this.incoming.dataRaw?.subarray(),
-      }),
-
-      outgoing: Object.assign(clone(_.omit(this.outgoing, ['stream', 'dataRaw'])), {
-        stream: this.outgoing.stream,
-        dataRaw: this.outgoing.dataRaw?.subarray(),
-      }),
-    });
-  }
-
-  public toPlain(): RequestContextSnapshot['TPlain'] {
-    return {
-      transport: this.transport,
-      event: this.event,
-      flags: this.flags,
-
-      state: this.state,
-      cache: this.cache,
-
-      seed: this.seed,
-      container: this.container?.toPlain(),
-
-      incoming: Object.assign(_.omit(this.incoming, ['stream']), {
-        dataRaw: this.incoming.dataRaw?.toString(),
-      }),
-
-      outgoing: Object.assign(_.omit(this.outgoing, ['stream']), {
-        dataRaw: this.outgoing.dataRaw?.toString(),
-      }),
-
-      ...(this.forwarded && {
-        forwarded: Object.assign(_.omit(this.forwarded, ['incoming', 'outgoing']), {
-          incoming: Object.assign(_.omit(this.forwarded.incoming, ['dataRaw']), {
-            dataRaw: this.forwarded.incoming.dataRaw?.toString(),
-          }),
-
-          ...(this.forwarded.outgoing && {
-            outgoing: Object.assign(_.omit(this.forwarded.outgoing, ['dataRaw']), {
-              dataRaw: this.forwarded.outgoing.dataRaw?.toString(),
-            }),
-          }),
-        }),
-      }),
-
-      messages: this.messages,
-      error: this.error,
-    };
-  }
-
-  static build<TContext extends IServerContext<any>>(configuration: RequestContextSnapshot<TContext>['configuration']) {
-    return new RequestContextSnapshot<TContext>(configuration);
-  }
-}

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

@@ -1,65 +0,0 @@
-import type { Observable } from 'rxjs';
-
-import type { TRequestPayloadType } from '../../types';
-import type { SetRequiredKeys } from '../../../../types';
-
-export interface IRequestContextIncoming {
-  type: TRequestPayloadType;
-  path: string;
-  method: string;
-  headers: Record<string, string>;
-
-  query?: Record<string, unknown>;
-  stream?: Observable<unknown>;
-
-  data?: unknown;
-  dataRaw?: Buffer;
-
-  delay?: number;
-  error?: 'ECONNABORTED';
-}
-
-export interface IRequestContextOutgoing {
-  type: TRequestPayloadType;
-  status: number;
-  headers: Record<string, string>;
-
-  data?: unknown;
-  dataRaw?: Buffer;
-
-  stream?: Observable<unknown>;
-}
-
-export interface IRequestContextMessage {
-  id: number;
-  location: 'incoming' | 'outgoing';
-
-  timestamp: number;
-  data: unknown;
-}
-
-export interface IRequestContextForwarded {
-  incoming: IRequestContextIncoming;
-  outgoing?: IRequestContextOutgoing;
-
-  messages?: Pick<IRequestContextMessage, 'location' | 'data'>[];
-  isCached?: boolean;
-}
-
-export interface IRequestContextCache {
-  outgoing: Omit<IRequestContextOutgoing, 'dataRaw'> & { dataRaw?: string };
-  messages?: Pick<IRequestContextMessage, 'location' | 'data'>[];
-}
-
-export interface IRequestContextCacheConfiguration {
-  isEnabled: boolean;
-  prefix?: string;
-  key?: string | object;
-
-  /** Seconds */
-  ttl?: number;
-}
-
-export type TRequestContextCacheConfigurationCompiled =
-  | { isEnabled: false }
-  | { isEnabled: true, key: string } & SetRequiredKeys<IRequestContextCacheConfiguration, 'ttl'>;

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

@@ -1,77 +0,0 @@
-import { extractPayloadType } from './utils';
-import { parsePayload } from './utils';
-import { serializePayload } from './utils';
-import { IncomingMessage } from 'http';
-import { extractHttpIncommingContext } from './utils';
-
-// Test generated using Keploy
-test('should return json when content type is application/json', () => {
-  const headers = {
-    'Content-Type': 'application/json'
-  };
-  const result = extractPayloadType(headers);
-  expect(result).toBe('json');
-});
-
-// Test generated using Keploy
-test('should return xml when content type is application/xml', () => {
-  const headers = {
-    'Content-Type': 'application/xml'
-  };
-  const result = extractPayloadType(headers);
-  expect(result).toBe('xml');
-});
-
-// Test generated using Keploy
-test('should return undefined when type is unsupported', () => {
-  const result = parsePayload('plain', Buffer.from('test data'));
-  expect(result).toBeUndefined();
-});
-
-// Test generated using Keploy
-test('should serialize payload to JSON buffer', () => {
-  const payload = { key: 'value' };
-  const result = serializePayload('json', payload);
-  expect(result).toEqual(Buffer.from(JSON.stringify(payload)));
-});
-
-// Test generated using Keploy
-test('should serialize payload to XML buffer', () => {
-  const payload = { key: 'value' };
-  const result = serializePayload('xml', payload);
-  expect(result).toEqual(expect.any(Buffer));
-});
-
-// Test generated using Keploy
-test('test_parsePayload_validJson', () => {
-  const payload = Buffer.from(JSON.stringify({ key: 'value' }));
-  const result = parsePayload('json', payload);
-  expect(result).toEqual({ key: 'value' });
-});
-
-// Test generated using Keploy
-const xmlPayload = Buffer.from('<root><key>value</key></root>');
-const result = parsePayload('xml', xmlPayload);
-expect(result).toEqual({ root: { key: 'value' } });
-
-// Test generated using Keploy
-test('test_extractPayloadType_emptyHeaders', () => {
-  const headers = {};
-  const result = extractPayloadType(headers);
-  expect(result).toBeNull();
-});
-
-// Test generated using Keploy
-test('test_extractHttpIncommingContext_missingBody', async () => {
-  const request = <IncomingMessage><unknown>{
-    url: '/test?param=value',
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: undefined
-  };
-
-  const result = await extractHttpIncommingContext(request);
-  expect(result.data).toBeUndefined();
-});