@n1k1t/mock-server 0.1.61 → 0.1.62

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

@@ -1,230 +0,0 @@
-import minimatch from 'minimatch';
-import _ from 'lodash';
-
-import { checkIsLocationInContext, extractContextByLocation, extractWithJsonPathSafe } from '../utils';
-import { PartialDeep, TFunction } from '../../../types';
-import { ExpectationOperator } from '../models/operator';
-import {
-  CompileExpectationOperatorValue,
-  CompileExpectationOperatorValueWithPredicate,
-  IExpectationSchemaContext,
-  IExpectationExecUtils,
-  TExpectationMetaTag,
-  TExpectationOperatorLocation,
-} from '../types';
-
-export default class HasExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
-  TValue = void
-> extends ExpectationOperator<
-  TContext,
-  {
-    [K in TLocation]: {
-      $location: K;
-
-      $path?: string;
-      $jsonPath?: string;
-
-      $regExp?: RegExp;
-      $regExpAnyOf?: RegExp[];
-
-      $match?: NonNullable<CompileExpectationOperatorValue<TContext, K, TValue>> extends object
-        ? PartialDeep<NonNullable<CompileExpectationOperatorValue<TContext, K, TValue>>>
-        : string;
-
-      $matchAnyOf?: (
-        NonNullable<CompileExpectationOperatorValue<TContext, K, TValue>> extends object
-          ? PartialDeep<NonNullable<CompileExpectationOperatorValue<TContext, K, TValue>>>
-          : string
-      )[];
-
-      $value?: CompileExpectationOperatorValueWithPredicate<TContext, K, TValue>;
-      $valueAnyOf?: CompileExpectationOperatorValueWithPredicate<TContext, K, TValue>[];
-
-      $exec?: string | TFunction<boolean, [
-        CompileExpectationOperatorValue<TContext, K, TValue>,
-        IExpectationExecUtils<TContext>
-      ]>;
-    };
-  }[TLocation]
-> {
-  public compiled = {
-    ...(this.command.$regExp && {
-      regExp: new RegExp(this.command.$regExp.source, this.command.$regExp.flags)
-    }),
-
-    ...(this.command.$regExpAnyOf && {
-      regExpAnyOf: this.command.$regExpAnyOf.map((exp) => new RegExp(exp.source, exp.flags)),
-    }),
-
-    ...(this.command.$exec && {
-      exec: this.compileExecHandler(this.command.$exec, ['payload', 'utils']),
-    }),
-  };
-
-  public get tags(): TExpectationMetaTag[] {
-    if (this.command.$location !== 'path' && this.command.$location !== 'method') {
-      return [];
-    }
-
-    if (this.command.$value) {
-      return [{ location: this.command.$location, value: String(this.command.$value) }];
-    }
-    if (this.command.$valueAnyOf) {
-      return this.command.$valueAnyOf.map((value) => (<TExpectationMetaTag>{
-        location: this.command.$location,
-        value: String(value)
-      }));
-    }
-
-    if (this.command.$match) {
-      return [{ location: this.command.$location, value: String(this.command.$match) }];
-    }
-    if (this.command.$matchAnyOf) {
-      return this.command.$matchAnyOf.map((value) => (<TExpectationMetaTag>{
-        location: this.command.$location,
-        value: String(value)
-      }));
-    }
-
-    if (this.command.$regExp) {
-      return [{ location: this.command.$location, value: this.command.$regExp.source }];
-    }
-    if (this.command.$regExpAnyOf) {
-      return this.command.$regExpAnyOf.map((value) => (<TExpectationMetaTag>{
-        location: this.command.$location,
-        value: value.source,
-      }));
-    }
-
-    return [];
-  }
-
-  public match(context: TContext): boolean {
-    if (!checkIsLocationInContext(this.command.$location, context)) {
-      return false;
-    }
-
-    const payload = extractContextByLocation(this.command.$location, context);
-    if (!payload) {
-      return false;
-    }
-
-    switch(payload.type) {
-      case 'string': {
-        if (this.command.$value !== undefined) {
-          return payload.value === this.command.$value;
-        }
-        if (this.command.$valueAnyOf) {
-          return this.command.$valueAnyOf.some((value) => payload.value === value);
-        }
-
-        if (this.compiled.regExp) {
-          return this.compiled.regExp.test(payload.value ?? '');
-        }
-        if (this.compiled.regExpAnyOf) {
-          return this.compiled.regExpAnyOf.some((regExp) => regExp.test(payload.value ?? ''));
-        }
-
-        if (typeof this.command.$match === 'string') {
-          return minimatch(payload.value ?? '', this.command.$match);
-        }
-        if (this.command.$matchAnyOf) {
-          return this.command.$matchAnyOf.some((pattern) => minimatch(payload.value ?? '', String(pattern)));
-        }
-
-        if (this.compiled.exec) {
-          return this.compiled.exec('match', context, payload.value) === true;
-        }
-
-        return false;
-      }
-
-      case 'number': {
-        if (this.command.$value !== undefined) {
-          return payload.value === this.command.$value;
-        }
-        if (this.command.$valueAnyOf) {
-          return this.command.$valueAnyOf.some((value) => payload.value === value);
-        }
-
-        if (typeof this.command.$match === 'string') {
-          return minimatch(String(payload.value), this.command.$match);
-        }
-        if (this.command.$matchAnyOf) {
-          const value = String(payload.value);
-          return this.command.$matchAnyOf.some((pattern) => minimatch(value, String(pattern)));
-        }
-
-        if (this.compiled.exec) {
-          return this.compiled.exec('match', context, payload.value) === true;
-        }
-
-        return false;
-      }
-
-      case 'buffer': {
-        if (this.compiled.exec) {
-          return this.compiled.exec('match', context, payload.value) === true;
-        }
-
-        return false;
-      }
-
-      case 'object': {
-        if (this.command.$path && !_.has(payload.value, this.command.$path)) {
-          return false;
-        }
-
-        const values = (
-          this.command.$path
-            ? [_.get(payload.value, this.command.$path)]
-            : (this.command.$jsonPath && _.isObject(payload.value))
-            ? extractWithJsonPathSafe({ path: this.command.$jsonPath, json: payload.value }).results?.map(({ value }) => value)
-            : [payload.value]
-        ) ?? [];
-
-        if (this.command.$value !== undefined) {
-          return values.every((value) => _.isEqual(this.command.$value, value));
-        }
-        if (this.command.$valueAnyOf) {
-          return values.every((source) => this.command.$valueAnyOf!.some((target) => _.isEqual(source, target)));
-        }
-
-        if (this.compiled.regExp) {
-          return values.every((value) => this.compiled.regExp!.test(String(value)));
-        }
-        if (this.compiled.regExpAnyOf) {
-          return values.every((value) => this.compiled.regExpAnyOf!.some((exp) => exp.test(String(value))));
-        }
-
-        if (typeof this.command.$match === 'string') {
-          return values.every((value) => minimatch(String(value), <string>this.command.$match));
-        }
-        if (typeof this.command.$match === 'object') {
-          return values.every((value) => _.isMatch(value, <object>this.command.$match));
-        }
-
-        if (typeof this.command.$matchAnyOf?.[0] === 'string') {
-          return values.every((value) => this.command.$matchAnyOf!.some((pattern) => minimatch(String(value), String(pattern))));
-        }
-        if (typeof this.command.$matchAnyOf?.[0] === 'object') {
-          return values.every((value) => this.command.$matchAnyOf!.some((target) => _.isMatch(value, <object>target)));
-        }
-
-        if (this.compiled.exec) {
-          return values.every((value) => this.compiled.exec!('match', context, value) === true);
-        }
-
-        return values.length !== 0;
-      }
-
-      default: return false;
-    }
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    return context;
-  }
-}

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

@@ -1,116 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import * as operators from './index';
-
-describe('Expectations.Operators.If', () => {
-  describe('matching', () => {
-    it('should match by schema with simple valid condition and valid [then] target branch', () => {
-      const operator = new operators.$if(operators, {
-        $condition: { $has: { $location: 'path', $regExp: /^\/foo/ } },
-        $then: { $has: { $location: 'method', $value: 'POST' } },
-      });
-
-      expect(operator.match(buildExpectationContext())).toBeTruthy();
-    });
-
-    it('should match by schema with simple invalid condition and valid [then] target branch', () => {
-      const operator = new operators.$if(operators, {
-        $condition: { $has: { $location: 'path', $regExp: /^\/bar/ } },
-        $then: { $has: { $location: 'method', $value: 'POST' } },
-      });
-
-      expect(operator.match(buildExpectationContext())).toBeFalsy();
-    });
-
-    it('should match by schema with simple valid condition and invalid [then] target branch', () => {
-      const operator = new operators.$if(operators, {
-        $condition: { $has: { $location: 'path', $regExp: /^\/foo/ } },
-        $then: { $has: { $location: 'method', $value: 'GET' } },
-      });
-
-      expect(operator.match(buildExpectationContext())).toBeFalsy();
-    });
-
-    it('should match by schema with simple invalid condition and valid [else] target branch', () => {
-      const operator = new operators.$if(operators, {
-        $condition: { $has: { $location: 'path', $regExp: /^\/bar/ } },
-        $else: { $has: { $location: 'method', $value: 'POST' } },
-      });
-
-      expect(operator.match(buildExpectationContext())).toBeTruthy();
-    });
-
-    it('should match by schema with simple invalid condition and invalid [else] target branch', () => {
-      const operator = new operators.$if(operators, {
-        $condition: { $has: { $location: 'path', $regExp: /^\/bar/ } },
-        $else: { $has: { $location: 'method', $value: 'GET' } },
-      });
-
-      expect(operator.match(buildExpectationContext())).toBeFalsy();
-    });
-
-    it('should match by schema with complex valid condition', () => {
-      const operator = new operators.$if(operators, {
-        $condition: {
-          $or: [
-            { $if: { $condition: {} } },
-            { $has: { $location: 'path', $regExp: /^\/bar/ } },
-            { $has: { $location: 'method', $value: 'POST'} },
-          ],
-        },
-
-        $then: {
-          $or: [
-            { $has: { $location: 'incoming.data', $path: 'foo.1.test.0', $regExp: /^2/ } },
-            { $has: { $location: 'incoming.data', $path: 'foo.1.baz.0', $regExp: /^2/ } },
-          ],
-        },
-      });
-
-      expect(operator.match(buildExpectationContext())).toBeTruthy();
-    });
-
-    it('should match by schema with complex invalid condition', () => {
-      const operator = new operators.$if(operators, {
-        $condition: {
-          $or: [
-            { $if: { $condition: {} } },
-            { $has: { $location: 'path', $regExp: /^\/bar/ } },
-            { $has: { $location: 'method', $value: 'GET'} },
-          ],
-        },
-
-        $else: {
-          $has: { $location: 'incoming.data', $path: 'foo.1.test.0', $regExp: /^2/ },
-        },
-      });
-
-      expect(operator.match(buildExpectationContext())).toBeFalsy();
-    });
-  });
-
-  describe('manipulation', () => {
-    it('should manipulate by schema with conplex condition', () => {
-      const operator = new operators.$if<any>(operators, {
-        $condition: {
-          $or: [
-            { $if: { $condition: {} } },
-            { $has: { $location: 'path', $regExp: /^\/bar/ } },
-            { $has: { $location: 'method', $value: 'POST'} },
-          ],
-        },
-
-        $then: {
-          $and: [
-            { $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/if.operator.ts

@@ -1,77 +0,0 @@
-import { ExpectationOperator, TExpectationOperatorConstructor } from '../models/operator';
-import {
-  IExpectationSchemaContext,
-  IExpectationOperatorsSchema,
-  TExpectationMetaTag,
-  TExpectationOperatorLocation,
-} from '../types';
-
-export default class IfExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
-  TValue = void
-> extends ExpectationOperator<
-  TContext,
-  {
-    $condition: Pick<IExpectationOperatorsSchema<TContext, TLocation, TValue>, '$and' | '$exec' | '$has' | '$or' | '$not'>;
-
-    $then?: IExpectationOperatorsSchema<TContext, TLocation, TValue>;
-    $else?: IExpectationOperatorsSchema<TContext, TLocation, TValue>;
-  }
-> {
-  public compiled = {
-    condition: (() => {
-      const extracted = this.extractNestedSchema(this.command.$condition);
-      if (!extracted) {
-        return null;
-      }
-
-      const Operator = <TExpectationOperatorConstructor<TContext>>this.operators[extracted.key];
-      return new Operator(this.operators, extracted.nested);
-    })(),
-
-    ...(this.command.$then && {
-      then: (() => {
-        const extracted = this.extractNestedSchema(this.command.$then);
-        if (!extracted) {
-          return null;
-        }
-
-        const Operator = <TExpectationOperatorConstructor<TContext>>this.operators[extracted.key];
-        return new Operator(this.operators, extracted.nested);
-      })(),
-    }),
-
-    ...(this.command.$else && {
-      else: (() => {
-        const extracted = this.extractNestedSchema(this.command.$else);
-        if (!extracted) {
-          return null;
-        }
-
-        const Operator = <TExpectationOperatorConstructor<TContext>>this.operators[extracted.key];
-        return new Operator(this.operators, extracted.nested);
-      })(),
-    }),
-  };
-
-  public get tags(): TExpectationMetaTag[] {
-    return [
-      ...(this.compiled.condition?.tags ?? []),
-      ...(this.compiled.then?.tags ?? []),
-      ...(this.compiled.else?.tags ?? []),
-    ];
-  }
-
-  public match(context: TContext): boolean {
-    const result = this.compiled.condition?.match(context) ?? false;
-    return (result ? this.compiled.then?.match(context) : this.compiled.else?.match(context)) ?? false;
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    const result = this.compiled.condition?.match(context) ?? false;
-
-    result ? this.compiled.then?.manipulate(context) : this.compiled.else?.manipulate(context);
-    return context;
-  }
-}

package/src/expectations/operators/index.ts

@@ -1,11 +0,0 @@
-export { default as $and } from './and.operator';
-export { default as $or } from './or.operator';
-export { default as $not } from './not.operator';
-export { default as $if } from './if.operator';
-export { default as $has } from './has.operator';
-export { default as $set } from './set.operator';
-export { default as $merge } from './merge.operator';
-export { default as $remove } from './remove.operator';
-export { default as $exec } from './exec.operator';
-export { default as $switch } from './switch.operator';
-export { default as root } from './root.operator';

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

@@ -1,48 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import * as operators from './index';
-
-describe('Expectations.Operators.Merge', () => {
-  it('should handle schema with non object payload', () => {
-    const operator = new operators.$merge<any, any>(operators, {
-      $location: 'path',
-      $value: true,
-    });
-
-    const context = operator.manipulate({ incoming: { path: 'test' } });
-    expect(context.incoming.path).toEqual('test');
-  });
-
-  it('should manipulate by schema', () => {
-    const operator = new operators.$merge(operators, {
-      $location: 'incoming.query',
-      $value: { test: true },
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.test).toBeTruthy();
-  });
-
-  it('should manipulate by schema using path', () => {
-    const operator = new operators.$merge(operators, {
-      $location: 'incoming.query',
-      $path: 'bar',
-      $value: { test: true },
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.bar.test).toBeTruthy();
-  });
-
-  it('should manipulate by schema using jsonPath', () => {
-    const operator = new operators.$merge(operators, {
-      $location: 'incoming.data',
-      $jsonPath: '$.foo[*]',
-      $value: { test: true },
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-
-    expect(context.incoming.data.foo[0].test).toBeTruthy();
-    expect(context.incoming.data.foo[1].test).toBeTruthy();
-  });
-});

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

@@ -1,97 +0,0 @@
-import merge from 'deepmerge';
-import _ from 'lodash';
-
-import { extractContextByLocation, extractWithJsonPathSafe } from '../utils';
-import { ExpectationOperator } from '../models/operator';
-import { TFunction } from '../../../types';
-import {
-  CompileExpectationOperatorValue,
-  CompileExpectationOperatorValueWithPredicate,
-  IExpectationSchemaContext,
-  IExpectationExecUtils,
-  TExpectationMetaTag,
-  TExpectationOperatorObjectLocation,
-} from '../types';
-
-export default class MergeExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorObjectLocation = TExpectationOperatorObjectLocation,
-  TValue = void
-> extends ExpectationOperator<
-  TContext,
-  {
-    [K in TLocation]: {
-      $location: K;
-
-      $value?: CompileExpectationOperatorValueWithPredicate<TContext, K, TValue>;
-      $exec?: string | TFunction<CompileExpectationOperatorValueWithPredicate<TContext, K, TValue>, [
-        CompileExpectationOperatorValue<TContext, K, TValue>,
-        IExpectationExecUtils<TContext>
-      ]>;
-
-      $path?: string;
-      $jsonPath?: string;
-    }
-  }[TLocation]
-> {
-  public compiled = {
-    ...(this.command.$exec && {
-      exec: this.compileExecHandler(this.command.$exec, ['payload', 'utils']),
-    }),
-  };
-
-  public get tags(): TExpectationMetaTag[] {
-    return [];
-  }
-
-  public match(): boolean {
-    return true;
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    const payload = extractContextByLocation(this.command.$location, context);
-    if (payload?.type !== 'object' || !_.isObject(payload.value)) {
-      return context;
-    }
-
-    if (this.command.$path) {
-      const value = _.get(payload.value, this.command.$path);
-
-      _.set(
-        payload.parent,
-        `${payload.key}.${this.command.$path}`,
-        this.compiled.exec
-          ? merge(value, this.compiled.exec('manipulate', context, value), { arrayMerge: (target, source) => source })
-          : merge(value, <object>this.command.$value ?? {}, { arrayMerge: (target, source) => source })
-      );
-
-      return context;
-    }
-
-    if (this.command.$jsonPath) {
-      extractWithJsonPathSafe({ path: this.command.$jsonPath, json: payload.value }).results?.forEach((segment) => {
-        const value = _.get(segment.parent, segment.parentProperty);
-
-        _.set(
-          <object>payload.value,
-          segment.pointer.substring(1).replace(/\//g, '.'),
-          this.compiled.exec
-            ? merge(value, this.compiled.exec('manipulate', context, value))
-            : merge(value, this.command.$value ?? {})
-        )
-      });
-
-      return context;
-    }
-
-    _.set(
-      payload.parent,
-      payload.key,
-      this.compiled.exec
-        ? merge(payload.value, this.compiled.exec('manipulate', context, payload.value))
-        : merge(payload.value, this.command.$value ?? {})
-    );
-
-    return context;
-  }
-}

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

@@ -1,12 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import * as operators from './index';
-
-describe('Expectations.Operators.Not', () => {
-  it('should match by schema', () => {
-    const operator = new operators.$not(operators, {
-      $has: { $location: 'incoming.query', $path: 'foo', $value: 1 },
-    });
-
-    expect(operator.match(buildExpectationContext())).toBeFalsy();
-  });
-});

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

@@ -1,38 +0,0 @@
-import { ExpectationOperator, TExpectationOperatorConstructor } from '../models/operator';
-import {
-  IExpectationSchemaContext,
-  IExpectationOperatorsSchema,
-  TExpectationMetaTag,
-  TExpectationOperatorLocation,
-} from '../types';
-
-export default class NotExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
-  TValue = void
-> extends ExpectationOperator<
-  TContext,
-  IExpectationOperatorsSchema<TContext, TLocation, TValue>
-> {
-  public compiled = (() => {
-    const extracted = this.extractNestedSchema(this.command);
-    if (!extracted) {
-      return null;
-    }
-
-    const Operator = <TExpectationOperatorConstructor<TContext>>this.operators[extracted.key];
-    return new Operator(this.operators, extracted.nested);
-  })();
-
-  public get tags(): TExpectationMetaTag[] {
-    return [];
-  }
-
-  public match(context: TContext): boolean {
-    return this.compiled ? !this.compiled.match(context) : false;
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    return context;
-  }
-}

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

@@ -1,60 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import * as operators from './index';
-
-describe('Expectations.Operators.Or', () => {
-  describe('matching', () => {
-    it('should match by schema with one valid condition', () => {
-      const operator = new operators.$or(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.$or(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', () => {
-      const operator = new operators.$or(operators, []);
-      expect(operator.match(buildExpectationContext())).toBeFalsy();
-    });
-
-    it('should match by schema with one valid and one invalid condition', () => {
-      const operator = new operators.$or(operators, [
-        { $has: { $location: 'incoming.query', $path: 'foo', $value: 1 } },
-        { $has: { $location: 'incoming.query', $path: 'bar.baz', $value: 1 } },
-      ]);
-
-      expect(operator.match(buildExpectationContext())).toBeTruthy();
-    });
-
-    it('should match by schema with two invalid conditions', () => {
-      const operator = new operators.$or(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.$or<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();
-    });
-  });
-});