mock-config-server 3.3.1 → 3.3.2

package/dist/src/utils/helpers/entities/convertToEntityDescriptor/convertToEntityDescriptor.test.ts

@@ -1,27 +0,0 @@
-import { convertToEntityDescriptor } from './convertToEntityDescriptor';
-
-describe('convertToEntityDescriptor', () => {
-  test('Should correctly convert value to descriptor', () => {
-    expect(convertToEntityDescriptor(null)).toEqual({ checkMode: 'equals', value: null });
-    expect(convertToEntityDescriptor(undefined)).toEqual({ checkMode: 'equals', value: undefined });
-    expect(convertToEntityDescriptor(true)).toEqual({ checkMode: 'equals', value: true });
-    expect(convertToEntityDescriptor(1)).toEqual({ checkMode: 'equals', value: 1 });
-    expect(convertToEntityDescriptor('string')).toEqual({ checkMode: 'equals', value: 'string' });
-    expect(convertToEntityDescriptor([])).toEqual({
-      checkMode: 'equals',
-      value: []
-    });
-    expect(convertToEntityDescriptor({ key: 'value' })).toEqual({
-      checkMode: 'equals',
-      value: { key: 'value' }
-    });
-  });
-
-  test('Should return same value if descriptor provided', () => {
-    expect(convertToEntityDescriptor({ checkMode: 'exists' })).toEqual({ checkMode: 'exists' });
-    expect(convertToEntityDescriptor({ checkMode: 'equals', value: 'string' })).toEqual({
-      checkMode: 'equals',
-      value: 'string'
-    });
-  });
-});

package/dist/src/utils/helpers/entities/isEntityDescriptor/isEntityDescriptor.test.ts

@@ -1,15 +0,0 @@
-import { isEntityDescriptor } from './isEntityDescriptor';
-
-describe('isEntityDescriptor', () => {
-  test('Should correctly define descriptor', () => {
-    expect(isEntityDescriptor(null)).toEqual(false);
-    expect(isEntityDescriptor(undefined)).toEqual(false);
-    expect(isEntityDescriptor(true)).toEqual(false);
-    expect(isEntityDescriptor(1)).toEqual(false);
-    expect(isEntityDescriptor('string')).toEqual(false);
-    expect(isEntityDescriptor([])).toEqual(false);
-    expect(isEntityDescriptor({ key: 'value' })).toEqual(false);
-    expect(isEntityDescriptor({ checkMode: 'exists' })).toEqual(true);
-    expect(isEntityDescriptor({ checkMode: 'equals', value: 'string' })).toEqual(true);
-  });
-});

package/dist/src/utils/helpers/graphql/getGraphQLInput/getGraphQLInput.test.ts

@@ -1,140 +0,0 @@
-import type { Request } from 'express';
-
-import { getGraphQLInput } from './getGraphQLInput';
-
-describe('getGraphQLInput', () => {
-  test('Should get correct graphQL input from GET request (with object variables)', () => {
-    const mockRequest = {
-      method: 'GET',
-      query: {
-        query: 'query GetCharacters { characters { name } }',
-        variables: { limit: 10 }
-      }
-    } as unknown as Request;
-
-    const graphQLInput = getGraphQLInput(mockRequest);
-
-    expect(graphQLInput).toStrictEqual({
-      query: 'query GetCharacters { characters { name } }',
-      variables: { limit: 10 }
-    });
-  });
-
-  test('Should get correct graphQL input from GET request (with string variables)', () => {
-    const mockRequest = {
-      method: 'GET',
-      query: {
-        query: 'query GetCharacters { characters { name } }',
-        variables: '{ "limit": 10 }'
-      }
-    } as unknown as Request;
-
-    const graphQLInput = getGraphQLInput(mockRequest);
-
-    expect(graphQLInput).toStrictEqual({
-      query: 'query GetCharacters { characters { name } }',
-      variables: { limit: 10 }
-    });
-  });
-
-  test('Should get correct graphQL input from GET request with empty variables', () => {
-    const mockRequest = {
-      method: 'GET',
-      query: {
-        query: 'query GetCharacters { characters { name } }'
-      }
-    } as unknown as Request;
-
-    const graphQLInput = getGraphQLInput(mockRequest);
-
-    expect(graphQLInput).toStrictEqual({
-      query: 'query GetCharacters { characters { name } }',
-      variables: undefined
-    });
-  });
-
-  test('Should get correct graphQL input from GET request with empty query and variables', () => {
-    const mockRequest = {
-      method: 'GET',
-      query: {}
-    } as unknown as Request;
-
-    const graphQLInput = getGraphQLInput(mockRequest);
-
-    expect(graphQLInput).toStrictEqual({
-      query: undefined,
-      variables: undefined
-    });
-  });
-
-  test('Should get correct graphQL input from POST request', () => {
-    const mockRequest = {
-      method: 'POST',
-      body: {
-        query: 'query GetCharacters { characters { name } }',
-        variables: { limit: 10 }
-      }
-    } as unknown as Request;
-
-    const graphQLInput = getGraphQLInput(mockRequest);
-
-    expect(graphQLInput).toStrictEqual({
-      query: 'query GetCharacters { characters { name } }',
-      variables: { limit: 10 }
-    });
-  });
-
-  test('Should get correct graphQL input from POST with empty variables', () => {
-    const mockRequest = {
-      method: 'POST',
-      body: {
-        query: 'query GetCharacters { characters { name } }'
-      }
-    } as unknown as Request;
-
-    const graphQLInput = getGraphQLInput(mockRequest);
-
-    expect(graphQLInput).toStrictEqual({
-      query: 'query GetCharacters { characters { name } }',
-      variables: undefined
-    });
-  });
-
-  test('Should get correct graphQL input from POST with empty query and variables', () => {
-    const mockRequest = {
-      method: 'POST',
-      body: {}
-    } as unknown as Request;
-
-    const graphQLInput = getGraphQLInput(mockRequest);
-
-    expect(graphQLInput).toStrictEqual({
-      query: undefined,
-      variables: undefined
-    });
-  });
-
-  test('Should throw error if request method is not GET or POST', () => {
-    const deleteMockRequest = {
-      method: 'DELETE',
-      query: {
-        query: 'query GetCharacters { characters { name } }'
-      }
-    } as unknown as Request;
-
-    expect(() => getGraphQLInput(deleteMockRequest)).toThrow(
-      'Not allowed request method DELETE for graphql request'
-    );
-
-    const putMockRequest = {
-      method: 'PUT',
-      body: {
-        query: 'query GetCharacters { characters { name } }'
-      }
-    } as unknown as Request;
-
-    expect(() => getGraphQLInput(putMockRequest)).toThrow(
-      'Not allowed request method PUT for graphql request'
-    );
-  });
-});

package/dist/src/utils/helpers/graphql/parseQuery/parseQuery.test.ts

@@ -1,32 +0,0 @@
-import { parseQuery } from './parseQuery';
-
-describe('parseQuery', () => {
-  test('Should parse graphQL query', () => {
-    const parsedQuery = parseQuery('query GetCharacters { characters { name } }');
-
-    expect(parsedQuery).toStrictEqual({
-      operationType: 'query',
-      operationName: 'GetCharacters'
-    });
-  });
-
-  test('Should parse graphQL mutation', () => {
-    const parsedQuery = parseQuery(
-      'mutation CreateCharacters($name: String!) { createCharacters(name: $name) { name } }'
-    );
-
-    expect(parsedQuery).toStrictEqual({
-      operationType: 'mutation',
-      operationName: 'CreateCharacters'
-    });
-  });
-
-  test('Should parse graphQL query with empty operationName', () => {
-    const parsedQuery = parseQuery('query { characters { name } }');
-
-    expect(parsedQuery).toStrictEqual({
-      operationType: 'query',
-      operationName: undefined
-    });
-  });
-});

package/dist/src/utils/helpers/interceptors/callRequestInterceptor/callRequestInterceptors.test.ts

@@ -1,53 +0,0 @@
-import type { Request } from 'express';
-
-import type { RequestInterceptor } from '@/utils/types';
-
-import { callRequestInterceptor } from './callRequestInterceptor';
-
-describe('callRequestInterceptors: order of calls', () => {
-  test('Should call passed request interceptor', () => {
-    const request = {} as Request;
-    const interceptor = jest.fn();
-
-    callRequestInterceptor({ request, interceptor });
-    expect(interceptor.mock.calls.length).toBe(1);
-  });
-});
-
-describe('callRequestInterceptors: params functions', () => {
-  test('Should correctly get header from request.headers object when use getHeader param', () => {
-    const request = { headers: { name: 'value' } };
-    const getHeaderRequestInterceptor: RequestInterceptor = ({ getHeader }) => {
-      expect(getHeader('name')).toBe('value');
-    };
-
-    callRequestInterceptor({
-      request: request as unknown as Request,
-      interceptor: getHeaderRequestInterceptor
-    });
-  });
-
-  test('Should correctly get headers as request.headers object when use getHeaders param', () => {
-    const request = { headers: { name: 'value' } };
-    const getHeadersRequestInterceptor: RequestInterceptor = ({ getHeaders }) => {
-      expect(getHeaders()).toStrictEqual({ name: 'value' });
-    };
-
-    callRequestInterceptor({
-      request: request as unknown as Request,
-      interceptor: getHeadersRequestInterceptor
-    });
-  });
-
-  test('Should correctly get cookie from request.cookies object when use getCookie param', () => {
-    const request = { cookies: { name: 'value' } };
-    const getCookieRequestInterceptor: RequestInterceptor = ({ getCookie }) => {
-      expect(getCookie('name')).toBe('value');
-    };
-
-    callRequestInterceptor({
-      request: request as unknown as Request,
-      interceptor: getCookieRequestInterceptor
-    });
-  });
-});

package/dist/src/utils/helpers/interceptors/callResponseInterceptors/callResponseInterceptors.test.ts

@@ -1,262 +0,0 @@
-import type { Request, Response } from 'express';
-
-import type { ResponseInterceptor } from '@/utils/types';
-
-import { callResponseInterceptors } from './callResponseInterceptors';
-
-describe('callResponseInterceptors: order of calls', () => {
-  test('Should call all passed response interceptors in order: route -> request -> api -> server', async () => {
-    const initialData = '';
-    const request = {} as Request;
-    const response = {} as Response;
-    const routeInterceptor = jest.fn((data) => `${data}routeInterceptor;`);
-    const requestInterceptor = jest.fn((data) => `${data}requestInterceptor;`);
-    const apiInterceptor = jest.fn((data) => `${data}apiInterceptor;`);
-    const serverInterceptor = jest.fn((data) => `${data}serverInterceptor`);
-
-    expect(
-      await callResponseInterceptors({
-        data: initialData,
-        request,
-        response
-      })
-    ).toBe('');
-    expect(routeInterceptor.mock.calls.length).toBe(0);
-    expect(requestInterceptor.mock.calls.length).toBe(0);
-    expect(apiInterceptor.mock.calls.length).toBe(0);
-    expect(serverInterceptor.mock.calls.length).toBe(0);
-
-    expect(
-      await callResponseInterceptors({
-        data: initialData,
-        request,
-        response,
-        interceptors: {
-          routeInterceptor,
-          apiInterceptor,
-          requestInterceptor,
-          serverInterceptor
-        }
-      })
-    ).toBe('routeInterceptor;requestInterceptor;apiInterceptor;serverInterceptor');
-    expect(routeInterceptor.mock.calls.length).toBe(1);
-    expect(requestInterceptor.mock.calls.length).toBe(1);
-    expect(apiInterceptor.mock.calls.length).toBe(1);
-    expect(serverInterceptor.mock.calls.length).toBe(1);
-
-    expect(routeInterceptor.mock.invocationCallOrder[0]).toBeLessThan(
-      requestInterceptor.mock.invocationCallOrder[0]
-    );
-    expect(requestInterceptor.mock.invocationCallOrder[0]).toBeLessThan(
-      apiInterceptor.mock.invocationCallOrder[0]
-    );
-    expect(apiInterceptor.mock.invocationCallOrder[0]).toBeLessThan(
-      serverInterceptor.mock.invocationCallOrder[0]
-    );
-  });
-});
-
-describe('callResponseInterceptors: params functions', () => {
-  test('Should correctly call response getHeader method when use getHeader param', async () => {
-    const data = null;
-    const request = {};
-    const response = { getHeader: jest.fn() };
-
-    const getHeaderRouteInterceptor: ResponseInterceptor = (data, { getHeader }) => {
-      getHeader('header');
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as Request,
-      response: response as unknown as Response,
-      interceptors: {
-        routeInterceptor: getHeaderRouteInterceptor
-      }
-    });
-    expect(response.getHeader).toHaveBeenCalledWith('header');
-    expect(response.getHeader).toHaveBeenCalledTimes(1);
-  });
-
-  test('Should correctly call response getHeaders method when use getHeaders param', async () => {
-    const data = null;
-    const request = {};
-    const response = { getHeaders: jest.fn() };
-
-    const getHeadersRouteInterceptor: ResponseInterceptor = (data, { getHeaders }) => {
-      getHeaders();
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as Request,
-      response: response as unknown as Response,
-      interceptors: {
-        routeInterceptor: getHeadersRouteInterceptor
-      }
-    });
-    expect(response.getHeaders).toHaveBeenCalledWith();
-    expect(response.getHeaders).toHaveBeenCalledTimes(1);
-  });
-
-  test('Should correctly call response set method when use setHeader param', async () => {
-    const data = null;
-    const request = {};
-    const response = { set: jest.fn() };
-
-    const setHeaderRouteInterceptor: ResponseInterceptor = (data, { setHeader }) => {
-      setHeader('name', 'value');
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as Request,
-      response: response as unknown as Response,
-      interceptors: {
-        routeInterceptor: setHeaderRouteInterceptor
-      }
-    });
-    expect(response.set).toHaveBeenCalledWith('name', 'value');
-    expect(response.set).toHaveBeenCalledTimes(1);
-  });
-
-  test('Should correctly call response append method when use appendHeader param', async () => {
-    const data = null;
-    const request = {};
-    const response = { append: jest.fn() };
-
-    const appendHeaderRouteInterceptor: ResponseInterceptor = (data, { appendHeader }) => {
-      appendHeader('name', 'value');
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as Request,
-      response: response as unknown as Response,
-      interceptors: {
-        routeInterceptor: appendHeaderRouteInterceptor
-      }
-    });
-    expect(response.append).toHaveBeenCalledWith('name', 'value');
-    expect(response.append).toHaveBeenCalledTimes(1);
-  });
-
-  test('Should correctly set statusCode into response when use setStatusCode param', async () => {
-    const data = null;
-    const request = {} as Request;
-    const response = {} as Response;
-
-    const setStatusCodeRouteInterceptor: ResponseInterceptor = (data, { setStatusCode }) => {
-      setStatusCode(204);
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request,
-      response,
-      interceptors: {
-        routeInterceptor: setStatusCodeRouteInterceptor
-      }
-    });
-    expect(response.statusCode).toBe(204);
-  });
-
-  test('Should correctly get cookie from request.cookies object when use getCookie param', async () => {
-    const data = null;
-    const request = { cookies: { name: 'value' } };
-    const response = {};
-
-    const getCookieRouteInterceptor: ResponseInterceptor = (data, { getCookie }) => {
-      expect(getCookie('name')).toBe('value');
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as unknown as Request,
-      response: response as Response,
-      interceptors: {
-        routeInterceptor: getCookieRouteInterceptor
-      }
-    });
-  });
-
-  test('Should correctly call response cookie method with/without options when use setCookie param', async () => {
-    const data = null;
-    const request = {};
-    const response = { cookie: jest.fn() };
-
-    const setCookieWithoutOptionsRouteInterceptor: ResponseInterceptor = (data, { setCookie }) => {
-      setCookie('name', 'value');
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as Request,
-      response: response as unknown as Response,
-      interceptors: {
-        routeInterceptor: setCookieWithoutOptionsRouteInterceptor
-      }
-    });
-    expect(response.cookie).toHaveBeenCalledWith('name', 'value');
-    expect(response.cookie).toHaveBeenCalledTimes(1);
-
-    response.cookie.mockClear();
-
-    const setCookieWithOptionsRouteInterceptor: ResponseInterceptor = (data, { setCookie }) => {
-      setCookie('name', 'value', { path: '/your/path' });
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as Request,
-      response: response as unknown as Response,
-      interceptors: {
-        routeInterceptor: setCookieWithOptionsRouteInterceptor
-      }
-    });
-    expect(response.cookie).toHaveBeenCalledWith('name', 'value', { path: '/your/path' });
-    expect(response.cookie).toBeCalledTimes(1);
-  });
-
-  test('Should correctly call response clearCookie method when use clearCookie param', async () => {
-    const data = null;
-    const request = {};
-    const response = { clearCookie: jest.fn() };
-
-    const clearCookieRouteInterceptor: ResponseInterceptor = (data, { clearCookie }) => {
-      clearCookie('name', { path: '/your/path' });
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as Request,
-      response: response as unknown as Response,
-      interceptors: {
-        routeInterceptor: clearCookieRouteInterceptor
-      }
-    });
-    expect(response.clearCookie).toHaveBeenCalledWith('name', { path: '/your/path' });
-    expect(response.clearCookie).toHaveBeenCalledTimes(1);
-  });
-
-  test('Should correctly call response attachment method when use attachment param', async () => {
-    const data = null;
-    const request = {};
-    const response = { attachment: jest.fn() };
-
-    const attachmentRouteInterceptor: ResponseInterceptor = (data, { attachment }) => {
-      attachment('filename');
-      return data;
-    };
-    await callResponseInterceptors({
-      data,
-      request: request as Request,
-      response: response as unknown as Response,
-      interceptors: {
-        routeInterceptor: attachmentRouteInterceptor
-      }
-    });
-    expect(response.attachment).toHaveBeenCalledWith('filename');
-    expect(response.attachment).toHaveBeenCalledTimes(1);
-  });
-});

package/dist/src/utils/helpers/isPlainObject/isPlainObject.test.ts

@@ -1,20 +0,0 @@
-import { isPlainObject } from './isPlainObject';
-
-describe('isPlainObject', () => {
-  test('Object value should return true', () => {
-    expect(isPlainObject(Object({}))).toBe(true);
-  });
-
-  test('All Primitive, array, function values should return false', () => {
-    expect(isPlainObject(Number(1))).toBe(false);
-    expect(isPlainObject(BigInt(9007199254740991n))).toBe(false);
-    expect(isPlainObject(String('test'))).toBe(false);
-    expect(isPlainObject(Boolean(true))).toBe(false);
-    expect(isPlainObject(Symbol('test'))).toBe(false);
-    expect(isPlainObject(Array([]))).toBe(false);
-    expect(isPlainObject(() => {})).toBe(false);
-    expect(isPlainObject(undefined)).toBe(false);
-    expect(isPlainObject(null)).toBe(false);
-    expect(isPlainObject(/\d/)).toBe(false);
-  });
-});

package/dist/src/utils/helpers/isPrimitive/isPrimitive.test.ts

@@ -1,26 +0,0 @@
-import { isPrimitive } from './isPrimitive';
-
-describe('isPrimitive', () => {
-  test('Object value should return false', () => {
-    expect(isPrimitive(Object({}))).toBe(false);
-  });
-
-  test('Function value should return false', () => {
-    expect(isPrimitive(() => {})).toBe(false);
-  });
-
-  test('Array value should return false', () => {
-    expect(isPrimitive(Array([]))).toBe(false);
-  });
-
-  test('All Primitives should return true', () => {
-    expect(isPrimitive(Boolean(true))).toBe(true);
-    expect(isPrimitive(Number(1))).toBe(true);
-    expect(isPrimitive(BigInt(9007199254740991n))).toBe(true);
-    expect(isPrimitive(String())).toBe(true);
-    expect(isPrimitive(String('test'))).toBe(true);
-    expect(isPrimitive(Symbol('test'))).toBe(true);
-    expect(isPrimitive(undefined)).toBe(true);
-    expect(isPrimitive(null)).toBe(true);
-  });
-});

package/dist/src/utils/helpers/isRegExp/isRegExp.test.ts

@@ -1,20 +0,0 @@
-import { isRegExp } from './isRegExp';
-
-describe('isRegExp', () => {
-  test('RegExp value should return true', () => {
-    expect(isRegExp(/\d/)).toBe(true);
-  });
-
-  test('All Primitive, array, object, function values should return false', () => {
-    expect(isRegExp(Number(1))).toBe(false);
-    expect(isRegExp(BigInt(9007199254740991n))).toBe(false);
-    expect(isRegExp(String('test'))).toBe(false);
-    expect(isRegExp(Boolean(true))).toBe(false);
-    expect(isRegExp(Symbol('test'))).toBe(false);
-    expect(isRegExp(Array([]))).toBe(false);
-    expect(isRegExp(Object({}))).toBe(false);
-    expect(isRegExp(() => {})).toBe(false);
-    expect(isRegExp(undefined)).toBe(false);
-    expect(isRegExp(null)).toBe(false);
-  });
-});

package/dist/src/utils/helpers/url/convertWin32PathToUnix/convertWin32PathToUnix.test.ts

@@ -1,21 +0,0 @@
-import { convertWin32PathToUnix } from './convertWin32PathToUnix';
-
-describe('convertWin32PathToUnix', () => {
-  test('Should correctly convert Windows-like path to Unix-like', () => {
-    expect(convertWin32PathToUnix('C:\\mock-config-server\\dist\\src\\static\\views')).toEqual(
-      'C:/mock-config-server/dist/src/static/views'
-    );
-  });
-
-  test('Should correctly convert long Windows-like path to Unix-like', () => {
-    expect(convertWin32PathToUnix('\\\\?\\mock-config-server\\dist\\src\\static\\views')).toEqual(
-      'mock-config-server/dist/src/static/views'
-    );
-  });
-
-  test('Should correctly convert Windows-like path with double backslashes to Unix-like', () => {
-    expect(convertWin32PathToUnix('C:\\\\mock-config-server\\dist\\src\\static\\views')).toEqual(
-      'C:/mock-config-server/dist/src/static/views'
-    );
-  });
-});

package/dist/src/utils/helpers/url/getUrlParts/getUrlParts.test.ts

@@ -1,8 +0,0 @@
-import { getUrlParts } from './getUrlParts';
-
-describe('getUrlParts', () => {
-  test('Should correct parse url parts', () => {
-    expect(getUrlParts('/part1/part2/')).toEqual(['part1', 'part2']);
-    expect(getUrlParts('//part1/part2///')).toEqual(['part1', 'part2']);
-  });
-});

package/dist/src/utils/helpers/url/removeLeadingAndTrailingSlashes/removeLeadingAndTrailingSlashes.test.ts

@@ -1,10 +0,0 @@
-import { removeLeadingAndTrailingSlashes } from './removeLeadingAndTrailingSlashes';
-
-describe('removeLeadingAndTrailingSlashes', () => {
-  test('Should correct remove leading and trailing slashes', () => {
-    expect(removeLeadingAndTrailingSlashes('///base/users/1')).toEqual('base/users/1');
-    expect(removeLeadingAndTrailingSlashes('//base/users/1///')).toEqual('base/users/1');
-    expect(removeLeadingAndTrailingSlashes('base/users/1/')).toEqual('base/users/1');
-    expect(removeLeadingAndTrailingSlashes('/base/users/1')).toEqual('base/users/1');
-  });
-});

package/dist/src/utils/helpers/url/urlJoin/urlJoin.test.ts

@@ -1,9 +0,0 @@
-import { urlJoin } from './urlJoin';
-
-describe('urlJoin', () => {
-  test('Should correctly merge paths', () => {
-    expect(urlJoin('/base', '/rest')).toEqual('/base/rest');
-    expect(urlJoin('/base', 'rest')).toEqual('/base/rest');
-    expect(urlJoin('/base', 'rest', '/users')).toEqual('/base/rest/users');
-  });
-});