intent/packages/core/tests/unit/rest/http-server/server.test.ts at c895f32cd47fab46c9af0453e7b474281568d3e6 · intentjs/intent · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import { MiddlewareNext } from 'hyper-express';
import { IntentMiddleware } from '../../../../lib/rest';
import { HyperServer } from '../../../../lib/rest/http-server/server';
import { Request, Response } from '@intentjs/hyper-express';
import { ConfigService } from '../../../../lib/config';

jest.mock('../../../../lib/config', () => ({
    ConfigService: {
        get: (key: string) => ({})
    }
}));

describe('HyperServer', () => {
    let server: HyperServer;

    beforeEach(() => {
        server = new HyperServer();
    });

    describe('useGlobalMiddlewares', () => {
        it('should register global middleware', async () => {
            const mockMiddleware = async (req: Request, res: Response, next: MiddlewareNext) => {};

            server.useGlobalMiddlewares([mockMiddleware as unknown as IntentMiddleware]);

            expect(server.globalMiddlewares).toHaveLength(1);
            expect(server.globalMiddlewares[0]).toBe(mockMiddleware);
        });
    });

    describe('build', () => {
        it('should register GET route', async () => {
            const mockRoute = {
                method: 'GET',
                path: '/test',
                httpHandler: jest.fn()
            };

            const routeMiddlewares = new Map();
            routeMiddlewares.set('GET:/test', []);

            server.useRouteMiddlewares(routeMiddlewares);
            await server.build([mockRoute], {});

            const routes = ((server as any).hyper).routes;

            expect(routes).toMatchObject({
                get: {
                    '/test': expect.objectContaining({
                        path: '/test',
                        method: 'GET',
                    })
                },
                post: {},
                put: {},
                del: {}
            });
        });

        it('should register different HTTP method routes', async () => {
            const mockRoutes = [
                {
                    method: 'GET',
                    path: '/test',
                    httpHandler: jest.fn()
                },
                {
                    method: 'POST',
                    path: '/test',
                    httpHandler: jest.fn()
                },
                {
                    method: 'PUT',
                    path: '/test',
                    httpHandler: jest.fn()
                },
                {
                    method: 'DELETE',
                    path: '/test',
                    httpHandler: jest.fn()
                }
            ];

            const routeMiddlewares = new Map();
            routeMiddlewares.set('GET:/test', []);
            routeMiddlewares.set('POST:/test', []);
            routeMiddlewares.set('PUT:/test', []);
            routeMiddlewares.set('DELETE:/test', []);

            server.useRouteMiddlewares(routeMiddlewares);
            await server.build(mockRoutes, {});

            const routes = ((server as any).hyper).routes;
            expect(routes).toMatchObject({
                get: {
                    '/test': expect.objectContaining({
                        path: '/test',
                        method: 'GET',
                    })
                },
                post: {
                    '/test': expect.objectContaining({
                        path: '/test',
                        method: 'POST',
                    })
                },
                put: {
                    '/test': expect.objectContaining({
                        path: '/test',
                        method: 'PUT',
                    })
                },
                del: {
                    '/test': expect.objectContaining({
                        path: '/test',
                        method: 'DELETE',
                    })
                }
            });
        });
    });
});