@n1k1t/mock-server 0.1.60 → 0.1.61

package/src/gui/styles/main.scss

@@ -0,0 +1,245 @@
+@import 'constants';
+@import 'elements';
+
+@import '../app/**/*.scss';
+
+div.history, div.expectation {
+  overflow: visible;
+
+  div.meta {
+    border-radius: inherit;
+    display: flex;
+    flex-wrap: wrap;
+
+    div.segment {
+      display: inline-flex;
+      flex-wrap: wrap;
+      margin-bottom: 5px;
+    }
+
+    span:not(.truncated, .short), button {
+      padding: 7px 15px;
+      display: inline-block;
+      position: relative;
+      background-color: rgba(#fff, .05);
+      border-radius: 5px;
+      margin-right: 5px;
+      margin-top: 0;
+      margin-bottom: 0;
+      font-size: 14px;
+    }
+
+    button {
+      min-width: 50px;
+      margin-left: 0;
+
+      i {
+        float: none;
+        margin-right: 0;
+      }
+    }
+
+    b {
+      font-weight: normal;
+      position: relative;
+      display: inline-block;
+
+      &:after {
+        content: '';
+        display: inline-block;
+        position: relative;
+        height: 14px;
+        width: 1px;
+        background-color: rgba(#fff, .1);
+        top: 2px;
+        margin-left: 10px;
+        margin-right: 5px;
+      }
+    }
+
+    span {
+      span.truncated span.full {
+        background-color: lighten($color-dark, 10);
+        transition-duration: .1s;
+        transform: translateY(10px);
+        visibility: hidden;
+        opacity: 0;
+        color: #fff;
+        position: absolute;
+        font-size: 12px;
+        bottom: 25px;
+        margin-bottom: 10px;
+        left: 0;
+        z-index: +1;
+      }
+
+      &:hover span.truncated {
+        padding-top: 10px;
+
+        span.full {
+          visibility: visible;
+          transform: none;
+          opacity: 1;
+        }
+      }
+    }
+
+    span.arrow {
+      background: transparent;
+      color: rgba(#fff, .3);
+      padding: 8px 10px;
+      padding-left: 12px;
+      margin-right: 5px;
+    }
+
+    button.activity i {
+      &.fa-plug { color: $color-green }
+      &.fa-power-off { color: $color-red }
+    }
+
+    span.name {
+      font-size: 12px;
+      b { color: $color-main }
+    }
+
+    span.status {
+      color: rgba(#fff, .4);
+      font-size: 12px;
+
+      b {
+        min-width: 35px;
+        text-align: center;
+        font-size: 14px;
+      }
+
+      &.red b { color: $color-red }
+      &.green b { color: $color-green }
+    }
+
+    span.transport {
+      color: rgba(#fff, .4);
+      font-size: 12px;
+    }
+
+    span.method {
+      color: $color-dark;
+      font-weight: bold;
+    }
+
+    span.path {
+      background-color: adjust-hue($color-main, -20);
+      color: $color-dark;
+    }
+
+    span.time {
+      width: 60px;
+      text-align: center;
+      font-size: 12px;
+      padding: 9px 15px;
+    }
+
+    span.calls-count, span.name, span.time {
+      color: rgba(#fff, .5);
+
+      &.active {
+        color: #fff;
+      }
+
+      i {
+        opacity: .2;
+        margin-right: 10px;
+      }
+    }
+
+    span.calls-count {
+      min-width: 38px;
+    }
+
+    span.pending {
+      min-width: 35px;
+      text-align: center;
+
+      i:before { animation: pending 1s infinite }
+    }
+
+    span.separator, span.label {
+      padding: 0 5px;
+      color: rgba(#000, .3);
+      font-size: 12px;
+      margin-right: 0;
+      margin-bottom: 0;
+    }
+    span.label {
+      padding-left: 0;
+    }
+
+    span.handled-with {
+      background-color: transparent;
+      color: rgba(#fff, .3);
+      margin-right: 0;
+      padding: 7px 5px;
+
+      span.handler-name {
+        margin: 0;
+        padding: 0;
+        background-color: transparent;
+        color: $color-main;
+      }
+      span.handler-name.red {
+        color: $color-red;
+      }
+    }
+
+    span.error { background-color: darken($color-red, 10) }
+    span.forward {
+      background-color: $color-purple;
+      font-size: 12px;
+    }
+
+    span.seed {
+      color: $color-green;
+      font-size: 12px;
+    }
+
+    span.cache {
+      background-color: lighten($color-purple, 20);
+      color: $color-dark;
+    }
+  }
+
+  &:hover div.meta {
+    cursor: pointer;
+
+    span.time, span.transport, span.status, span.name, span.method, span.seed {
+      background-color: rgba(#fff, .15);
+    }
+  }
+
+  &.expectation div.meta {
+    span.status b:after {
+      display: none;
+    }
+  }
+
+  @media screen and (max-width: $screen-medium) {
+    div.meta {
+      background-color: lighten($color-dark, 2);
+      padding: 5px;
+      padding-bottom: 0;
+      margin-bottom: 5px;
+
+      span.arrow:nth-child(1), span.arrow:nth-child(2) { display: none }
+
+      div.segment:first-child {
+        width: 100%;
+
+        span:not(.path) { background-color: transparent }
+        span.time { padding: 9px 5px; }
+      }
+    }
+
+    &:hover div.meta {
+      background-color: lighten($color-dark, 5);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export { default as config } from './config';
+
+export * from './expectations/types';
+export * from '../types';
+
+export * from './server';
+export * from './client';
+export * from './logger';
+export * from './meta';

package/src/logger/index.ts

@@ -0,0 +1,80 @@
+import colors from 'colors';
+import _ from 'lodash';
+
+import { calculateLogLevelWeight, colorifyLogLevel, serializeLogSegments } from './utils';
+import { TLoggerLevel, TLoggerSerializer } from './types';
+import { TFunction } from '../../types';
+
+import config from '../config';
+
+export * from './types';
+
+export class Logger {
+  constructor(public title: string) {}
+
+  public debug(...messages: unknown[]): void {
+    if (calculateLogLevelWeight(config.get('logger').level) <= calculateLogLevelWeight('D')) {
+      return Logger.external?.debug
+        ? Logger.external.debug(this.title, ...serializeLogSegments(messages, Logger.serializer))
+        : this.publish('D', ...messages);
+    }
+  }
+
+  public info(...messages: unknown[]): void {
+    if (calculateLogLevelWeight(config.get('logger').level) <= calculateLogLevelWeight('I')) {
+      return Logger.external?.info
+        ? Logger.external.info(this.title, ...serializeLogSegments(messages, Logger.serializer))
+        : this.publish('I', ...messages);
+    }
+  }
+
+  public warn(...messages: unknown[]): void {
+    if (calculateLogLevelWeight(config.get('logger').level) <= calculateLogLevelWeight('W')) {
+      return Logger.external?.warn
+        ? Logger.external.warn(this.title, ...serializeLogSegments(messages, Logger.serializer))
+        : this.publish('W', ...messages);
+    }
+  }
+
+  public error(...messages: unknown[]): void {
+    if (calculateLogLevelWeight(config.get('logger').level) <= calculateLogLevelWeight('E')) {
+      return Logger.external?.error
+        ? Logger.external.error(this.title, ...serializeLogSegments(messages, Logger.serializer))
+        : this.publish('E', ...messages);
+    }
+  }
+
+  public fatal(...messages: unknown[]): void {
+    if (calculateLogLevelWeight(config.get('logger').level) <= calculateLogLevelWeight('F')) {
+      return Logger.external?.fatal
+        ? Logger.external.fatal(this.title, ...serializeLogSegments(messages, Logger.serializer))
+        : this.publish('F', ...messages);
+    }
+  }
+
+  private publish(level: TLoggerLevel, ...messages: unknown[]): void {
+    console.log(
+      colors.gray(new Date().toLocaleTimeString()),
+      colorifyLogLevel(level),
+      _.get(colors, 'brightWhite')(this.title),
+      ...serializeLogSegments(messages, Logger.serializer).map((segment) => colors.white(String(segment)))
+    );
+  }
+
+  static serializer: TLoggerSerializer | null = null;
+  static external: Partial<Pick<Logger, 'debug' | 'info' | 'warn' | 'error' | 'fatal'>> | null = null;
+
+  static useExternal(external: NonNullable<typeof Logger['external']>) {
+    return Object.assign(Logger, { external });
+  }
+
+  static useSerializers(serializers: Record<string, TFunction<unknown, [any]>>) {
+    return Object.assign(Logger, {
+      serializer: (key: string, value: unknown) => serializers[key] ? serializers[key](value) : value,
+    });
+  }
+
+  static build(title: string) {
+    return new Logger(title);
+  }
+}

package/src/logger/types.ts

@@ -0,0 +1,4 @@
+import { TFunction } from '../../types';
+
+export type TLoggerLevel = 'D' | 'I' | 'W' | 'E' | 'F';
+export type TLoggerSerializer = TFunction<unknown, [string, unknown]>;

package/src/logger/utils.ts

@@ -0,0 +1,25 @@
+import colors from 'colors';
+import _ from 'lodash';
+
+import { TLoggerLevel, TLoggerSerializer } from './types';
+
+export const serializeLogSegments = (
+  segments: unknown[],
+  serializer: TLoggerSerializer | null = null
+): unknown[] => segments.map((segment) => (_.isObject(segment) ? JSON.stringify(segment, serializer ?? undefined) : segment));
+
+export const colorifyLogLevel = _.memoize((level: TLoggerLevel): string => ({
+  D: colors.gray('[D]'),
+  I: colors.cyan('[I]'),
+  W: colors.yellow('[W]'),
+  E: colors.red('[E]'),
+  F: colors.magenta('[F]'),
+})[level]);
+
+export const calculateLogLevelWeight = _.memoize((level: TLoggerLevel): number => ({
+  D: 10,
+  I: 20,
+  W: 30,
+  E: 40,
+  F: 50,
+})[level]);

package/src/meta/index.ts

@@ -0,0 +1,6 @@
+import { MetaStorage } from './storage';
+
+export * from './storage';
+export * from './model';
+
+export const metaStorage = new MetaStorage();

package/src/meta/model.spec.ts

@@ -0,0 +1,28 @@
+import { MetaContext } from './model';
+
+// Test generated using Keploy
+test('test_merge_with_valid_context', () => {
+  const meta = new MetaContext();
+  const context = { requestId: '12345', operationId: '67890' };
+  meta.merge(context);
+  expect(meta.requestId).toBe('12345');
+  expect(meta.operationId).toBe('67890');
+});
+
+// Test generated using Keploy
+test('test_pick_single_property', () => {
+  const meta = new MetaContext();
+  meta.requestId = 'abc';
+  meta.operationId = 'xyz';
+  const result = meta.pick(['requestId']);
+  expect(result).toEqual({ requestId: 'abc' });
+  expect(result).not.toHaveProperty('operationId');
+});
+
+// Test generated using Keploy
+test('test_build_with_provided_values', () => {
+  const context = { requestId: 'customId', operationId: 'customOperation' };
+  const meta = MetaContext.build(context);
+  expect(meta.requestId).toBe('customId');
+  expect(meta.operationId).toBe('customOperation');
+});

package/src/meta/model.ts

@@ -0,0 +1,29 @@
+import { v4 as genUid } from 'uuid';
+import _ from 'lodash';
+
+import type { PickWithType } from '../../types';
+
+export type TMetaContext = Partial<PickWithType<MetaContext, string | number | boolean>>;
+
+export class MetaContext {
+  public requestId: string = 'unknown';
+  public operationId: string = 'unknown';
+
+  public merge(context: TMetaContext) {
+    return Object.assign(this, context);
+  }
+
+  public pick<K extends keyof TMetaContext>(keys: K[]): Pick<this, K> {
+    return _.pick(this, keys);
+  }
+
+  static build(context?: Partial<Pick<MetaContext, 'operationId' | 'requestId'>>) {
+    return Object.assign(
+      new MetaContext(),
+      _.defaults(context ?? {}, {
+        requestId: genUid(),
+        operationId: genUid(),
+      })
+    );
+  }
+}

package/src/meta/storage.spec.ts

@@ -0,0 +1,18 @@
+import { MetaStorage } from './storage';
+import { MetaContext } from './model';
+
+// Test generated using Keploy
+test('wrap should execute the handler with the generated context', () => {
+  const storage = new MetaStorage();
+  const mockHandler = jest.fn();
+  storage.wrap({}, mockHandler);
+  expect(mockHandler).toHaveBeenCalled();
+});
+
+// Test generated using Keploy
+test('generate should return the same MetaContext instance when provided', () => {
+  const storage = new MetaStorage();
+  const existingContext = new MetaContext();
+  const context = storage.generate(existingContext);
+  expect(context).toBe(existingContext);
+});

package/src/meta/storage.ts

@@ -0,0 +1,20 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+import { MetaContext, TMetaContext } from './model';
+import { TFunction } from '../../types';
+
+export class MetaStorage {
+  private storage = new AsyncLocalStorage<MetaContext>();
+
+  public provide() {
+    return this.storage.getStore() ?? this.generate();
+  }
+
+  public generate(payload: TMetaContext = {}) {
+    return payload instanceof MetaContext ? payload : MetaContext.build(payload);
+  }
+
+  public wrap<T>(payload: TMetaContext = {}, handler: TFunction<T>) {
+    return this.storage.run(this.generate(payload), handler);
+  }
+}

package/src/server/endpoints/cache.delete.endpoint.ts

@@ -0,0 +1,54 @@
+import Redis from 'ioredis';
+import _ from 'lodash';
+
+import { Endpoint } from '../models';
+import { Logger } from '../../logger';
+
+interface IRedisResult {
+  count: number;
+}
+
+const logger = Logger.build('Server.Endpoint.CacheUsage.Get');
+
+const deleteKeys = (client: Redis, prefix?: string) => new Promise<IRedisResult>((resolve, reject) => {
+  const stream = client.scanStream({ match: `${client.options.keyPrefix ?? ''}${prefix ?? ''}*` });
+  const result: IRedisResult = { count: 0 };
+
+  stream.once('end', () => resolve(result));
+  stream.once('error', (error) => {
+    logger.error('Got error while scan execution', error?.stack ?? error);
+    stream.close();
+
+    reject(error);
+  });
+
+  stream.on('data', async (keys: string[]) => {
+    stream.pause();
+
+    result.count += keys.length;
+
+    await Promise
+      .all(keys.map(async (key) => client.call('DEL', key)))
+      .catch((error) => {
+        logger.error('Got error while deletion keys', error?.stack ?? error);
+        stream.close();
+
+        reject(error);
+        return [];
+      });
+
+    stream.resume();
+  });
+});
+
+export default Endpoint
+  .build<{ incoming: { data: { prefix?: string } }, outgoing: { redis?: IRedisResult } }>()
+  .bindToHttp(<const>{ method: 'DELETE', path: `/cache` })
+  .bindToIo(<const>{ path: 'cache:delete' })
+  .assignHandler(async ({ incoming, reply, server }) =>
+    reply.ok({
+      redis: server.databases.redis
+        ? await deleteKeys(server.databases.redis, incoming.data?.prefix).catch(() => undefined)
+        : undefined,
+    })
+  );

package/src/server/endpoints/cache.usage.get.endpoint.ts

@@ -0,0 +1,12 @@
+import { IRedisUsage } from '../services';
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{ incoming: { query: { prefix?: string } }, outgoing: { redis: IRedisUsage } }>()
+  .bindToHttp(<const>{ method: 'GET', path: `/cache/usage` })
+  .bindToIo(<const>{ path: 'cache:usage:get' })
+  .assignHandler(async ({ incoming, reply, server }) =>
+    reply.ok({
+      redis: await server.services.analytics.calculateRedisUsage(incoming.query?.prefix),
+    })
+  );

package/src/server/endpoints/config.get.endpoint.ts

@@ -0,0 +1,10 @@
+import _ from 'lodash';
+
+import { Endpoint } from '../models';
+import config from '../../config';
+
+export default Endpoint
+  .build<{ outgoing: Pick<typeof config['storage'], 'history'> }>()
+  .bindToHttp(<const>{ method: 'GET', path: `/config` })
+  .bindToIo(<const>{ path: 'config:get' })
+  .assignHandler(({ reply }) => reply.ok(_.pick(config.storage, ['history'])));

package/src/server/endpoints/expectations-group.update.endpoint.ts

@@ -0,0 +1,32 @@
+import { Expectation } from '../../expectations';
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{
+    incoming: {
+      data: {
+        name?: string;
+        set: {
+          isEnabled: boolean;
+        };
+      };
+    };
+
+    outgoing: Expectation['TPlain'][];
+  }>()
+  .bindToHttp(<const>{ method: 'PUT', path: '/expectations/group' })
+  .bindToIo(<const>{ path: 'expectations:group:update' })
+  .assignHandler(async ({ reply, incoming, server }) => {
+    if (!incoming.data) {
+      return reply.validationError();
+    }
+
+    const group = incoming.data.name ?? 'default';
+    const provider = group === 'default' ? server.providers.default : server.providers.get(group);
+
+    if (!provider) {
+      return reply.notFound();
+    }
+
+    reply.ok(await provider.client.updateExpectationsGroup(incoming.data.set));
+  });

package/src/server/endpoints/expectations.create.endpoint.ts

@@ -0,0 +1,23 @@
+import { Expectation } from '../../expectations';
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{
+    incoming: { data: Expectation<any>['configuration'] };
+    outgoing: Expectation['TPlain'];
+  }>()
+  .bindToHttp(<const>{ method: 'POST', path: '/expectations' })
+  .assignHandler(async ({ reply, incoming, server }) => {
+    if (!incoming.data) {
+      return reply.validationError();
+    }
+
+    const group = incoming.data.group ?? 'default';
+    const provider = group === 'default' ? server.providers.default : server.providers.get(group);
+
+    if (!provider) {
+      return reply.notFound();
+    }
+
+    reply.ok(await provider.client.createExpectation(incoming.data))
+  });

package/src/server/endpoints/expectations.delete.endpoint.ts

@@ -0,0 +1,12 @@
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{
+    incoming: { data: void | { ids?: string[] } };
+    outgoing: null;
+  }>()
+  .bindToHttp(<const>{ method: 'DELETE', path: '/expectations' })
+  .assignHandler(async ({ reply, incoming, provider }) => {
+    await provider.client.deleteExpectations(incoming.data);
+    reply.ok(null);
+  });

package/src/server/endpoints/expectations.get-list.endpoint.ts

@@ -0,0 +1,15 @@
+import { Expectation } from '../../expectations';
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{ outgoing: Expectation['TPlain'][] }>()
+  .bindToHttp(<const>{ method: 'GET', path: '/expectations' })
+  .bindToIo(<const>{ path: 'expectations:get-list' })
+  .assignHandler(({ reply, server }) =>
+    reply.ok(
+      server.providers
+        .extract()
+        .reduce<Expectation[]>((acc, provider) => acc.concat([...provider.storages.expectations.values()]), [])
+        .map((expectation) => expectation.toPlain())
+    )
+  );

package/src/server/endpoints/expectations.update.endpoint.ts

@@ -0,0 +1,29 @@
+import { Expectation } from '../../expectations';
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{
+    incoming: {
+      data: {
+        id: string;
+        set: Partial<Expectation<any>['configuration']>;
+      };
+    };
+
+    outgoing: Expectation['TPlain'];
+  }>()
+  .bindToHttp(<const>{ method: 'PUT', path: '/expectations' })
+  .bindToIo(<const>{ path: 'expectations:update' })
+  .assignHandler(async ({ reply, incoming, server }) => {
+    if (!incoming.data) {
+      return reply.validationError();
+    }
+
+    const provider = server.providers.extract().find((provider) => provider.storages.expectations.has(incoming.data!.id));
+    if (!provider) {
+      return reply.notFound();
+    }
+
+    const updated = await provider.client.updateExpectation(incoming.data);
+    updated ? reply.ok(updated) : reply.notFound();
+  });