@n1k1t/mock-server 0.1.61 → 0.1.62

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

@@ -1,37 +0,0 @@
-import { ExpectationOperator, TExpectationOperatorConstructor } from '../models/operator';
-import {
-  IExpectationSchemaContext,
-  IExpectationOperatorsSchema,
-  TExpectationMetaTag,
-  TExpectationOperatorLocation,
-} from '../types';
-
-export default class OrExpectationOperator<
-  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.some((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/remove.operator.spec.ts

@@ -1,40 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import * as operators from './index';
-
-describe('Expectations.Operators.Remove', () => {
-  it('should handle schema with non object payload', () => {
-    const operator = new operators.$remove<any>(operators, { $location: 'path' });
-    const context = operator.manipulate({ incoming: { path: 'foo' } });
-
-    expect(context.incoming.path).toEqual('foo');
-  });
-
-  it('should handle schema without targeting properties', () => {
-    const operator = new operators.$remove<any>(operators, { $location: 'incoming.headers' });
-    const context = operator.manipulate({ headers: { 'content-type': 'unknown' } });
-
-    expect(context.headers['content-type']).toEqual('unknown');
-  });
-
-  it('should manipulate by schema using path', () => {
-    const operator = new operators.$remove(operators, {
-      $location: 'incoming.query',
-      $path: 'foo',
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.foo).toBeUndefined();
-  });
-
-  it('should manipulate by schema using jsonPath', () => {
-    const operator = new operators.$remove(operators, {
-      $location: 'incoming.data',
-      $jsonPath: '$.foo[*].bar,baz',
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-
-    expect(context.incoming.data.foo[0].bar).toBeUndefined();
-    expect(context.incoming.data.foo[1].baz).toBeUndefined();
-  });
-});

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

@@ -1,50 +0,0 @@
-import _ from 'lodash';
-
-import { IExpectationSchemaContext, TExpectationMetaTag, TExpectationOperatorLocation } from '../types';
-import { extractContextByLocation, extractWithJsonPathSafe } from '../utils';
-import { ExpectationOperator } from '../models/operator';
-
-export default class RemoveExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation
-> extends ExpectationOperator<
-  TContext,
-  {
-    [K in TLocation]: {
-      $location: K;
-
-      $path?: string;
-      $jsonPath?: string;
-    }
-  }[TLocation]
-> {
-  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') {
-      return context;
-    }
-
-    if (this.command.$path) {
-      _.unset(payload.value, this.command.$path);
-      return context;
-    }
-
-    if (this.command.$jsonPath && _.isObject(payload.value)) {
-      extractWithJsonPathSafe({ path: this.command.$jsonPath, json: payload.value })
-        .results?.forEach((segment) => _.unset(segment.parent, segment.parentProperty));
-
-      return context;
-    }
-
-    _.unset(payload.parent, payload.key);
-    return context;
-  }
-}

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

@@ -1,26 +0,0 @@
-import RootExpectationOperator from './root.operator';
-
-// Test generated using Keploy
-test('should return false when compiled is null', () => {
-  const mockOperators: any = {};
-  const operator = new RootExpectationOperator(<any>{}, mockOperators);
-  operator.compiled = null;  // Set compiled to null
-  expect(operator.match(<any>{})).toBe(false);
-});
-
-// Test generated using Keploy
-test('should return original context when compiled is null', () => {
-  const mockOperators: any = {};
-  const operator = new RootExpectationOperator(<any>{}, mockOperators);
-  operator.compiled = null;  // Set compiled to null
-  const context = { data: 'test' };
-  expect(operator.manipulate(<any>context)).toBe(context);
-});
-
-// Test generated using Keploy
-test('tags should return empty array if compiled is null', () => {
-  const mockOperators: any = {};
-  const operator = new RootExpectationOperator(<any>{}, mockOperators);
-  operator.compiled = null;  // Set compiled to null
-  expect(operator.tags).toEqual([]);
-});

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

@@ -1,51 +0,0 @@
-import { ExpectationOperator, TExpectationOperatorConstructor } from '../models/operator';
-import { Logger } from '../../logger';
-import {
-  IExpectationSchemaContext,
-  IExpectationOperatorsSchema,
-  TExpectationMetaTag,
-  TExpectationOperatorLocation,
-} from '../types';
-
-const logger = Logger.build('Expectations.Operators.Root');
-
-export default class RootExpectationOperator<
-  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 this.compiled?.tags ?? [];
-  }
-
-  public match(context: TContext): boolean {
-    try {
-      return this.compiled?.match(context) ?? false;
-    } catch(error: any) {
-      logger.error('Got error on expectation matching', error?.stack ?? error);
-      return false;
-    }
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    try {
-      return this.compiled?.manipulate(context) ?? context;
-    } catch(error: any) {
-      logger.error('Got error on expectation manipulation', error?.stack ?? error);
-      return context;
-    }
-  }
-}

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

@@ -1,96 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import * as operators from './index';
-
-describe('Expectations.Operators.Set', () => {
-  it('should manipulate by schema in outgoing.status', () => {
-    const operator = new operators.$set(operators, {
-      $location: 'outgoing.status',
-      $value: 404,
-    });
-
-    const context = operator.manipulate(buildExpectationContext());
-    expect(context.outgoing?.status).toEqual(404);
-  });
-
-  it('should manipulate by schema in incoming.headers', () => {
-    const operator = new operators.$set(operators, {
-      $location: 'incoming.headers',
-      $path: 'a.b.c.d',
-      $value: 'test',
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.headers.a.b.c.d).toEqual('test');
-  });
-
-  it('should manipulate by schema in incoming.data using jsonPath', () => {
-    const operator = new operators.$set(operators, {
-      $location: 'incoming.data',
-      $jsonPath: '$.foo[*].bar,baz',
-      $value: { test: true },
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-
-    expect(context.incoming.data.foo[0].bar.test).toBeTruthy();
-    expect(context.incoming.data.foo[1].baz.test).toBeTruthy();
-  });
-
-  it('should manipulate by schema in incoming.query', () => {
-    const operator = new operators.$set(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 and exec as function', () => {
-    const operator = new operators.$set<any>(operators, {
-      $location: 'incoming.query',
-      $path: 'foo',
-
-      $exec: (payload) => payload + 1,
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.foo).toEqual(2);
-  });
-
-  it('should manipulate by schema using exec as function', () => {
-    const operator = new operators.$set<any>(operators, {
-      $location: 'incoming.query',
-      $path: 'test',
-
-      $exec: () => true,
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.test).toBeTruthy();
-  });
-
-  it('should manipulate by schema using exec as string', () => {
-    const operator = new operators.$set(operators, {
-      $location: 'incoming.query',
-      $path: 'test',
-
-      $exec: 'true',
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.test).toBeTruthy();
-  });
-
-  it('should manipulate by schema using exec as string with utils', () => {
-    const operator = new operators.$set(operators, {
-      $location: 'incoming.query',
-      $path: 'test',
-
-      $exec: '_.isEqual({}, {})',
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.test).toBeTruthy();
-  });
-});

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

@@ -1,116 +0,0 @@
-import _ from 'lodash';
-
-import { extractContextByLocation, extractWithJsonPathSafe } from '../utils';
-import { ExpectationOperator } from '../models/operator';
-import { TFunction } from '../../../types';
-import {
-  CompileExpectationOperatorValue,
-  CompileExpectationOperatorValueWithPredicate,
-  IExpectationSchemaContext,
-  IExpectationExecUtils,
-  TExpectationMetaTag,
-  TExpectationOperatorLocation,
-} from '../types';
-
-export default class SetExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
-  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[] {
-    if (this.command.$location === 'outgoing.status') {
-      return this.command.$value
-        ? [{ location: 'outgoing.status', value: Number(this.command.$value) }]
-        : [];
-    }
-
-    if (this.command.$location === 'error') {
-      return this.command.$value
-        ? [{ location: 'error', value: String(this.command.$value) }]
-        : [];
-    }
-
-    return [];
-  }
-
-  public match(): boolean {
-    return true;
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    const payload = extractContextByLocation(this.command.$location, context);
-    if (!payload) {
-      return context;
-    }
-
-    switch(payload.type) {
-      case 'number':
-      case 'buffer':
-      case 'string': {
-        _.set(
-          payload.parent,
-          payload.key,
-          this.compiled.exec ? this.compiled.exec('manipulate', context, payload.value) : this.command.$value
-        );
-
-        return context;
-      }
-
-      case 'object': {
-        if (this.command.$path) {
-          _.set(
-            payload.parent,
-            `${payload.key}.${this.command.$path}`,
-            this.compiled.exec
-              ? this.compiled.exec('manipulate', context, _.get(payload.value, this.command.$path))
-              : this.command.$value
-          );
-
-          return context;
-        }
-
-        if (this.command.$jsonPath && _.isObject(payload.value)) {
-          extractWithJsonPathSafe({ path: this.command.$jsonPath, json: payload.value }).results?.forEach(
-            ({ parent, parentProperty, value }) => this.compiled.exec
-              ? _.set(parent, parentProperty, this.compiled.exec('manipulate', context, value))
-              : _.set(parent, parentProperty, this.command.$value)
-          );
-
-          return context;
-        }
-
-        _.set(
-          payload.parent,
-          payload.key,
-          this.compiled.exec ? this.compiled.exec('manipulate', context, payload.value) : this.command.$value
-        );
-
-        return context;
-      }
-
-      default: return context;
-    }
-  }
-}

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

@@ -1,157 +0,0 @@
-import * as operators from './index';
-
-describe('Expectations.Operators.Switch', () => {
-  describe('matching', () => {
-    it('should match by schema in incoming body using path', () => {
-      const operator = new operators.$switch<any>(operators, {
-        $location: 'incoming.data',
-        $path: 'foo.bar',
-
-        $cases: {
-          'a': { $has: { $location: 'incoming.data', $path: 'baz', $value: 'a' } },
-          'b': { $has: { $location: 'incoming.data', $path: 'baz', $value: 'b' } },
-        },
-
-        $default: { $exec: () => true },
-      });
-
-      expect(operator.match({ incoming: { data: {} } })).toBeTruthy();
-      expect(operator.match({ incoming: { data: { baz: 'a', foo: { bar: 'a' } } } })).toBeTruthy();
-      expect(operator.match({ incoming: { data: { baz: 'b', foo: { bar: 'b' } } } })).toBeTruthy();
-
-      expect(operator.match({ incoming: { data: { foo: { bar: 'a' } } } })).toBeFalsy();
-      expect(operator.match({ incoming: { data: { baz: 'b', foo: { bar: 'a' } } } })).toBeFalsy();
-      expect(operator.match({ incoming: { data: { baz: 'a', foo: { bar: 'b' } } } })).toBeFalsy();
-    });
-
-    it('should match by schema in incoming body using exec', () => {
-      const operator = new operators.$switch<any>(operators, {
-        $location: 'incoming.data',
-        $exec: (payload) => payload?.foo?.bar,
-
-        $cases: {
-          'a': { $has: { $location: 'incoming.data', $path: 'baz', $value: 'a' } },
-          'b': { $has: { $location: 'incoming.data', $path: 'baz', $value: 'b' } },
-        },
-
-        $default: { $exec: () => true },
-      });
-
-      expect(operator.match({ incoming: { data: {} } })).toBeTruthy();
-      expect(operator.match({ incoming: { data: { baz: 'a', foo: { bar: 'a' } } } })).toBeTruthy();
-      expect(operator.match({ incoming: { data: { baz: 'b', foo: { bar: 'b' } } } })).toBeTruthy();
-
-      expect(operator.match({ incoming: { data: { foo: { bar: 'a' } } } })).toBeFalsy();
-      expect(operator.match({ incoming: { data: { baz: 'b', foo: { bar: 'a' } } } })).toBeFalsy();
-      expect(operator.match({ incoming: { data: { baz: 'a', foo: { bar: 'b' } } } })).toBeFalsy();
-    });
-
-    it('should match by schema in incoming body using exec with utils', () => {
-      const operator = new operators.$switch<any>(operators, {
-        $location: 'incoming.data',
-        $exec: (payload, { _ }) => _.get(payload, 'foo.bar'),
-
-        $cases: {
-          'a': { $has: { $location: 'incoming.data', $path: 'baz', $value: 'a' } },
-          'b': { $has: { $location: 'incoming.data', $path: 'baz', $value: 'b' } },
-        },
-
-        $default: { $exec: () => true },
-      });
-
-      expect(operator.match({ incoming: { data: {} } })).toBeTruthy();
-      expect(operator.match({ incoming: { data: { baz: 'a', foo: { bar: 'a' } } } })).toBeTruthy();
-      expect(operator.match({ incoming: { data: { baz: 'b', foo: { bar: 'b' } } } })).toBeTruthy();
-
-      expect(operator.match({ incoming: { data: { foo: { bar: 'a' } } } })).toBeFalsy();
-      expect(operator.match({ incoming: { data: { baz: 'b', foo: { bar: 'a' } } } })).toBeFalsy();
-      expect(operator.match({ incoming: { data: { baz: 'a', foo: { bar: 'b' } } } })).toBeFalsy();
-    });
-  });
-
-  describe('manipulation', () => {
-    it('should manipulate by schema in incoming body using path', () => {
-      const operator = new operators.$switch<any>(operators, {
-        $location: 'incoming.data',
-        $path: 'foo.bar',
-
-        $cases: {
-          'a': { $set: { $location: 'incoming.data', $path: 'baz', $value: 'a' } },
-          'b': { $set: { $location: 'incoming.data', $path: 'baz', $value: 'b' } },
-        },
-
-        $default: { $exec: ({ context }) => context.default = true },
-      });
-
-      expect(operator.manipulate<any>({ incoming: { data: {} } }).default).toBeTruthy();
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'a' } } } }).incoming.data.baz
-      ).toEqual('a');
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'b' } } } }).incoming.data.baz
-      ).toEqual('b');
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'c' } } } }).incoming.data.baz
-      ).toBeUndefined();
-    });
-
-    it('should match by schema in incoming body using exec', () => {
-      const operator = new operators.$switch<any>(operators, {
-        $location: 'incoming.data',
-        $exec: (payload) => payload?.foo?.bar,
-
-        $cases: {
-          'a': { $set: { $location: 'incoming.data', $path: 'baz', $value: 'a' } },
-          'b': { $set: { $location: 'incoming.data', $path: 'baz', $value: 'b' } },
-        },
-
-        $default: { $exec: ({ context }) => context.default = true },
-      });
-
-      expect(operator.manipulate<any>({ incoming: { data: {} } }).default).toBeTruthy();
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'a' } } } }).incoming.data.baz
-      ).toEqual('a');
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'b' } } } }).incoming.data.baz
-      ).toEqual('b');
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'c' } } } }).incoming.data.baz
-      ).toBeUndefined();
-    });
-
-    it('should match by schema in incoming body using exec with utils', () => {
-      const operator = new operators.$switch<any>(operators, {
-        $location: 'incoming.data',
-        $exec: (payload, { _ }) => _.get(payload, 'foo.bar'),
-
-        $cases: {
-          'a': { $set: { $location: 'incoming.data', $path: 'baz', $value: 'a' } },
-          'b': { $set: { $location: 'incoming.data', $path: 'baz', $value: 'b' } },
-        },
-
-        $default: { $exec: ({ context }) => context.default = true },
-      });
-
-      expect(operator.manipulate<any>({ incoming: { data: {} } }).default).toBeTruthy();
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'a' } } } }).incoming.data.baz
-      ).toEqual('a');
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'b' } } } }).incoming.data.baz
-      ).toEqual('b');
-
-      expect(
-        operator.manipulate<any>({ incoming: { data: { foo: { bar: 'c' } } } }).incoming.data.baz
-      ).toBeUndefined();
-    });
-  })
-});