mock-config-server 1.0.3 → 2.0.0

package/dist/src/routes/createRoutes/createRoutes.test.js

@@ -1,276 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const express_1 = __importDefault(require("express"));
-const supertest_1 = __importDefault(require("supertest"));
-const createRoutes_1 = require("./createRoutes");
-describe('createRoutes', () => {
-    const createServer = (mockServerConfig) => {
-        const server = (0, express_1.default)();
-        const routerBase = express_1.default.Router();
-        const routerWithRoutes = (0, createRoutes_1.createRoutes)(routerBase, mockServerConfig);
-        server.use(express_1.default.json());
-        server.use(mockServerConfig.baseUrl ?? '/', routerWithRoutes);
-        return server;
-    };
-    test('Should match config by entities "includes" behavior', async () => {
-        const server = createServer({
-            configs: [
-                {
-                    path: '/users',
-                    method: 'get',
-                    routes: [
-                        {
-                            entities: {
-                                headers: { key1: 'value1', key2: 'value2' },
-                                query: { key1: 'value1' }
-                            },
-                            data: { name: 'John', surname: 'Doe' }
-                        }
-                    ]
-                }
-            ]
-        });
-        const response = await (0, supertest_1.default)(server)
-            .get('/users')
-            .set({ key1: 'value1', key2: 'value2' })
-            .query({ key1: 'value1', key2: 'value2' });
-        expect(response.statusCode).toBe(200);
-        expect(response.body).toStrictEqual({ name: 'John', surname: 'Doe' });
-    });
-    test('Should give priority to more specific route config', async () => {
-        const server = createServer({
-            configs: [
-                {
-                    path: '/users',
-                    method: 'get',
-                    routes: [
-                        {
-                            entities: {
-                                headers: { key1: 'value1', key2: 'value2' },
-                                query: { key1: 'value1' }
-                            },
-                            data: { name: 'John', surname: 'Doe' }
-                        },
-                        {
-                            entities: {
-                                headers: { key1: 'value1', key2: 'value2' },
-                                query: { key1: 'value1', key2: 'value2' }
-                            },
-                            data: { name: 'John', surname: 'Smith' }
-                        }
-                    ]
-                }
-            ]
-        });
-        const response = await (0, supertest_1.default)(server)
-            .get('/users')
-            .set({ key1: 'value1', key2: 'value2', key3: 'value3' })
-            .query({ key1: 'value1', key2: 'value2', key3: 'value3' });
-        expect(response.statusCode).toBe(200);
-        expect(response.body).toStrictEqual({ name: 'John', surname: 'Smith' });
-    });
-    test('Should return 404 and description text for no matched request entities', async () => {
-        const server = createServer({
-            configs: [
-                {
-                    path: '/users',
-                    method: 'get',
-                    routes: [
-                        {
-                            entities: {
-                                headers: { key1: 'value1' }
-                            },
-                            data: { name: 'John', surname: 'Doe' }
-                        }
-                    ]
-                }
-            ]
-        });
-        const response = await (0, supertest_1.default)(server).get('/users').set({ key2: 'value2' });
-        expect(response.statusCode).toBe(404);
-        expect(response.body).toBe('No data for GET:/users');
-    });
-    test('Should compare non plain object body by full equal behavior', async () => {
-        const server = createServer({
-            configs: [
-                {
-                    path: '/users',
-                    method: 'post',
-                    routes: [
-                        {
-                            entities: {
-                                body: [
-                                    {
-                                        key1: 'value1',
-                                        key2: { nestedKey1: 'nestedValue1' }
-                                    }
-                                ]
-                            },
-                            data: { name: 'John', surname: 'Doe' }
-                        }
-                    ]
-                }
-            ]
-        });
-        const successResponse = await (0, supertest_1.default)(server)
-            .post('/users')
-            .set('Content-Type', 'application/json')
-            .send([{ key1: 'value1', key2: { nestedKey1: 'nestedValue1' } }]);
-        expect(successResponse.statusCode).toBe(200);
-        expect(successResponse.body).toStrictEqual({ name: 'John', surname: 'Doe' });
-        const failedResponse = await (0, supertest_1.default)(server)
-            .post('/users')
-            .set('Content-Type', 'application/json')
-            .send([{ key1: 'value1', key2: { nestedKey1: 'nestedValue1', nestedKey2: 'nestedValue2' } }]);
-        expect(failedResponse.statusCode).toBe(404);
-        expect(failedResponse.body).toBe('No data for POST:/users');
-    });
-    test('Should compare plain object body by "includes" behavior', async () => {
-        const server = createServer({
-            configs: [
-                {
-                    path: '/users',
-                    method: 'post',
-                    routes: [
-                        {
-                            entities: {
-                                body: {
-                                    key1: 'value1',
-                                    key2: { nestedKey1: 'nestedValue1' }
-                                }
-                            },
-                            data: { name: 'John', surname: 'Doe' }
-                        }
-                    ]
-                }
-            ]
-        });
-        const response = await (0, supertest_1.default)(server)
-            .post('/users')
-            .set('Content-Type', 'application/json')
-            .send({ key1: 'value1', key2: { nestedKey1: 'nestedValue1', nestedKey2: 'nestedValue2' } });
-        expect(response.statusCode).toBe(200);
-        expect(response.body).toStrictEqual({ name: 'John', surname: 'Doe' });
-    });
-    test('Should call request interceptors in order: request -> server', async () => {
-        const requestInterceptor = jest.fn();
-        const serverInterceptor = jest.fn();
-        const server = createServer({
-            configs: [
-                {
-                    path: '/users',
-                    method: 'post',
-                    routes: [
-                        {
-                            entities: {
-                                body: {
-                                    key1: 'value1',
-                                    key2: 'value2'
-                                }
-                            },
-                            data: { name: 'John', surname: 'Doe' }
-                        }
-                    ],
-                    interceptors: { request: requestInterceptor }
-                },
-                {
-                    path: '/settings',
-                    method: 'post',
-                    routes: [
-                        {
-                            entities: {
-                                body: {
-                                    key1: 'value1',
-                                    key2: 'value2'
-                                }
-                            },
-                            data: { name: 'John', surname: 'Smith' }
-                        }
-                    ]
-                }
-            ],
-            interceptors: { request: serverInterceptor }
-        });
-        await (0, supertest_1.default)(server)
-            .post('/users')
-            .set('Content-Type', 'application/json')
-            .send({ key1: 'value1', key2: 'value2' });
-        expect(requestInterceptor.mock.calls.length).toBe(1);
-        expect(serverInterceptor.mock.calls.length).toBe(1);
-        expect(requestInterceptor.mock.invocationCallOrder[0]).toBeLessThan(serverInterceptor.mock.invocationCallOrder[0]);
-        await (0, supertest_1.default)(server)
-            .post('/settings')
-            .set('Content-Type', 'application/json')
-            .send({ key1: 'value1', key2: 'value2' });
-        expect(requestInterceptor.mock.calls.length).toBe(1);
-        expect(serverInterceptor.mock.calls.length).toBe(2);
-    });
-    test('Should call response interceptors in order: route -> request -> server', async () => {
-        const routeInterceptor = jest.fn();
-        const requestInterceptor = jest.fn();
-        const serverInterceptor = jest.fn();
-        const server = createServer({
-            configs: [
-                {
-                    path: '/users',
-                    method: 'post',
-                    routes: [
-                        {
-                            entities: {
-                                body: {
-                                    key1: 'value1',
-                                    key2: 'value2'
-                                }
-                            },
-                            data: { name: 'John', surname: 'Doe' },
-                            interceptors: { response: routeInterceptor }
-                        }
-                    ],
-                    interceptors: { response: requestInterceptor }
-                },
-                {
-                    path: '/settings',
-                    method: 'post',
-                    routes: [
-                        {
-                            entities: {
-                                body: {
-                                    key1: 'value1',
-                                    key2: 'value2'
-                                }
-                            },
-                            data: { name: 'John', surname: 'Smith' }
-                        }
-                    ]
-                }
-            ],
-            interceptors: { response: serverInterceptor }
-        });
-        await (0, supertest_1.default)(server)
-            .post('/users')
-            .set('Content-Type', 'application/json')
-            .send({ key1: 'value1', key2: 'value2' });
-        expect(routeInterceptor.mock.calls.length).toBe(1);
-        expect(requestInterceptor.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(serverInterceptor.mock.invocationCallOrder[0]);
-        await (0, supertest_1.default)(server)
-            .post('/settings')
-            .set('Content-Type', 'application/json')
-            .send({ key1: 'value1', key2: 'value2' });
-        expect(routeInterceptor.mock.calls.length).toBe(1);
-        expect(requestInterceptor.mock.calls.length).toBe(1);
-        expect(serverInterceptor.mock.calls.length).toBe(2);
-        await (0, supertest_1.default)(server)
-            .post('/messages')
-            .set('Content-Type', 'application/json')
-            .send({ key1: 'value1', key2: 'value2' });
-        expect(routeInterceptor.mock.calls.length).toBe(1);
-        expect(requestInterceptor.mock.calls.length).toBe(1);
-        expect(serverInterceptor.mock.calls.length).toBe(2);
-    });
-});