@n1k1t/mock-server 0.1.59 → 0.1.61

package/src/utils/index.spec.ts

@@ -0,0 +1,31 @@
+import { wait, buildCounter, flattenArrayed } from './index';
+
+// Test generated using Keploy
+test('wait resolves after specified duration', async () => {
+  const duration = 100;
+  const start = Date.now();
+  await wait(duration);
+  const end = Date.now();
+  expect(end - start).toBeGreaterThanOrEqual(duration);
+});
+
+// Test generated using Keploy
+test('buildCounter increments correctly with initial value', () => {
+  const counter = buildCounter(5);
+  expect(counter()).toBe(6);
+  expect(counter()).toBe(7);
+});
+
+// Test generated using Keploy
+test('flattenArrayed wraps a single array in an array', () => {
+  const singleArray = [1, 2, 3];
+  const expectedResult = [[1, 2, 3]];
+  expect(flattenArrayed<any>(singleArray)).toEqual(expectedResult);
+});
+
+// Test generated using Keploy
+test('flattenArrayed wraps a non-array in an array', () => {
+  const nonArrayInput = 42;
+  const expectedResult = [[42]];
+  expect(flattenArrayed<any>(nonArrayInput)).toEqual(expectedResult);
+});

package/src/utils/index.ts

@@ -0,0 +1,51 @@
+import type { FlattenArrays } from '../../types';
+
+export const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+export const cast = <T>(payload: T) => payload;
+
+export const flattenArrayed = <
+  T extends unknown[][],
+  Q extends FlattenArrays<T>[] = FlattenArrays<T>[]
+>(payload: T): Q => {
+  if (payload?.every?.(Array.isArray)) {
+    return <Q>payload.reduce((acc, nestedPayload) => acc.concat(flattenArrayed(<T>nestedPayload)), []);
+  }
+
+  return Array.isArray(payload)
+    ? <Q>[payload]
+    : <Q>[[payload]];
+};
+
+/**
+ * @example
+ * ```ts
+ * const counter = buildCounter(5);
+ *
+ * counter() // 6
+ * counter() // 7
+ * counter(2) // 9
+ * ```
+ */
+export const buildCounter =
+  (initial = 0, step = 1) =>
+  (value = step) =>
+    (initial += value);
+
+export const serializeRegExp = (exp: RegExp): Pick<RegExp, 'source' | 'flags'> => ({
+  source: exp.source,
+  flags: exp.flags,
+});
+
+export const parseJsonSafe = <T extends Record<string, unknown>>(serializedJson: string) => {
+  try {
+    return <const>{
+      status: 'OK',
+      result: <T>JSON.parse(serializedJson),
+    };
+  } catch(error) {
+    return <const>{
+      status: 'ERROR',
+      error: error instanceof Error ? error : new Error('Unknown'),
+    };
+  }
+};

package/test/index.ts

@@ -0,0 +1,299 @@
+import { MockServer, RemoteClient, Logger, Provider } from '../src';
+import * as providers from './providers';
+
+Logger.useSerializers({
+  cvv: () => '***',
+  card: (text: string) => `xxxx${text.slice(4, 8)}xxxx`,
+});
+
+const host = 'localhost';
+const port = 13000;
+
+(async () => {
+  const server = await MockServer.start({
+    host,
+    port,
+
+    databases: {
+      redis: {
+        host: 'localhost',
+        port: 6379,
+      },
+    },
+  });
+
+  const client = await RemoteClient.connect({ baseUrl: `http://${host}:${port}` });
+  const papi = Provider.build({ group: 'papi' });
+
+  server.router
+    .register('/statics/**', {
+      provider: providers.statics,
+      transports: ['http'],
+    })
+    .register('/{generation,items}/**', {
+      provider: providers.root,
+      transports: ['http'],
+    })
+    .register('**/papi/**', {
+      provider: papi,
+    });
+
+  await client.createExpectation(({ $ }) => ({
+    transports: ['http'],
+    schema: {
+      request: $.has('path', { $value: '/foo/9349beb2-2fba-4ecd-9280-b44edbeb6b58/bar/f4261e21-cad7-412d-9726-5a8e48734855' }),
+      response: $.set('outgoing.data', { $value: { has_mocked: true } }),
+
+      forward: {
+        baseUrl: 'https://www.google.com/9349beb2-2fba-4ecd-9280-b44edbeb6b58',
+      },
+    },
+  }));
+
+  await client.createExpectation(({ $ }) => ({
+    transports: ['http'],
+    schema: {
+      request: $.has('path', { $match: '/statics/qwe' }),
+      response: $.set('outgoing.data', { $value: { has_mocked: true } }),
+    },
+  }));
+
+  await client.createExpectation<{
+    container: {
+      counter: number;
+    };
+
+    outgoing: {
+      data: object;
+    };
+  }>(({ $ }) => ({
+    transports: ['http'],
+    isEnabled: true,
+
+    schema: {
+      request: $.and([
+        $.has('incoming.headers', '$path', 'x-use-mock', { $value: 'true' }),
+        $.has('path', { $regExp: /^\/forward\/*./ }),
+
+        $.set('container', { $exec: (container, { context }) => context.storage.find('test') }),
+
+        $.exec(({ context }) => {
+          context.incoming.path = context.incoming.path.replace('/forward', '');
+          return true;
+        }),
+      ]),
+
+      response: $.and([
+        $.set('outgoing.data', {
+          $exec: (payload, { context }) => Object.assign(payload, {
+            counter: context.container?.payload.counter,
+            transport: context.transport,
+          }),
+        }),
+      ]),
+
+      forward: {
+        baseUrl: 'http://127.0.0.1:8053/v1/maintenance',
+        timeout: 2000,
+
+        cache: {
+          prefix: 'papi:location:',
+          ttl: 20,
+        },
+      },
+    },
+  }));
+
+  await server.client.createExpectation(({ $ }) => ({
+    transports: ['http'],
+    schema: {
+      request: $.and([
+        $.has('path', { $match: '**/papi/**' }),
+      ]),
+      response: $.and([
+        $.set('outgoing.dataRaw', { $exec: () => Buffer.from('Mocked') }),
+      ]),
+    },
+  }));
+
+  await papi.client.createExpectation<{
+    incoming: {
+      query: {
+        foo: 'a' | 'b' | 'c';
+        bar?: string;
+      };
+    };
+
+    outgoing: {
+      data: {
+        timestamp: number;
+        data: {
+          version: string;
+          options: {
+            use_test_mode_by_default: boolean;
+            has_mocked_by?: string;
+          };
+        };
+      };
+    };
+  }>(({ $ }) => ({
+    schema: {
+      request: $.and([
+        $.has('path', { $match: '**/papi/forward/**' }),
+        $.exec(({ context }) => context.incoming.headers['content-type'] === 'application/json'),
+        // $.set('delay', { $value: 5000 }),
+      ]),
+
+      response: $.and([
+        // $.set('cache', '$path', 'isEnabled', { $value: true }),
+
+        $.merge('outgoing.data', '$path', 'data', {
+          $exec: (payload, {}) => ({ foo: 123, host, version: payload.version + '1' }),
+        }),
+
+        $.if({
+          $condition: $.has('incoming.query', '$path', 'foo', { $value: 'a' }),
+          $then: $.merge('outgoing.data', '$path', 'data', { $value: { options: { has_mocked_by: 'John Cena' } } }),
+        }),
+
+        $.if({
+          $condition: $.has('incoming.query', '$path', 'foo', { $value: 'b' }),
+          $then: $.and([
+            $.remove('outgoing.data', {}),
+            $.set('outgoing.dataRaw', { $exec: () => Buffer.from('["What the f*ck"]') }),
+          ]),
+        }),
+      ]),
+
+      forward: {
+        url: 'http://localhost:17188/_papi/v1/maintenance/stats',
+
+        cache: {
+          prefix: 'papi:',
+          ttl: 300,
+        },
+      },
+    },
+  }));
+
+  await server.client.createExpectation<{
+    incoming: {
+      data: number;
+    };
+
+    outgoing: {
+      data: { counter: number };
+    };
+  }>(({ $ }) => ({
+    transports: ['ws'],
+    schema: {
+      request: $.and([
+        $.has('event', { $value: 'message' }),
+        $.has('path', { $value: '/messages' }),
+        $.if({
+          $condition: $.has('incoming.data', { $value: 5 }),
+          $then: $.and([
+            $.merge('flags', { $value: { wsCloseConnection: true } }),
+            $.set('outgoing.status', { $value: 1001 }),
+          ]),
+          $else: $.exec(() => true),
+        }),
+      ]),
+
+      response: $.and([
+        $.if({
+          $condition: $.has('incoming.data', { $value: 6 }),
+          $then: $.and([
+            $.merge('flags', { $value: { wsCloseConnection: true } }),
+            $.set('outgoing.status', { $value: 1002 }),
+          ]),
+          $else: $.exec(() => true),
+        }),
+        $.set('outgoing.stream', {
+          $exec: (payload, { rx, context }) =>
+            rx.merge(
+              rx.from([{ counter: context.incoming.data }, { counter: context.incoming.data + 1 }]),
+              rx.from([{ counter: context.incoming.data + 2 }]).pipe(rx.delay(1000)),
+              rx.from([{ counter: context.incoming.data + 3 }]).pipe(rx.delay(2000)),
+              rx.from([{ counter: context.incoming.data + 4 }]).pipe(rx.delay(3000)),
+            ),
+        }),
+      ]),
+    },
+  }));
+
+  await server.client.createExpectation<{
+    incoming: {
+      data: number;
+    };
+
+    outgoing: {
+      data: { counter: number };
+    };
+  }>(({ $ }) => ({
+    transports: ['ws'],
+    schema: {
+      request: $.and([
+        $.has('event', { $value: 'connection' }),
+        $.has('path', { $value: '/connection' }),
+      ]),
+
+      response: $.and([
+        $.set('outgoing.stream', {
+          $exec: (payload, { context, rx }) =>
+            rx.merge<typeof context['outgoing']['data'][]>(
+              rx.from([{ counter: 1 }, { counter: 2 }]),
+              rx.from([{ counter: 3 }]).pipe(rx.delay(1000)),
+              rx.from([{ counter: 4 }]).pipe(rx.delay(2000)),
+              rx.from([{ counter: 5 }]).pipe(rx.delay(3000)),
+            )
+        }),
+      ]),
+    },
+  }));
+
+  await server.client.createExpectation<{
+    incoming: {
+      data: number;
+    };
+
+    outgoing: {
+      data: number | string;
+    };
+  }>(({ $ }) => ({
+    transports: ['ws'],
+    schema: {
+      request: $.and([
+        $.has('event', { $value: 'connection' }),
+        $.has('path', { $value: '/mixed' }),
+      ]),
+
+      response: $.and([
+        $.set('outgoing.stream', {
+          $exec: (payload, { context, rx }) => {
+            const subject = new rx.ReplaySubject<typeof context['outgoing']['data']>();
+
+            subject.next('It multuplies value by 2');
+            subject.next('Type any number here...');
+
+            context.incoming.stream!
+              .pipe(
+                rx.tap((data) => {
+                  if (data === 5) {
+                    context.outgoing.status = 1011;
+
+                    subject.next('Ooops');
+                    subject.complete();
+                  }
+                }),
+                rx.map((data) => data ** 2),
+              )
+              .subscribe(subject);
+
+            return subject.asObservable();
+          },
+        }),
+      ]),
+    },
+  }));
+})();

package/test/providers/index.ts

@@ -0,0 +1,2 @@
+export { default as statics } from './statics';
+export { default as root } from './root';

package/test/providers/root.ts

@@ -0,0 +1,241 @@
+import { Provider } from '../../src';
+
+const provider = Provider.build({ group: 'root' });
+
+(async () => {
+  await provider.client.createExpectation(({ $ }) => ({
+    isEnabled: true,
+    transports: ['http'],
+    schema: {
+      request: $.and([
+        $.has('method', { $value: 'GET' }),
+        $.has('path', { $value: '/items/1' }),
+      ]),
+      response: $.and([
+        $.set('outgoing.headers', { $value: { 'content-type': 'application/json' } }),
+
+        $.set('container', {
+          $exec: (payload, { context }) => context.storage.register({
+            key: `im:order:123123`,
+            payload: {
+              orderId: 123123,
+              ticketIds: {
+                567567: 123123,
+              },
+              orderItemIds: {
+                123123: 45645456,
+              },
+            },
+          }),
+        }),
+
+        $.set('container', {
+          $exec: (payload, { context }) => context.storage.find(`im:order:123123`)?.bind('im:ticket:123123123'),
+        }),
+
+        $.exec(({ context }) => {
+          if (context.incoming.path === '/items/1') {
+            if (context.outgoing) {
+              context.outgoing.status = 204;
+            }
+          }
+        }),
+      ]),
+    },
+  }));
+
+  await provider.client.createExpectation<{
+    incoming: {
+      query: {
+        foo: 'a' | 'b' | 'c';
+        bar?: string;
+      };
+    };
+
+    outgoing: {
+      data: {
+        foo: number;
+        bar: {
+          baz: 'a' | 'b' | 'c';
+        };
+      };
+    };
+  }>(({ $ }) => ({
+    transports: ['http'],
+    schema: {
+      request: $.and([
+        $.has('method', { $value: 'GET' }),
+        $.has('path', { $match: '/generat*on/foo' }),
+        $.has('incoming.query', '$path', 'foo', { $valueAnyOf: ['a', 'b', 'c'] }),
+        $.exec(({ context }) => context.incoming.headers['content-type'] === 'application/json'),
+      ]),
+
+      response: $.and([
+        $.set('outgoing.data', { $value: {} }),
+        $.switch('incoming.query', '$path', 'foo', {
+          $cases: {
+            'a': $.and([
+              $.set('outgoing.status', { $value: 201 }),
+              $.set('outgoing.data', '$path', 'bar.baz', { $value: 'a' }),
+            ]),
+
+            'b': $.merge('outgoing.data', '$path', 'bar', { $value: { baz: 'b' } }),
+          },
+
+          $default: $.and([
+            $.set('outgoing.status', { $value: 400 }),
+            $.set('outgoing.data', '$path', 'bar.baz', { $value: 'c' }),
+          ]),
+        }),
+
+        $.exec(({ context, logger }) => {
+          context.outgoing!.headers['x-mock-entity'] = String(Date.now());
+
+          logger.info('Payment data', { cvv: '123', card: '123412341234' });
+
+          switch(context.incoming.query.foo) {
+            case 'a': return context.outgoing.data.foo = 100;
+            case 'b': return context.outgoing.data.foo = 200;
+            case 'c': return context.outgoing.data.foo = 300;
+          }
+        }),
+      ]),
+    },
+  }));
+
+  await provider.client.createExpectation<{
+    incoming: {
+      query: {
+        foo: 'a' | 'b' | 'c';
+        bar?: string;
+      };
+    };
+
+    outgoing: {
+      data: object;
+    };
+  }>(({ $ }) => ({
+    schema: {
+      request: $.and([
+        $.has('path', { $matchAnyOf: ['/gen*ration/bar'] }),
+        $.exec(({ context }) => context.incoming.headers['content-type'] === 'application/xml'),
+      ]),
+
+      response: $.and([
+        $.set('outgoing.headers', '$path', 'content-type', { $value: 'application/xml' }),
+        $.set('outgoing.data', {
+          $value: {
+            tag: {
+              nested: {
+                '#text': 100,
+                '@_type': 'mocked'
+              }
+            },
+          },
+        }),
+
+        $.exec(({ context, logger, meta }) => {
+          logger.info(meta.requestId, context.incoming.data);
+          return true;
+        }),
+
+        $.if({
+          $condition: $.not($.has('incoming.query', '$path', 'foo', { $value: 'a' })),
+
+          $then: $.and([
+            $.set('outgoing.status', { $value: 201 }),
+            $.set('outgoing.data', {
+              $value: {
+                tag: {
+                  nested: {
+                    '#text': 200,
+                    '@_type': 'mocked'
+                  }
+                },
+              },
+            }),
+          ]),
+        }),
+      ]),
+    },
+  }));
+
+  await provider.client.createExpectation<{
+    incoming: {
+      data: {
+        foo: {
+          baz?: 1 | 2 | 3;
+          bar: {
+            baz: 'a' | 'b' | 'c';
+          };
+        };
+      };
+    };
+  }>(({ $ }) => ({
+    schema: {
+      request: $.and([
+        $.has('method', { $value: 'POST' }),
+        $.has('path', { $valueAnyOf: ['/generation/deep-matching'] }),
+
+        $.or([
+          $.has('incoming.data', { $match: { foo: { bar: {} } } }),
+          $.has('incoming.data', { $match: { foo: { baz: 1 } } }),
+        ]),
+      ]),
+
+      response: $.and([
+        $.set('outgoing.status', { $value: 201 }),
+        $.set('outgoing.data', { $value: ['How match is the fish?'] }),
+
+        $.if({
+          $condition: $.has('incoming.data', '$path', 'foo.bar.baz', { $value: 'a' }),
+          $then: $.set('outgoing.data', { $value: ['Matched'] }),
+        }),
+      ]),
+    },
+  }));
+
+  await provider.client.createExpectation<{
+    container: {
+      counter: number;
+      items: string[];
+    };
+
+    state: {
+      foo?: number;
+      bar?: 2;
+    };
+  }>(({ $ }) => ({
+    schema: {
+      request: $.and([
+        $.has('path', { $value: '/generation/faker' }),
+        $.set('seed', { $exec: (seed, { context, T }) => T(seed ?? context.incoming.query?.foo ?? context.state.foo) }),
+
+        $.set('container', {
+          $exec: (container, { context }) => context.storage.provide({ ttl: 20, key: 'test', payload: { counter: 0, items: [] } })
+        }),
+      ]),
+
+      response: $.and([
+        $.exec(({ context }) => {
+          context.container!.payload.items.push(new Date().toISOString());
+        }),
+        $.set('outgoing.data', {
+          $exec: (payload, { context, faker }) => ({
+            counter: context.container!.payload.counter,
+            items: context.container!.payload.items,
+
+            id: faker.number.int({ max: 1000, min: 500 }),
+            first_name: faker.person.firstName('male'),
+            last_name: faker.person.lastName('male'),
+
+            uids: [faker.string.uuid(), faker.string.uuid()],
+            ids: [faker.number.int({ max: 1000, min: 500 }), faker.number.int({ max: 1000, min: 500 })],
+          }),
+        }),
+      ]),
+    },
+  }));
+})();
+
+export default provider;

package/test/providers/statics.ts

@@ -0,0 +1,37 @@
+import { Provider } from '../../src';
+
+const provider = Provider.build({ group: 'statics' });
+
+(async () => {
+  await provider.client.createExpectation(({ $ }) => ({
+    schema: {
+      request: $.has('path', { $value: '/statics/foo' }),
+      response: $.and([
+        $.set('outgoing.status', { $value: 200 }),
+        $.set('outgoing.data', {
+          $exec: () => ({
+            foo: true,
+          }),
+        }),
+      ]),
+    },
+  }));
+
+  await provider.client.createExpectation(({ $ }) => ({
+    transports: ['http'],
+    schema: {
+      request: $.has('path', { $value: '/statics/bar' }),
+      response: $.and([
+        $.set('outgoing.status', { $value: 200 }),
+        $.set('outgoing.data', {
+          $exec: (payload, { context }) => ({
+            bar: true,
+            transport: context.transport,
+          }),
+        }),
+      ]),
+    },
+  }));
+})();
+
+export default provider;