@n1k1t/mock-server 0.1.59 → 0.1.61

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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