@n1k1t/mock-server 0.1.61 → 0.1.62

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

@@ -1,297 +0,0 @@
-import { gzip, ungzip } from 'node-gzip';
-import { from } from 'rxjs';
-import rfdc from 'rfdc';
-import _ from 'lodash';
-
-import type { Expectation, IExpectationSchemaForward } from '../../../expectations';
-
-import { ExecutorManualError } from './errors';
-import { cast, wait } from '../../../utils';
-import { Logger } from '../../../logger';
-import {
-  parsePayload,
-  RequestContext,
-  serializePayload,
-  extractPayloadType,
-  IRequestContextCache,
-  IRequestContextOutgoing,
-  IRequestContextIncoming,
-  IRequestContextForwarded,
-} from '../context';
-
-export * from './errors';
-
-const clone = rfdc();
-const logger = Logger.build('Server.Models.Executor');
-
-export interface IExecutorExecOptions {
-  expectation?: Expectation<any>;
-}
-
-export abstract class Executor<TRequestContext extends RequestContext = RequestContext> {
-  public TRequestContext!: TRequestContext;
-  public TContext!: TRequestContext['TContext'];
-
-  /** Uses to handle request forwarding */
-  public abstract forward(
-    context: TRequestContext,
-    incoming: IRequestContextIncoming,
-    configuration: IExpectationSchemaForward,
-  ): Promise<IRequestContextForwarded | null>;
-
-  /** Uses to handle outgoing payload and reply */
-  public abstract reply(
-    context: TRequestContext,
-    outgoing: IRequestContextOutgoing
-  ): Promise<IRequestContextOutgoing | null>;
-
-  /** Matches expectation */
-  public async match(context: TRequestContext): Promise<Expectation<any> | null> {
-    return context.provider.storages.expectations.match(context.snapshot);
-  }
-
-  /** Prepares context right after expectation was manipulated */
-  public async prepare(context: TRequestContext): Promise<unknown> {
-    return context;
-  }
-
-  /** Uses to handle whole request */
-  public async exec(context: TRequestContext, options?: IExecutorExecOptions): Promise<TRequestContext> {
-    const expectation = options?.expectation ? options.expectation : await this.match(context).catch((error) => {
-      logger.error('Got error while execution [matchExpectation] method', error?.stack ?? error);
-      return null;
-    });
-
-    if (!expectation) {
-      if (!context.outgoing) {
-        context.provider.storages.history.unregister(context.history);
-        return context;
-      }
-
-      if (context.history?.hasStatus('registered')) {
-        context.history.switchStatus('pending');
-      }
-
-      return context;
-    }
-
-    context.assign({
-      snapshot: expectation.request.manipulate(context.snapshot),
-      expectation: expectation.increaseExecutionsCounter(),
-    });
-
-    await this
-      .prepare(context)
-      .catch((error) => logger.error('Got error while execution [prepare] method', error?.stack ?? error));
-
-    context.provider.server.exchanges.io.publish('expectation:updated', expectation.toPlain());
-    logger.info('Expectation has matched as', `"${expectation.name}" [${expectation.id}]`);
-
-    if (context.history?.hasStatus('registered')) {
-      context.history
-        .switchStatus('pending')
-        .actualizeSnapshot(context.snapshot)
-        .assign({ expectation: context.expectation });
-
-      context.provider.server.exchanges.io.publish('history:added', context.history.toPlain());
-      context.provider.server.services.metrics.register('rate', { count: 1 });
-    }
-
-    if (!context.hasStatuses(['handling'])) {
-      return context;
-    }
-
-    if (context.snapshot.incoming.delay) {
-      logger.info(`Has delayed over [${context.snapshot.incoming.delay}ms]`);
-      await wait(context.snapshot.incoming.delay);
-    }
-
-    if (context.snapshot.incoming.error) {
-      logger.info(`Has destroyed using [${context.snapshot.incoming.error}]`);
-
-      context.snapshot.assign({ error: { code: context.snapshot.incoming.error, isManual: true } });
-      throw ExecutorManualError.build(context.snapshot.incoming.error);
-    }
-
-    if (expectation.forward) {
-      const forwarded = await this.handleForwarding(context).catch((error) => {
-        logger.error('Got error while execution [handleForwarding] method', error?.stack ?? error);
-        return null;
-      });
-
-      if (forwarded) {
-        context.snapshot.assign({
-          outgoing: forwarded.outgoing ?? context.snapshot.outgoing,
-
-          forwarded: {
-            isCached: forwarded.isCached,
-            messages: clone(forwarded.messages),
-
-            incoming: Object.assign(
-              clone(_.omit(forwarded.incoming, ['stream'])),
-              _.pick(forwarded.incoming, ['stream'])
-            ),
-
-            ...(forwarded.outgoing && {
-              outgoing: Object.assign(
-                clone(_.omit(forwarded.outgoing, ['stream'])),
-                _.pick(forwarded.outgoing, ['stream'])
-              ),
-            }),
-          }
-        });
-      }
-
-      if (context.snapshot.forwarded && context.history?.hasStatus('pending')) {
-        context.history.snapshot.assign({
-          cache: context.snapshot.cache,
-
-          forwarded: {
-            isCached: context.snapshot.forwarded.isCached,
-            incoming: _.omit(context.snapshot.forwarded.incoming, ['stream']),
-
-            ...(context.snapshot.forwarded.outgoing && {
-              outgoing: _.omit(context.snapshot.forwarded.outgoing, ['stream'])
-            }),
-          },
-        });
-
-        context.provider.server.exchanges.io.publish('history:updated', context.history.toPlain());
-      }
-    }
-
-    if (!context.hasStatuses(['handling'])) {
-      return context;
-    }
-
-    const outgoing = await this.handleReplying(context).catch((error) => {
-      logger.error('Got error while execution [handleReplying] method', error?.stack ?? error);
-      return null;
-    });
-
-    return outgoing ? context.assign({ outgoing }) : context;
-  }
-
-  private async handleForwarding(context: TRequestContext): Promise<IRequestContextForwarded | null> {
-    if (!context.expectation?.forward) {
-      return context.snapshot;
-    }
-
-    const snapshot = context.snapshot.assign({ cache: context.compileCacheConfiguration() });
-
-    if (snapshot.cache.isEnabled) {
-      const cached = await context.provider.server.databases.redis!.get(snapshot.cache.key).catch((error) => {
-        logger.error('Got error while redis get', error?.stack ?? error);
-        return null;
-      });
-
-      const unziped = cached
-        ? await ungzip(Buffer.from(cached, 'base64')).catch((error) => {
-          logger.error('Got error while cache unzip', error?.stack ?? error);
-          return null;
-        })
-        : null;
-
-      const parsed = <IRequestContextCache | null>(unziped ? parsePayload('json', unziped) : null);
-      const dataRaw = parsed?.outgoing.dataRaw ? Buffer.from(parsed?.outgoing.dataRaw, 'base64') : undefined;
-
-      if (parsed) {
-        logger.info(`Got cache [${snapshot.cache.key}]`);
-
-        if (parsed.messages?.length) {
-          parsed.outgoing.stream = from(parsed.messages.map((message) => message.data) ?? []);
-        }
-
-        return Object.assign(snapshot.pick(['incoming']), {
-          isCached: true,
-          messages: parsed.messages,
-
-          outgoing: Object.assign(_.omit(parsed.outgoing, ['dataRaw']), {
-            data: dataRaw ? parsePayload(parsed.outgoing.type, dataRaw) : undefined,
-            dataRaw,
-          }),
-        });
-      }
-    }
-
-    const type = extractPayloadType(snapshot.incoming.headers) ?? 'plain';
-    const dataRaw = snapshot.incoming.data === undefined
-      ? snapshot.incoming.dataRaw
-      : typeof snapshot.incoming.data === 'object'
-        ? serializePayload(type, snapshot.incoming.data)
-        : Buffer.from(String(snapshot.incoming.data));
-
-    const forwarded = await this
-      .forward(context, Object.assign(snapshot.incoming, { type, dataRaw }), context.expectation.forward)
-      .catch((error) => {
-        logger.error('Got error while execution [forward] method', error?.stack ?? error);
-        return null;
-      });
-
-    if (forwarded) {
-      forwarded.messages = [];
-      forwarded.outgoing?.stream?.subscribe({
-        error: () => null,
-        next: (data) => forwarded.messages!.push({ data, location: 'outgoing' }),
-      });
-    }
-
-    return forwarded;
-  }
-
-  private async handleReplying(context: TRequestContext): Promise<IRequestContextOutgoing | null> {
-    const snapshot = context.expectation?.response
-      ? context.expectation.response.manipulate(context.snapshot)
-      : context.snapshot;
-
-    const type = extractPayloadType(snapshot.outgoing.headers) ?? snapshot.outgoing.type;
-    const dataRaw = snapshot.outgoing.data === undefined
-      ? snapshot.outgoing.dataRaw
-      : typeof snapshot.outgoing.data === 'object'
-        ? serializePayload(type, snapshot.outgoing.data)
-        : Buffer.from(String(snapshot.outgoing.data));
-
-    const outgoing = await this
-      .reply(context, Object.assign(snapshot.outgoing, { type, dataRaw }))
-      .catch((error) => {
-        logger.error('Got error while execution [reply] method', error?.stack ?? error);
-        return null;
-      });
-
-    const shouldBeCached = snapshot.cache.isEnabled
-      && snapshot.forwarded?.outgoing
-      && !snapshot.forwarded.isCached
-      && snapshot.cache.ttl
-      && typeof snapshot.cache.key === 'string';
-
-    if (shouldBeCached) {
-      const serialized = serializePayload('json', cast<IRequestContextCache>({
-        messages: snapshot.forwarded!.messages?.filter((message) => message.location === 'outgoing'),
-        outgoing: Object.assign(_.omit(snapshot.forwarded!.outgoing, ['data']), {
-          dataRaw: snapshot.forwarded!.outgoing?.dataRaw?.toString('base64'),
-        }),
-      }));
-
-      if (!serialized) {
-        return outgoing;
-      }
-
-      const zipped = await gzip(serialized).catch((error) => {
-        logger.error('Got error while zip payload', error?.stack ?? error);
-        return null;
-      });
-
-      if (zipped) {
-        await context.provider.server.databases.redis!.setex(
-          <string>snapshot.cache.key,
-          snapshot.cache.ttl!,
-          zipped.toString('base64')
-        )
-          .then(() => logger.info(`Wrote cache [${snapshot.cache.key}] for [${snapshot.cache.ttl}] seconds`))
-          .catch((error) => logger.error('Got error while redis set', error?.stack ?? error));
-      }
-    }
-
-    return outgoing;
-  }
-}

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

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

package/src/server/models/history/model.spec.ts

@@ -1,35 +0,0 @@
-import { History } from './model';
-
-// Test generated using Keploy
-test('test_pushMessage_withValidData_messageAddedToSnapshot', () => {
-  const history = new History({ group: 'testGroup', snapshot: <any>{ messages: [] } });
-  const location = 'testLocation';
-  const data = { key: 'value' };
-
-  history.pushMessage(<any>location, data);
-
-  expect(history.snapshot.messages.length).toBe(1);
-  expect(history.snapshot.messages[0]).toEqual(
-    expect.objectContaining({
-      location: location,
-      data: data
-    })
-  );
-});
-
-// Test generated using Keploy
-test('test_switchStatus_updatesStatus', () => {
-  const history = new History({ group: 'testGroup', snapshot: <any>{ messages: [] } });
-  history.switchStatus('completed');
-  expect(history.hasStatus('completed')).toBe(true);
-});
-
-// Test generated using Keploy
-test('test_complete_marksStatusCompletedAndClonesContainer', () => {
-  const mockContainer = { clone: jest.fn() };
-  const history = new History({ group: 'testGroup', snapshot: <any>{ messages: [], container: mockContainer } });
-  history.complete();
-  expect(history.hasStatus('completed')).toBe(true);
-  expect(mockContainer.clone).toHaveBeenCalled();
-});
-

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

@@ -1,82 +0,0 @@
-import { v4 as genUid } from 'uuid';
-
-import type { IRequestContextMessage, RequestContextSnapshot } from '../../models';
-import type { SetRequiredKeys } from '../../../../types';
-import type { Expectation } from '../../../expectations';
-
-import { buildCounter, cast } from '../../../utils';
-
-export class History {
-  public TPlain!: Pick<History, 'id' | 'status' | 'group' | 'timestamp' | 'duration'> & {
-    snapshot: RequestContextSnapshot['TPlain'];
-    expectation?: Expectation<any>['TPlain'];
-  };
-
-  public id: string = genUid();
-  public messagesCounter = buildCounter();
-
-  public group: string = this.configuration.group;
-  public snapshot: SetRequiredKeys<RequestContextSnapshot, 'messages'> = this.configuration.snapshot;
-
-  public status = cast<'unregistered' | 'registered' | 'pending' | 'completed'>('unregistered');
-  public expectation?: Expectation<any>;
-
-  public timestamp: number = this.configuration.timestamp ?? Date.now();
-  public duration: number = 0;
-
-  constructor(private configuration: Pick<History, 'group' | 'snapshot'> & Partial<Pick<History, 'timestamp'>>) {}
-
-  public pushMessage(location: IRequestContextMessage['location'], data: unknown): this {
-    this.snapshot.messages.push({ location, data, id: this.messagesCounter(), timestamp: Date.now() });
-    return this.mark();
-  }
-
-  public actualizeSnapshot(snapshot: RequestContextSnapshot): this {
-    this.snapshot.assign(snapshot.omit(['incoming', 'forwarded', 'messages']));
-    return this.mark();
-  }
-
-  public switchStatus(status: History['status']): this {
-    return Object.assign(this.mark(), { status });
-  }
-
-  public hasStatus(status: History['status']): boolean {
-    return this.status === status;
-  }
-
-  public complete(): this {
-    if (this.snapshot.container) {
-      this.snapshot.container = this.snapshot.container.clone();
-    }
-
-    return this.switchStatus('completed');
-  }
-
-  public assign<T extends Partial<Pick<History, 'expectation'>>>(payload: T) {
-    return Object.assign(this.mark(), payload);
-  }
-
-  /** Updates duration property base on timestamp */
-  public mark() {
-    return this.hasStatus('completed') ? this : Object.assign(this, { duration: Date.now() - this.timestamp });
-  }
-
-  public toPlain(): History['TPlain'] {
-    return {
-      id: this.id,
-
-      timestamp: this.timestamp,
-      duration: this.duration,
-
-      group: this.group,
-      status: this.status,
-
-      snapshot: this.snapshot.toPlain(),
-      expectation: this.expectation?.toPlain(),
-    };
-  }
-
-  static build(configuration: History['configuration']) {
-    return new History(configuration);
-  }
-}

package/src/server/models/history/storage.spec.ts

@@ -1,41 +0,0 @@
-import { HistoryStorage } from './storage';
-import { History } from './model';
-import config from '../../../config';
-
-// Test generated using Keploy
-test('test_registerHistory_withoutExistingHistory_createsValidHistory', () => {
-  const storage = new HistoryStorage({ group: 'test-group' });
-  const historyData = { snapshot: {} };
-  const result = storage.register(<any>historyData);
-  expect(result).toBeInstanceOf(History);
-  expect(result.group).toBe('test-group');
-  expect(result.snapshot).toEqual(historyData.snapshot);
-});
-
-// Test generated using Keploy
-test('test_unregisterHistory_removesHistoryFromStorage', () => {
-  const storage = new HistoryStorage({ group: 'test-group' });
-  const historyInstance = new History(<any>{ id: '1', snapshot: {} });
-  storage.register(historyInstance);
-  expect(storage.size).toBe(1);
-  storage.unregister(historyInstance);
-  expect(storage.size).toBe(0);
-});
-
-// Test generated using Keploy
-test('test_registerHistory_exceedsLimit_removesOldestEntry', () => {
-  const mockConfig = { get: () => ({ limit: 2 }) };
-  jest.spyOn(config, 'get').mockImplementation(<any>mockConfig.get);
-
-  const storage = new HistoryStorage({ group: 'test-group' });
-  const history1 = new History(<any>{ id: '1', snapshot: {} });
-  const history2 = new History(<any>{ id: '2', snapshot: {} });
-  const history3 = new History(<any>{ id: '3', snapshot: {} });
-
-  storage.register(history1);
-  storage.register(history2);
-  expect(storage.size).toBe(2);
-  storage.register(history3);
-  expect(storage.size).toBe(2);
-  expect(storage.has('1')).toBe(false); // oldest entry should be removed
-});

package/src/server/models/history/storage.ts

@@ -1,38 +0,0 @@
-import { History } from './model';
-import config from '../../../config';
-
-export class HistoryStorage extends Map<string, History> {
-  private stack: string[] = [];
-
-  constructor(private configuration: Pick<History, 'group'>) {
-    super();
-  }
-
-  public register(predicate: History | Omit<History['configuration'], 'group'>): History {
-    const history = predicate instanceof History ? predicate : History.build({
-      group: this.configuration.group,
-      snapshot: predicate.snapshot,
-    });
-
-    this.set(history.id, history);
-
-    if (this.stack.push(history.id) > config.get('history').limit) {
-      this.delete(this.stack.shift()!);
-    }
-
-    return history.switchStatus('registered');
-  }
-
-  public unregister(history?: History): this {
-    if (history) {
-      this.delete(history.switchStatus('unregistered').id);
-    }
-
-    return this;
-  }
-
-  clear(): void {
-    this.stack = [];
-    super.clear();
-  }
-}

package/src/server/models/index.ts

@@ -1,11 +0,0 @@
-export * from './containers';
-export * from './transports';
-export * from './providers';
-export * from './exchanges';
-export * from './executor';
-export * from './endpoint';
-export * from './service';
-export * from './history';
-export * from './context';
-export * from './router';
-export * from './reply';

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

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

package/src/server/models/providers/model.spec.ts

@@ -1,11 +0,0 @@
-import { Provider } from './model';
-
-// Test generated using Keploy
-describe('Provider', () => {
-  it('should assign the server correctly', () => {
-    const provider = Provider.build({ group: 'test-group' });
-    const mockServer = {}; // Mock server object
-    provider.assign({ server: <any>mockServer });
-    expect(provider.server).toBe(mockServer);
-  });
-});

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

@@ -1,33 +0,0 @@
-import type { MockServer } from '../../index';
-
-import { IServerContext, TDefaultServerContext } from '../../types';
-import { ExpectationsStorage } from '../../../expectations';
-import { ContainersStorage } from '../containers';
-import { HistoryStorage } from '../history';
-import { OnsiteClient } from '../../../client';
-
-export class Provider<TContext extends IServerContext<any> = TDefaultServerContext> {
-  public TContext!: TContext;
-  public server!: MockServer;
-
-  public client = OnsiteClient.build<TContext>(this);
-  public group: string = this.provided.group;
-
-  public storages = {
-    expectations: new ExpectationsStorage(),
-    containers: new ContainersStorage(),
-    history: new HistoryStorage(this.provided),
-  };
-
-  constructor(private provided: Pick<Provider, 'group'>) {}
-
-  public assign(payload: Partial<Pick<Provider, 'server'>>): this {
-    return Object.assign(this, payload);
-  }
-
-  static build<TContext extends IServerContext<any> = TDefaultServerContext>(
-    provided: Provider['provided']
-  ): Provider<TContext> {
-    return new Provider<TContext>(provided);
-  }
-}

package/src/server/models/providers/storage.spec.ts

@@ -1,21 +0,0 @@
-import { ProvidersStorage } from './storage';
-import { MockServer } from '../../index';
-import { Provider } from './model';
-
-// Test generated using Keploy
-test('extract returns all providers including default', () => {
-  const mockServer = <MockServer<any, any>>{};
-  const storage = new ProvidersStorage(mockServer);
-  const provider1 = Provider.build({ group: 'group1' });
-  const provider2 = Provider.build({ group: 'group2' });
-
-  storage.register(provider1);
-  storage.register(provider2);
-
-  const result = storage.extract();
-
-  expect(result).toHaveLength(3); // Two registered + one default
-  expect(result).toContainEqual(provider1);
-  expect(result).toContainEqual(provider2);
-  expect(result).toContainEqual(storage.default);
-});

package/src/server/models/providers/storage.ts

@@ -1,34 +0,0 @@
-import type { IServerContext } from '../../types';
-import type { MockServer } from '../../index';
-
-import { Provider } from './model';
-import { Logger } from '../../../logger';
-
-const logger = Logger.build('Server.Models.ProvidersStorage');
-
-export class ProvidersStorage<TContext extends IServerContext<any>> extends Map<string, Provider<TContext>> {
-  public default = Provider.build<TContext>({ group: 'default' });
-
-  constructor(private server: MockServer<any, TContext>) {
-    super();
-  }
-
-  public extract(): Provider[] {
-    return [...this.values(), this.default];
-  }
-
-  public register(provider: Provider<TContext>): this {
-    provider.assign({ server: this.server });
-
-    if (this.default === provider) {
-      return this;
-    }
-    if (this.has(provider.group)) {
-      logger.info(`Provider group [${provider.group}] is already registered. Using existent...`);
-      return this;
-    }
-
-    logger.info(`Provider group [${provider.group}] has registered`);
-    return this.set(provider.group, provider);
-  }
-}

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

@@ -1,17 +0,0 @@
-import { RequestContext } from './context';
-import { Reply } from './reply';
-
-// Test generated using Keploy
-test('test_okMethod_shouldReturnStructuredResponse', () => {
-  const mockContext = {} as RequestContext;
-  const reply = new class extends Reply<typeof mockContext> {
-    ok = (payload: unknown) => ({ status: 200, data: payload });
-    notFound = () => ({ status: 404 });
-    internalError = (message?: string) => ({ status: 500, message });
-    validationError = (reasons?: unknown[]) => ({ status: 400, errors: reasons });
-  }(mockContext);
-
-  const response = reply.ok({ message: 'success' });
-  expect(response).toEqual({ status: 200, data: { message: 'success' } });
-  expect(typeof response).toBe('object');
-});

package/src/server/models/reply.ts

@@ -1,10 +0,0 @@
-import type { RequestContext } from './context';
-
-export abstract class Reply<TContext extends RequestContext, TOutgoing = unknown> {
-  constructor(public context: TContext) {}
-
-  public abstract ok(payload: TOutgoing): unknown;
-  public abstract notFound(): unknown;
-  public abstract internalError(message?: string): unknown;
-  public abstract validationError(reasons?: unknown[]): unknown;
-}