mock-config-server 3.3.1 → 3.3.2

package/dist/src/core/graphql/createGraphQLRoutes/helpers/prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs.test.ts

@@ -1,116 +0,0 @@
-import type { GraphQLRequestConfig } from '@/utils/types';
-
-import { prepareGraphQLRequestConfigs } from './prepareGraphQLRequestConfigs';
-
-describe('prepareGraphQLRequestConfigs', () => {
-  test('Should not sort routes if they does not contain entities', () => {
-    const GraphQLRequestConfigs: GraphQLRequestConfig[] = [
-      {
-        operationName: 'GetUser',
-        operationType: 'query',
-        routes: [
-          {
-            data: { name: 'John', surname: 'Doe' }
-          },
-          {
-            data: { name: 'John', surname: 'Smith' }
-          },
-          {
-            data: { name: 'John', surname: 'John' }
-          }
-        ]
-      }
-    ];
-    expect(prepareGraphQLRequestConfigs(GraphQLRequestConfigs)).toStrictEqual(
-      GraphQLRequestConfigs
-    );
-  });
-
-  test('Should sort routes by their specificity of entities', () => {
-    const GraphQLRequestConfigs: GraphQLRequestConfig[] = [
-      {
-        operationName: 'GetUser',
-        operationType: 'query',
-        routes: [
-          {
-            entities: {
-              headers: {
-                header1: 'value'
-              }
-            },
-            data: { name: 'John', surname: 'Doe' }
-          },
-          {
-            entities: {
-              headers: {
-                header1: 'value',
-                header2: 'value'
-              }
-            },
-            data: { name: 'John', surname: 'Doe' }
-          },
-          {
-            entities: {
-              headers: {
-                header1: 'value'
-              },
-              query: {
-                query1: 'value',
-                query2: 'value'
-              },
-              variables: {
-                variable1: 'value1',
-                variable2: 'value2'
-              }
-            },
-            data: { name: 'John', surname: 'Doe' }
-          }
-        ]
-      }
-    ];
-    const expectedGraphQLRequestConfigs: GraphQLRequestConfig[] = [
-      {
-        operationName: 'GetUser',
-        operationType: 'query',
-        routes: [
-          {
-            entities: {
-              headers: {
-                header1: 'value'
-              },
-              query: {
-                query1: 'value',
-                query2: 'value'
-              },
-              variables: {
-                variable1: 'value1',
-                variable2: 'value2'
-              }
-            },
-            data: { name: 'John', surname: 'Doe' }
-          },
-          {
-            entities: {
-              headers: {
-                header1: 'value',
-                header2: 'value'
-              }
-            },
-            data: { name: 'John', surname: 'Doe' }
-          },
-          {
-            entities: {
-              headers: {
-                header1: 'value'
-              }
-            },
-            data: { name: 'John', surname: 'Doe' }
-          }
-        ]
-      }
-    ];
-    expect(prepareGraphQLRequestConfigs(GraphQLRequestConfigs)).toStrictEqual(
-      expectedGraphQLRequestConfigs
-    );
-  });
-});

package/dist/src/core/middlewares/cookieParseMiddleware/cookieParseMiddleware.test.ts

@@ -1,22 +0,0 @@
-import express from 'express';
-import request from 'supertest';
-
-import { cookieParseMiddleware } from './cookieParseMiddleware';
-
-describe('cookieParseMiddleware', () => {
-  test('Should correctly parse cookies', async () => {
-    const server = express();
-    cookieParseMiddleware(server);
-
-    let parsedCookies = {};
-
-    server.use((request, _response, next) => {
-      parsedCookies = request.cookies;
-      next();
-    });
-
-    await request(server).get('/').set({ cookie: 'key=value' });
-
-    expect(parsedCookies).toEqual({ key: 'value' });
-  });
-});

package/dist/src/core/middlewares/cookieParseMiddleware/helpers/parseCookie/parseCookie.test.ts

@@ -1,45 +0,0 @@
-import { parseCookie } from './parseCookie';
-
-describe('parseCookie', () => {
-  test('Should return an empty object for empty string', () => {
-    const cookieString = '';
-    const cookies = parseCookie(cookieString);
-
-    expect(cookies).toEqual({});
-  });
-
-  test('Should return an object with a single key-value pair', () => {
-    const cookieString = 'name=value';
-    const cookies = parseCookie(cookieString);
-
-    expect(cookies).toEqual({ name: 'value' });
-  });
-
-  test('Should return an object with multiple key-value pairs for a cookie string with multiple key-value pairs', () => {
-    const cookieString = 'name1=value1; name2=value2; name3=value3';
-    const cookies = parseCookie(cookieString);
-
-    expect(cookies).toEqual({ name1: 'value1', name2: 'value2', name3: 'value3' });
-  });
-
-  test('Should handle cookies with no value by setting the value to an empty string', () => {
-    const cookieString = 'name1';
-    const cookies = parseCookie(cookieString);
-
-    expect(cookies).toEqual({ name1: '' });
-  });
-
-  test('Should trim whitespace from keys and values', () => {
-    const cookieString = ' name1 = value1 ; name2=value2;  name3   =   value3   ';
-    const cookies = parseCookie(cookieString);
-
-    expect(cookies).toEqual({ name1: 'value1', name2: 'value2', name3: 'value3' });
-  });
-
-  test('Should ignore cookies with no name', () => {
-    const cookieString = '=value';
-    const cookies = parseCookie(cookieString);
-
-    expect(cookies).toEqual({});
-  });
-});

package/dist/src/core/middlewares/corsMiddleware/corsMiddleware.test.ts

@@ -1,152 +0,0 @@
-import express from 'express';
-import request from 'supertest';
-
-import type { Cors } from '@/utils/types';
-
-import { corsMiddleware } from './corsMiddleware';
-
-describe('corsMiddleware', () => {
-  const testOrigin = 'https://test.com';
-
-  test('Should set default cors for OPTIONS preflight request if does not set custom cors settings', async () => {
-    const server = express();
-    const cors: Cors = {
-      origin: testOrigin
-    };
-
-    corsMiddleware(server, cors);
-
-    const response = await request(server).options('/').set({ origin: testOrigin });
-
-    expect(response.headers).toMatchObject({
-      'access-control-allow-headers': '*',
-      'access-control-expose-headers': '*',
-      'access-control-allow-methods': 'GET,OPTIONS,PUT,PATCH,POST,DELETE',
-      'access-control-allow-origin': 'https://test.com',
-      'access-control-max-age': '3600',
-      'access-control-allow-credentials': 'true'
-    });
-  });
-
-  test('Should set default cors for request if does not set custom cors settings', async () => {
-    const server = express();
-    const cors: Cors = {
-      origin: testOrigin
-    };
-
-    corsMiddleware(server, cors);
-
-    const response = await request(server).get('/').set({ origin: testOrigin });
-
-    expect(response.headers).toMatchObject({
-      'access-control-allow-origin': 'https://test.com',
-      'access-control-allow-credentials': 'true',
-      'access-control-expose-headers': '*'
-    });
-
-    expect(response.headers).not.toMatchObject({
-      'access-control-allow-headers': expect.any(String),
-      'access-control-allow-methods': expect.any(String),
-      'access-control-max-age': expect.any(String)
-    });
-  });
-
-  const unsuitableOrigins = [
-    'https://uncorrectDomain.com',
-    [],
-    /https:\/\/uncorrectDomain.com/g,
-    () => 'https://uncorrectDomain.com',
-    () => Promise.resolve('https://uncorrectDomain.com')
-  ];
-
-  unsuitableOrigins.forEach((unsuitableOrigin) => {
-    test('Should not set default cors for OPTIONS preflight request if origin does not match', async () => {
-      const server = express();
-      const cors: Cors = {
-        origin: unsuitableOrigin
-      };
-
-      corsMiddleware(server, cors);
-
-      const response = await request(server).options('/').set({ origin: testOrigin });
-
-      expect(response.headers).not.toMatchObject({
-        'access-control-allow-headers': expect.any(String),
-        'access-control-expose-headers': expect.any(String),
-        'access-control-allow-methods': expect.any(String),
-        'access-control-allow-origin': expect.any(String),
-        'access-control-max-age': expect.any(String),
-        'access-control-allow-credentials': expect.any(String)
-      });
-    });
-
-    test('Should not set cors for request if origin does not match', async () => {
-      const server = express();
-      const cors: Cors = {
-        origin: unsuitableOrigin
-      };
-
-      corsMiddleware(server, cors);
-
-      const response = await request(server).get('/').set({ origin: testOrigin });
-
-      expect(response.headers).not.toMatchObject({
-        'access-control-allow-origin': expect.any(String),
-        'access-control-allow-credentials': expect.any(String),
-        'access-control-expose-headers': expect.any(String)
-      });
-    });
-  });
-
-  const corsParamsAndHeaders: { params: Omit<Cors, 'origin'>; headers: Record<string, string> }[] =
-    [
-      {
-        params: { allowedHeaders: ['header1', 'header2'] },
-        headers: {
-          'access-control-allow-headers': 'header1, header2'
-        }
-      },
-      {
-        params: { exposedHeaders: ['header1', 'header2'] },
-        headers: {
-          'access-control-expose-headers': 'header1, header2'
-        }
-      },
-      {
-        params: { maxAge: 10000 },
-        headers: {
-          'access-control-max-age': '10000'
-        }
-      },
-      {
-        params: { methods: ['GET', 'POST'] },
-        headers: {
-          'access-control-allow-methods': 'GET, POST'
-        }
-      },
-      {
-        params: { credentials: false },
-        headers: {
-          'access-control-allow-credentials': 'false'
-        }
-      }
-    ];
-
-  corsParamsAndHeaders.forEach(({ params, headers }) =>
-    test(`Should set allow param(s) ${Object.keys(params).join(', ')} to header(s) ${Object.keys(
-      headers
-    ).join(', ')}`, async () => {
-      const server = express();
-      const cors: Cors = {
-        origin: testOrigin,
-        ...params
-      };
-
-      corsMiddleware(server, cors);
-
-      const response = await request(server).options('/').set({ origin: testOrigin });
-
-      expect(response.headers).toMatchObject(headers);
-    })
-  );
-});

package/dist/src/core/middlewares/corsMiddleware/helpers/getAllowedOrigins/getAllowedOrigins.test.ts

@@ -1,15 +0,0 @@
-import { getAllowedOrigins } from './getAllowedOrigins';
-
-describe('getAllowedOrigins', () => {
-  test('Function should return array if get string or RegExp parameter', () => {
-    expect(getAllowedOrigins(/origin/g)).toEqual([/origin/g]);
-    expect(getAllowedOrigins('https://origin.com')).toEqual(['https://origin.com']);
-  });
-
-  test('Function should return array if get array parameter', () => {
-    expect(getAllowedOrigins([/origin/g, 'https://origin.com'])).toEqual([
-      /origin/g,
-      'https://origin.com'
-    ]);
-  });
-});

package/dist/src/core/middlewares/errorMiddleware/errorMiddleware.test.ts

@@ -1,29 +0,0 @@
-import express from 'express';
-import request from 'supertest';
-
-import { errorMiddleware } from './errorMiddleware';
-
-describe('errorMiddleware', () => {
-  test('Should handle error from server handler', async () => {
-    const server = express();
-
-    server.get('/error', () => {
-      throw new Error('error');
-    });
-
-    server.get('/success', (_request, response) => {
-      response.send('success');
-    });
-
-    errorMiddleware(server);
-
-    const errorResponse = await request(server).get('/error');
-    const successResponse = await request(server).get('/success');
-
-    expect(errorResponse.status).toEqual(500);
-    expect(errorResponse.text).toContain('error');
-
-    expect(successResponse.status).toEqual(200);
-    expect(successResponse.text).toEqual('success');
-  });
-});

package/dist/src/core/middlewares/noCorsMiddleware/noCorsMiddleware.test.ts

@@ -1,49 +0,0 @@
-import express from 'express';
-import request from 'supertest';
-
-import { noCorsMiddleware } from './noCorsMiddleware';
-
-describe('noCorsMiddleware', () => {
-  test('Should set no cors settings for OPTIONS preflight request', async () => {
-    const server = express();
-
-    noCorsMiddleware(server);
-
-    const preflightHeaders = {
-      'access-control-request-method': 'GET,OPTIONS,PUT,PATCH,POST,DELETE',
-      'access-control-request-headers': '*',
-      origin: '/'
-    };
-    const response = await request(server).options('/').set(preflightHeaders);
-
-    expect(response.headers).toMatchObject({
-      'access-control-allow-origin': '*',
-      'access-control-allow-credentials': 'true',
-      'access-control-expose-headers': '*',
-      'access-control-allow-headers': '*',
-      'access-control-allow-methods': 'GET,OPTIONS,PUT,PATCH,POST,DELETE',
-      'access-control-max-age': '3600'
-    });
-    expect(response.statusCode).toBe(204);
-  });
-
-  test('Should set no cors settings for request', async () => {
-    const server = express();
-
-    noCorsMiddleware(server);
-
-    const response = await request(server).get('/');
-
-    expect(response.headers).toMatchObject({
-      'access-control-allow-origin': '*',
-      'access-control-allow-credentials': 'true',
-      'access-control-expose-headers': '*'
-    });
-
-    expect(response.headers).not.toMatchObject({
-      'access-control-allow-headers': expect.any(String),
-      'access-control-allow-methods': expect.any(String),
-      'access-control-max-age': expect.any(String)
-    });
-  });
-});

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getGraphqlUrlSuggestions/getGraphqlUrlSuggestions.test.ts

@@ -1,27 +0,0 @@
-import type { GraphqlRequestSuggestionConfigs } from './getGraphqlUrlSuggestions';
-import { getGraphqlUrlSuggestions } from './getGraphqlUrlSuggestions';
-
-describe('getGraphqlUrlSuggestions', () => {
-  test('Should correctly return suggestions', () => {
-    const requestConfigs: GraphqlRequestSuggestionConfigs = [
-      { operationType: 'query', operationName: '/GetDevelopers' },
-      { operationType: 'mutation', operationName: '/CreateDeveloper' }
-    ];
-    expect(
-      getGraphqlUrlSuggestions({
-        url: new URL('http://localhost:31299/?query=query Getdevoper { developers }}'),
-        requestConfigs
-      })
-    ).toEqual([
-      { operationType: 'query', operationName: '/GetDevelopers' },
-      { operationType: 'mutation', operationName: '/CreateDeveloper' }
-    ]);
-
-    expect(
-      getGraphqlUrlSuggestions({
-        url: new URL('http://localhost:31299/?query=query devel { developers }}'),
-        requestConfigs
-      })
-    ).toEqual([]);
-  });
-});

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getLevenshteinDistance/getLevenshteinDistance.test.ts

@@ -1,12 +0,0 @@
-import { getLevenshteinDistance } from './getLevenshteinDistance';
-
-describe('getLevenshteinDistance', () => {
-  test('Should correct return Levenshtein distance', () => {
-    expect(getLevenshteinDistance('users', 'users')).toEqual(0);
-    expect(getLevenshteinDistance('psts', 'posts')).toEqual(1);
-    expect(getLevenshteinDistance('postss', 'posts')).toEqual(1);
-    expect(getLevenshteinDistance('users', 'Users')).toEqual(1);
-    expect(getLevenshteinDistance('1234', '1234567')).toEqual(3);
-    expect(getLevenshteinDistance('', '1234')).toEqual(4);
-  });
-});

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/getRestUrlSuggestions.test.ts

@@ -1,54 +0,0 @@
-import type { RestRequestSuggestionConfigs } from './getRestUrlSuggestions';
-import { getRestUrlSuggestions } from './getRestUrlSuggestions';
-
-describe('getRestUrlSuggestions', () => {
-  test('Should correctly return suggestions', () => {
-    const requestConfigs: RestRequestSuggestionConfigs = [
-      { method: 'get', path: '/posts/:postId' },
-      { method: 'post', path: '/posts/:postId/comments/:commentId' }
-    ];
-    expect(
-      getRestUrlSuggestions({
-        url: new URL('http://localhost:31299/posts/5/comments/2'),
-        requestConfigs
-      })
-    ).toEqual([{ method: 'post', path: '/posts/5/comments/2' }]);
-    expect(
-      getRestUrlSuggestions({
-        url: new URL('http://localhost:31299/psts/5/commennts/2'),
-        requestConfigs
-      })
-    ).toEqual([{ method: 'post', path: '/posts/5/comments/2' }]);
-    expect(
-      getRestUrlSuggestions({
-        url: new URL('http://localhost:31299/post/5/omments/2'),
-        requestConfigs
-      })
-    ).toEqual([{ method: 'post', path: '/posts/5/comments/2' }]);
-    expect(
-      getRestUrlSuggestions({
-        url: new URL('http://localhost:31299/ps/5/cots/2'),
-        requestConfigs
-      })
-    ).toEqual([]);
-  });
-
-  test('Should return requests with same query params as provided', () => {
-    const requestConfigs: RestRequestSuggestionConfigs = [
-      { method: 'get', path: '/users' },
-      { method: 'get', path: '/users/:userId' },
-      { method: 'post', path: '/user' },
-      { method: 'post', path: '/login' },
-      { method: 'delete', path: '/logout' }
-    ];
-    expect(
-      getRestUrlSuggestions({
-        url: new URL('http://localhost:31299/login?remember=true?action=success'),
-        requestConfigs
-      })
-    ).toEqual([
-      { method: 'post', path: '/login?remember=true?action=success' },
-      { method: 'delete', path: '/logout?remember=true?action=success' }
-    ]);
-  });
-});

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/helpers/getActualRestUrlMeaningfulString/getActualRestUrlMeaningfulString.test.ts

@@ -1,12 +0,0 @@
-import { getActualRestUrlMeaningfulString } from './getActualRestUrlMeaningfulString';
-
-describe('getActualRestUrlMeaningfulString', () => {
-  test('Should correctly return actual rest meaningful string', () => {
-    expect(
-      getActualRestUrlMeaningfulString(
-        ['base', 'rest', 'posts', '2', 'comments', '5'],
-        ['base', 'rest', 'posts', ':postId', 'comments', ':commentId']
-      )
-    ).toEqual('baserestpostscomments');
-  });
-});

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/helpers/getPatternRestUrlMeaningfulString/getPatternRestUrlMeaningfulString.test.ts

@@ -1,10 +0,0 @@
-import { getPatternRestUrlMeaningfulString } from './getPatternRestUrlMeaningfulString';
-
-describe('getPatternRestUrlMeaningfulString', () => {
-  test('Should correct return rest url pattern meaningful string', () => {
-    expect(
-      getPatternRestUrlMeaningfulString(['rest', 'posts', ':postId', 'comments', ':commentId'])
-    ).toEqual('restpostscomments');
-    expect(getPatternRestUrlMeaningfulString(['users'])).toEqual('users');
-  });
-});