@n1k1t/mock-server 0.1.60 → 0.1.61

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

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

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

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

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

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

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