@n1k1t/mock-server 0.1.59 → 0.1.61

package/src/client/utils.ts

@@ -0,0 +1,41 @@
+import { AxiosError } from 'axios';
+import _ from 'lodash';
+
+import type { IRequestConfiguration } from './errors';
+import type { IEndpointResponse } from '../server';
+
+import { ConnectionError, InternalServerError, ValidationError } from './errors';
+import { Expectation, serializeExpectationSchema } from '../expectations';
+
+export const handleRequestError = (error: AxiosError<IEndpointResponse<any>>) => {
+  const configuration: IRequestConfiguration = {
+    baseURL: error.config.baseURL,
+    method: error.config.method,
+    url: error.config.url,
+  };
+
+  if (!error.response) {
+    throw new ConnectionError(configuration);
+  }
+
+  switch(error.response?.data.code) {
+    case 'INTERNAL_ERROR': {
+      throw new InternalServerError(configuration, error.response?.data.data?.message);
+    }
+    case 'VALIDATION_ERROR': {
+      throw new ValidationError(configuration, error.response?.data.data?.reasons);
+    }
+  }
+
+  throw new InternalServerError(configuration, error.message);
+}
+
+export const prepareExpectationBodyToRequest = <T extends Partial<Expectation<any>['TPlain']>>(body: T): T => ({
+  ...body,
+
+  schema: {
+    ...body.schema,
+    ...(body.schema?.request && { request: serializeExpectationSchema(body.schema.request) }),
+    ...(body.schema?.response && { response: serializeExpectationSchema(body.schema.response) }),
+  }
+});

package/src/config/index.ts

@@ -0,0 +1,34 @@
+import path from 'path';
+
+import type { TLoggerLevel } from '../logger';
+
+import { Config } from './model';
+import { cast } from '../utils';
+
+export * from './model';
+
+const checkIsTypeScriptRuntime = (): boolean => path.parse(__filename).ext === '.ts';
+const getPathToRoot = (): string => path.resolve(__dirname, checkIsTypeScriptRuntime() ? '' : '../', '../../');
+
+export default Config.build(<const>{
+    statics: {
+      public: {
+        dir: path.resolve(getPathToRoot(), 'public'),
+      },
+    },
+
+    routes: {
+      internal: {
+        root: '/_system',
+        gui: '/gui',
+      },
+    },
+
+    history: {
+      limit: 100,
+    },
+
+    logger: {
+      level: cast<TLoggerLevel>('D'),
+    },
+  });

package/src/config/model.ts

@@ -0,0 +1,24 @@
+import merge from 'deepmerge';
+import { PartialDeep, SetRequiredKeys } from '../../types';
+
+export class Config<T extends object = object> {
+  public storage: T = merge(this.defaults, JSON.parse(process.env['MOCK_CONFIG'] ?? '{}'));
+
+  constructor(public defaults: T) {}
+
+  public get<K extends keyof T>(key: K): T[K] {
+    return this.storage[key];
+  }
+
+  public has<K extends keyof T>(key: K): this is SetRequiredKeys<T, K> {
+    return key in this.storage;
+  }
+
+  public merge(payload: PartialDeep<T>): this {
+    return Object.assign(this, { storage: merge(this.storage, <T>payload, { arrayMerge: (target, source) => source }) });
+  }
+
+  static build<T extends object>(defaults: T) {
+    return new Config(defaults);
+  }
+}

package/src/expectations/__utils__/index.ts

@@ -0,0 +1,61 @@
+import { IExpectationSchemaContext } from '../types';
+import { ContainersStorage } from '../../server/models';
+
+export const buildExpectationContext = (): IExpectationSchemaContext => ({
+  storage: new ContainersStorage(),
+
+  transport: 'http',
+  event: 'connection',
+
+  state: {},
+  flags: {},
+
+  cache: {
+    isEnabled: false,
+  },
+
+  incoming: {
+    type: 'json',
+
+    path: '/foo/bar/baz',
+    method: 'POST',
+
+    query: {
+      foo: 1,
+      bar: {
+        baz: null,
+      },
+    },
+
+    dataRaw: Buffer.from('{"foo": [{"bar": 1}, {"baz": ["2"]}]}'),
+    data: {
+      foo: [
+        { bar: 1 },
+        { baz: ['2'] },
+      ],
+    },
+
+    headers: {
+      'content-type': 'application/json',
+      'accept-language': 'en/gb',
+    },
+  },
+
+  outgoing: {
+    type: 'json',
+    status: 200,
+
+    dataRaw: Buffer.from('{"foo": {"bar": {"baz": true}}}'),
+    data: {
+      foo: {
+        bar: {
+          baz: true,
+        },
+      },
+    },
+
+    headers: {
+      'content-type': 'application/json',
+    },
+  },
+});

package/src/expectations/errors/index.ts

@@ -0,0 +1,7 @@
+import { ValueError } from '@n1k1t/typebox/errors';
+
+export class ExpectationValidationError extends Error {
+  constructor(public reasons: ValueError[]) {
+    super('Got error on expectation validation');
+  }
+}

package/src/expectations/index.ts

@@ -0,0 +1,3 @@
+export * from './models';
+export * from './types';
+export * from './utils';

package/src/expectations/models/expectation.ts

@@ -0,0 +1,96 @@
+import generateAnimalName from 'random-animal-name';
+import { v4 as genUid } from 'uuid';
+import { ValueError } from '@n1k1t/typebox/errors';
+import _ from 'lodash';
+
+import { serializeExpectationSchema } from '../utils';
+import {
+  IExpectationMeta,
+  IExpectationSchemaContext,
+  IExpectationSchemaInput,
+  IExpectationSchema,
+} from '../types';
+
+import * as operators from '../operators';
+
+export class Expectation<
+  TInput extends IExpectationSchemaInput = {},
+  TContext extends IExpectationSchemaContext<TInput> = IExpectationSchemaContext<TInput>
+> {
+  public TPlain!: Pick<
+    Expectation<TInput, TContext>,
+    'schema' | 'id' | 'group' | 'isEnabled' | 'meta' | 'name' | 'transports'
+  >;
+
+  public id: string = this.configuration.id ?? genUid();
+  public name: string = this.configuration.name ?? generateAnimalName().split(' ').map(_.capitalize).join('');
+  public group: string = this.configuration.group ?? 'unknown';
+
+  public transports?: TContext['transport'][] = this.configuration.transports;
+
+  public schema = <IExpectationSchema<TContext>>this.configuration.schema;
+  public isEnabled: boolean = this.configuration.isEnabled ?? true;
+
+  public request = this.schema.request
+    ? new operators.root<TContext>(operators, this.schema.request)
+    : new operators.root<TContext>(operators, { $exec: () => true });
+
+  public response = this.schema.response
+    ? new operators.root<TContext>(operators, this.schema.response)
+    : null;
+
+  public meta: IExpectationMeta = {
+    executionsCount: this.configuration.meta?.executionsCount ?? 0,
+    tags: (this.request?.tags ?? []).concat(this.response?.tags ?? []),
+  };
+
+  public get forward() {
+    return this.schema.forward;
+  }
+
+  private serialized = {
+    schema: {
+      request: this.schema.request ? serializeExpectationSchema(this.schema.request) : undefined,
+      response: this.schema.response ? serializeExpectationSchema(this.schema.response) : undefined,
+    },
+  };
+
+  constructor(
+    public configuration: Pick<Expectation<TContext>, 'schema'> & Partial<
+      Pick<Expectation<TContext>, 'id' | 'name' | 'isEnabled' | 'group' | 'transports' | 'meta'>
+    >
+  ) {}
+
+  public increaseExecutionsCounter(): this {
+    this.meta.executionsCount += 1;
+    return this;
+  }
+
+  public validate(): ValueError[] {
+    return [];
+  }
+
+  public toPlain(): Expectation<TInput, TContext>['TPlain'] {
+    return {
+      id: this.id,
+      group: this.group,
+
+      name: this.name,
+      transports: this.transports,
+
+      meta: this.meta,
+      isEnabled: this.isEnabled,
+
+      schema: {
+        ...this.schema,
+
+        request: this.serialized.schema.request,
+        response: this.serialized.schema.response,
+      },
+    };
+  }
+
+  static build<TContext extends IExpectationSchemaContext>(configuration: Expectation<TContext>['configuration']) {
+    return new Expectation(configuration);
+  }
+}

package/src/expectations/models/index.ts

@@ -0,0 +1,3 @@
+export * from './expectation';
+export * from './operator';
+export * from './storage';

package/src/expectations/models/operator.ts

@@ -0,0 +1,89 @@
+import { Faker, ru, en, en_GB } from '@faker-js/faker';
+import dayjs from 'dayjs';
+import _ from 'lodash';
+import * as rxjs from 'rxjs';
+
+import { Constructable, TFunction } from '../../../types';
+import { metaStorage } from '../../meta';
+import { Logger } from '../../logger';
+import {
+  IExpectationSchemaContext,
+  IExpectationExecMode,
+  IExpectationExecUtils,
+  IExpectationOperatorsSchema,
+  TExpectationMetaTag,
+  TExpectationOperators,
+} from '../types';
+
+const logger = Logger.build('Expectations.Models.Operator');
+
+export type TExpectationOperatorConstructor<TContext extends IExpectationSchemaContext> =
+  Constructable<ExpectationOperator<TContext, any>, ConstructorParameters<typeof ExpectationOperator>>
+
+export abstract class ExpectationOperator<TContext extends IExpectationSchemaContext, TSchema> {
+  public TContext!: TContext;
+  public TSchema!: TSchema;
+
+  public abstract match(context: TContext): boolean;
+  public abstract manipulate<T extends TContext>(context: T): T;
+
+  public abstract get tags(): TExpectationMetaTag[];
+
+  constructor(public operators: TExpectationOperators, public command: TSchema) {}
+
+  protected compileExecHandler(raw: TFunction<any, any[]> | string, provide: ('payload' | 'utils')[]) {
+    const parameters: string[] = [];
+
+    if (provide.includes('payload')) {
+      parameters.push('payload');
+    }
+    if (provide.includes('utils')) {
+      parameters.push('{ context, mode, meta, T, _, d, faker }');
+    }
+
+    const handler = typeof raw === 'function' ? raw : Function(parameters.join(', '), `return (() => ${raw})()`);
+
+    return (mode: IExpectationExecMode, context: TContext, ...args: unknown[]) => {
+      const utils = this.compileExecUtils(mode, context);
+      const handled = handler(...args, utils);
+
+      return typeof handled === 'function' ? handled(...args, utils) : handled;
+    }
+  }
+
+  protected extractNestedSchema(schema: IExpectationOperatorsSchema<any, any>): {
+    [K in keyof IExpectationOperatorsSchema]: null | {
+      key: K;
+      nested: IExpectationOperatorsSchema[K];
+    }
+  }[keyof IExpectationOperatorsSchema] {
+    const key = <keyof IExpectationOperatorsSchema | undefined>Object.keys(schema)[0];
+    return key ? { key, nested: <any>schema[key] } : null;
+  }
+
+  private compileExecUtils<T extends TContext>(
+    mode: IExpectationExecMode,
+    context: T
+  ): IExpectationExecUtils<T> {
+    const faker = new Faker({ locale: [ru, en, en_GB] });
+
+    if (context.seed) {
+      faker.seed(context.seed);
+    }
+
+    return {
+      _,
+
+      faker,
+      mode,
+      logger,
+
+      context: <IExpectationExecUtils<T>['context']>context,
+      meta: metaStorage.provide(),
+
+      T: (payload) => <any>payload,
+      rx: rxjs,
+      d: dayjs,
+    }
+  }
+}

package/src/expectations/models/storage.spec.ts

@@ -0,0 +1,70 @@
+import { buildExpectationContext } from '../__utils__';
+import { ExpectationsStorage } from './storage'
+import { Expectation } from './expectation';
+
+describe('Expectations.Models.Storage', () => {
+  it('should not match with empty storage', () => {
+    const storage = new ExpectationsStorage();
+    expect(storage.match(buildExpectationContext())).toBeNull();
+  });
+
+  it('should match with 1 expectation', () => {
+    const storage = new ExpectationsStorage();
+
+    const { expectation } = <{ expectation: Expectation }>storage.register({
+      schema: {
+        request: { $has: { $location: 'path', $value: '/foo/bar/baz' } },
+      },
+    });
+
+    expect(storage.match(buildExpectationContext())?.id).toEqual(expectation.id);
+  });
+
+  it('should not match with 1 expectation', () => {
+    const storage = new ExpectationsStorage();
+
+    storage.register({
+      schema: {
+        request: { $has: { $location: 'path', $value: '/foo' } },
+      },
+    });
+
+    expect(storage.match(buildExpectationContext())).toBeNull();
+  });
+
+  it('should match with 2 expectations', () => {
+    const storage = new ExpectationsStorage();
+
+    storage.register({
+      schema: {
+        request: { $has: { $location: 'path', $value: '/foo/bar' } },
+      },
+    });
+
+    const { expectation } = <{ expectation: Expectation }>storage.register({
+      schema: {
+        request: { $has: { $location: 'method', $valueAnyOf: ['GET', 'POST'] } },
+      },
+    });
+
+    expect(storage.match(buildExpectationContext())?.id).toEqual(expectation.id);
+  });
+
+  it('should not match with 2 expectations', () => {
+    const storage = new ExpectationsStorage();
+
+    storage.register({
+      schema: {
+        request: { $has: { $location: 'path', $value: '/foo/bar' } },
+      },
+    });
+
+    storage.register({
+      schema: {
+        request: { $has: { $location: 'method', $valueAnyOf: ['GET'] } },
+      },
+    });
+
+    expect(storage.match(buildExpectationContext())).toBeNull();
+  });
+});

package/src/expectations/models/storage.ts

@@ -0,0 +1,42 @@
+import { ValueError } from '@n1k1t/typebox/errors';
+
+import { IExpectationSchemaContext } from '../types';
+import { Expectation } from './expectation';
+import { Logger } from '../../logger';
+
+export type TExpectationsStorageRegisterationResult =
+  | { status: 'REGISTERED', expectation: Expectation<any> }
+  | { status: 'ERROR', reasons: ValueError[] };
+
+const logger = Logger.build('Expectations.Storage');
+
+export class ExpectationsStorage extends Map<string, Expectation> {
+  public register(configuration: Expectation['configuration']): TExpectationsStorageRegisterationResult {
+    const expectation = Expectation.build<any>(configuration);
+    const errors = expectation.validate();
+
+    if (errors.length) {
+      return { status: 'ERROR', reasons: errors }
+    }
+
+    logger.info(`Expectation [${expectation.name}] has registered in group [${expectation.group}]`);
+    this.set(expectation.id, expectation);
+
+    return { status: 'REGISTERED', expectation };
+  }
+
+  public match(context: IExpectationSchemaContext): Expectation<any> | null {
+    for (const expectation of this.values()) {
+      if (!expectation.isEnabled) {
+        continue;
+      }
+
+      const hasSameTransport = expectation.transports?.includes(context.transport) ?? true;
+      if (hasSameTransport && expectation.request.match(context)) {
+        return expectation;
+      }
+    }
+
+    return null;
+  }
+}

package/src/expectations/operators/and.operator.spec.ts

@@ -0,0 +1,59 @@
+import { buildExpectationContext } from '../__utils__';
+import * as operators from './index';
+
+describe('Expectations.Operators.And', () => {
+  describe('matching', () => {
+    it('should match by schema with one valid condition', () => {
+      const operator = new operators.$and(operators, [
+        { $has: { $location: 'incoming.query', $path: 'foo', $value: 1 } },
+      ]);
+
+      expect(operator.match(buildExpectationContext())).toBeTruthy();
+    });
+
+    it('should match by schema with two valid conditions', () => {
+      const operator = new operators.$and(operators, [
+        { $has: { $location: 'incoming.query', $path: 'foo', $value: 1 } },
+        { $has: { $location: 'incoming.query', $path: 'bar.baz', $value: null } },
+      ]);
+
+      expect(operator.match(buildExpectationContext())).toBeTruthy();
+    });
+
+    it('should match by schema with zero conditions', () => {
+      expect(new operators.$and(operators, []).match(buildExpectationContext())).toBeTruthy();
+    });
+
+    it('should match by schema with one valid and one invalid condition', () => {
+      const operator = new operators.$and(operators, [
+        { $has: { $location: 'incoming.query', $path: 'foo', $value: 1 } },
+        { $has: { $location: 'incoming.query', $path: 'bar.baz', $value: 1 } },
+      ]);
+
+      expect(operator.match(buildExpectationContext())).toBeFalsy();
+    });
+
+    it('should match by schema with two invalid conditions', () => {
+      const operator = new operators.$and(operators, [
+        { $has: { $location: 'incoming.query', $path: 'foo', $value: null } },
+        { $has: { $location: 'incoming.query', $path: 'bar.baz', $value: 1 } },
+      ]);
+
+      expect(operator.match(buildExpectationContext())).toBeFalsy();
+    });
+  });
+
+  describe('manipulation', () => {
+    it('should manipulate by schema with two conditions', () => {
+      const operator = new operators.$and<any>(operators, [
+        { $set: { $location: 'incoming.headers', $path: 'content-length', $value: 100 } },
+        { $set: { $location: 'incoming.query', $path: 'bar.baz', $value: { test: true } } },
+      ]);
+
+      const context = operator.manipulate<any>(buildExpectationContext());
+
+      expect(context.incoming.headers?.['content-length']).toEqual(100);
+      expect(context.incoming.query?.bar?.baz?.test).toBeTruthy();
+    });
+  });
+});

package/src/expectations/operators/and.operator.ts

@@ -0,0 +1,37 @@
+import { ExpectationOperator, TExpectationOperatorConstructor } from '../models/operator';
+import {
+  IExpectationSchemaContext,
+  IExpectationOperatorsSchema,
+  TExpectationMetaTag,
+  TExpectationOperatorLocation,
+} from '../types';
+
+export default class AndExpectationOperator<
+  TContext extends IExpectationSchemaContext,
+  TLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
+  TValue = void
+> extends ExpectationOperator<
+  TContext,
+  IExpectationOperatorsSchema<TContext, TLocation, TValue>[]
+> {
+  public compiled = this.command
+    .map((schema) => this.extractNestedSchema(schema)!)
+    .filter(Boolean)
+    .map((extracted) => {
+      const Operator = <TExpectationOperatorConstructor<TContext>>this.operators[extracted.key];
+      return new Operator(this.operators, extracted.nested);
+    });
+
+  public get tags(): TExpectationMetaTag[] {
+    return this.compiled.reduce<TExpectationMetaTag[]>((acc, operator) => acc.concat(operator.tags), []);
+  }
+
+  public match(context: TContext): boolean {
+    return this.compiled.every((operator) => operator.match(context));
+  }
+
+  public manipulate<T extends TContext>(context: T): T {
+    this.compiled.forEach((operator) => operator.manipulate(context));
+    return context;
+  }
+}

package/src/expectations/operators/exec.operator.spec.ts

@@ -0,0 +1,47 @@
+import { buildExpectationContext } from '../__utils__';
+import { IExpectationSchemaContext } from '../types';
+
+import * as operators from './index';
+
+describe('Expectations.Operators.Exec', () => {
+  it('should exec by inline serialized command with utils', () => {
+    const operator = new operators.$exec(operators, '_.set(context, "incoming.query.test", "foo")');
+    const context = operator.manipulate<any>(buildExpectationContext());
+
+    expect(context.incoming.query.test).toEqual('foo');
+  });
+
+  it('should exec by multiline serialized command', () => {
+    const operator = new operators.$exec(operators, `{
+      context.incoming.data.foo.push({ test: 1 });
+      context.incoming.data.foo.push({ test: 2 });
+    }`);
+
+    const context = operator.manipulate<any>(buildExpectationContext());
+
+    expect(context.incoming.data.foo[2].test).toEqual(1);
+    expect(context.incoming.data.foo[3].test).toEqual(2);
+  });
+
+  it('should exec by function', () => {
+    const operator = new operators.$exec<IExpectationSchemaContext<{
+      incoming: { query: { test: number } }
+    }>>(operators, ({ context }) => {
+      context.incoming.query.test = 100;
+    });
+
+    const context = operator.manipulate<any>(buildExpectationContext());
+    expect(context.incoming.query.test).toEqual(100);
+  });
+
+  it('should exec by function with utils', () => {
+    const operator = new operators.$exec<IExpectationSchemaContext<{
+      incoming: { query: { test: number } }
+    }>>(operators, ({ context, _ }) => {
+      _.set(context, 'incoming.query.test', 100);
+    });
+
+    const context = operator.manipulate<any>(buildExpectationContext());
+    expect(context.incoming.query.test).toEqual(100);
+  });
+});

package/src/expectations/operators/exec.operator.ts

@@ -0,0 +1,25 @@
+import _ from 'lodash';
+
+import { IExpectationExecUtils, IExpectationSchemaContext, TExpectationMetaTag } from '../types';
+import { ExpectationOperator } from '../models/operator';
+import { TFunction } from '../../../types';
+
+export default class ExecExpectationOperator<
+  TContext extends IExpectationSchemaContext,
+> extends ExpectationOperator<TContext, string | TFunction<unknown, [IExpectationExecUtils<TContext>]>> {
+  public compiled = this.compileExecHandler(this.command, ['utils']);
+
+  public get tags(): TExpectationMetaTag[] {
+    return [];
+  }
+
+  public match(context: TContext): boolean {
+    const result = this.compiled('match', context);
+    return typeof result === 'boolean' ? result : true;
+  }
+
+  public manipulate<T extends TContext>(context: T): T {
+    this.compiled('manipulate', context);
+    return context;
+  }
+}