@seidor-cloud-produtos/orbit-backend-lib 2.0.138 → 2.1.0

package/dist/frameworks/nest/nest.spec.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const authorization_nest_1 = tslib_1.__importDefault(require("./authorizations/authorization-nest"));
+const guard_nest_1 = tslib_1.__importDefault(require("./authorizations/guard-nest"));
+const not_allowed_nest_1 = require("./authorizations/not-allowed-nest");
+const orbit_error_1 = require("./errors/orbit-error");
+const orbit_exception_filter_1 = require("./exception-filters/orbit-exception-filter");
+describe('Nest integrations', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should expose orbit errors as HTTP exceptions', () => {
+        const error = new orbit_error_1.OrbitError('Forbidden', 403);
+        expect(error.getStatus()).toBe(403);
+        expect(error.message).toBe('Forbidden');
+    });
+    it('should expose the not allowed payload for Nest', () => {
+        const timestamp = new Date('2024-01-01T00:00:00.000Z');
+        const error = new not_allowed_nest_1.NestNotAllowedError({
+            status: 401,
+            body: {
+                code: 401,
+                message: 'Unauthorized',
+                timestamp,
+                errors: [
+                    {
+                        code_error: '401',
+                        location: 'authorization',
+                        msg: 'Unauthorized',
+                    },
+                ],
+            },
+            headers: {},
+        });
+        expect(error.getStatus()).toBe(403);
+        expect(error.getResponse()).toEqual({
+            code: 401,
+            message: 'Unauthorized',
+            timestamp,
+            errors: [
+                {
+                    code_error: '401',
+                    location: 'authorization',
+                    msg: 'Unauthorized',
+                },
+            ],
+        });
+        expect(error.message).toBe('Unauthorized');
+    });
+    it('should translate orbit errors in the exception filter', () => {
+        const response = {
+            status: vi.fn().mockReturnThis(),
+            json: vi.fn().mockReturnThis(),
+        };
+        const host = {
+            switchToHttp: () => ({
+                getResponse: () => response,
+            }),
+        };
+        const exception = new not_allowed_nest_1.NestNotAllowedError({
+            status: 403,
+            body: {
+                code: 403,
+                message: 'Forbidden',
+                timestamp: new Date('2024-01-01T00:00:00.000Z'),
+                errors: [],
+            },
+            headers: {},
+        });
+        const filter = new orbit_exception_filter_1.OrbitExceptionFilter();
+        filter.catch(exception, host);
+        expect(response.status).toHaveBeenCalledWith(403);
+        expect(response.json).toHaveBeenCalledWith(exception.getResponse());
+    });
+    it('should authorize or throw on Nest authorization wrappers', async () => {
+        const query = { $and: ['auth.read'] };
+        const request = {
+            headers: {
+                authorizations: '["auth.read"]',
+            },
+        };
+        const response = {};
+        const next = vi.fn();
+        const instance = (await authorization_nest_1.default.create(query, {
+            request,
+            response,
+            next,
+        }));
+        await expect(instance['handleAuthorized']()).resolves.toBe(true);
+        await expect(instance['unauthorize']({
+            status: 403,
+            body: {
+                code: 403,
+                message: 'Forbidden',
+                timestamp: new Date('2024-01-01T00:00:00.000Z'),
+                errors: [],
+            },
+            headers: {},
+        })).rejects.toBeInstanceOf(not_allowed_nest_1.NestNotAllowedError);
+    });
+    it('should validate requests through the Nest guard', async () => {
+        const validate = vi.fn().mockResolvedValue(true);
+        const createSpy = vi
+            .spyOn(authorization_nest_1.default, 'create')
+            .mockResolvedValue({ validate });
+        const request = {};
+        const response = {};
+        const next = vi.fn();
+        const guard = new guard_nest_1.default({ $or: ['auth.read'] });
+        const context = {
+            switchToHttp: () => ({
+                getRequest: () => request,
+                getResponse: () => response,
+                getNext: () => next,
+            }),
+        };
+        await expect(guard.canActivate(context)).resolves.toBe(true);
+        expect(createSpy).toHaveBeenCalledWith({ $or: ['auth.read'] }, { request, response, next });
+        expect(validate).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/infra/http/api-gateway/mapping-model.spec.js

@@ -132,5 +132,47 @@ describe('MappingModel', () => {
             expect(instance['deleteParams'].mock.calls.length).toBe(1);
             expect(instance['next'].mock.calls.length).toBe(1);
         });
+        it('should create an empty context when it is missing', () => {
+            const instance = new MockMappingModel(undefined);
+            instance['getBody'] = vi.fn().mockReturnValue({
+                ['api-gateway-params']: {
+                    header: {},
+                    querystring: {},
+                    path: {},
+                },
+            });
+            instance['next'] = vi.fn().mockReturnValue('next func');
+            instance['setHeader'] = vi.fn().mockReturnThis();
+            instance['deleteParams'] = vi.fn().mockReturnThis();
+            expect(instance.parse()).toBe('next func');
+            expect(instance['setHeader'].mock.calls).toStrictEqual([
+                ['authorizations', undefined],
+                ['fiscalidsfromtenant', '[]'],
+                ['accept-encoding', 'identity'],
+            ]);
+        });
+        it('should map fiscal ids from tenant into headers', () => {
+            const instance = new MockMappingModel(undefined);
+            instance['getBody'] = vi.fn().mockReturnValue({
+                ['api-gateway-params']: {
+                    context: {
+                        authorizations: ['test'],
+                        fiscalIdsFromTenant: ['123', '456'],
+                    },
+                    header: {},
+                    querystring: {},
+                    path: {},
+                },
+            });
+            instance['next'] = vi.fn().mockReturnValue('next func');
+            instance['setHeader'] = vi.fn().mockReturnThis();
+            instance['deleteParams'] = vi.fn().mockReturnThis();
+            expect(instance.parse()).toBe('next func');
+            expect(instance['setHeader'].mock.calls).toStrictEqual([
+                ['authorizations', ['test']],
+                ['fiscalidsfromtenant', '["123","456"]'],
+                ['accept-encoding', 'identity'],
+            ]);
+        });
     });
 });