@n1k1t/mock-server 0.1.59 → 0.1.61

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

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

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

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

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

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

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

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

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

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