@flusys/nestjs-shared 7.1.0 → 8.0.0-beta.1

package/cjs/filters/global-exception.filter.spec.js

@@ -1,440 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _typeorm = require("typeorm");
-const _globalexceptionfilter = require("./global-exception.filter");
-const _baseappexception = require("../exceptions/base-app.exception");
-const _messagekeys = require("../constants/message-keys");
-const mockGetRequestId = jest.fn();
-const mockGetUserId = jest.fn();
-const mockGetTenantId = jest.fn();
-const mockGetCompanyId = jest.fn();
-jest.mock('../middlewares/logger.middleware', ()=>({
-        getRequestId: (...args)=>mockGetRequestId(...args),
-        getUserId: (...args)=>mockGetUserId(...args),
-        getTenantId: (...args)=>mockGetTenantId(...args),
-        getCompanyId: (...args)=>mockGetCompanyId(...args)
-    }));
-function makeQueryFailedError(driverError, message = 'db error') {
-    const err = new _typeorm.QueryFailedError('SELECT 1', [], new Error(message));
-    Object.assign(err, driverError);
-    return err;
-}
-describe('GlobalExceptionFilter', ()=>{
-    let filter;
-    let errorSpy;
-    let warnSpy;
-    let request;
-    let response;
-    let host;
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        filter = new _globalexceptionfilter.GlobalExceptionFilter();
-        errorSpy = jest.spyOn(_common.Logger.prototype, 'error').mockImplementation(()=>undefined);
-        warnSpy = jest.spyOn(_common.Logger.prototype, 'warn').mockImplementation(()=>undefined);
-        jest.spyOn(_common.Logger.prototype, 'log').mockImplementation(()=>undefined);
-        mockGetRequestId.mockReturnValue(undefined);
-        mockGetUserId.mockReturnValue(undefined);
-        mockGetTenantId.mockReturnValue(undefined);
-        mockGetCompanyId.mockReturnValue(undefined);
-        request = {
-            headers: {},
-            method: 'GET',
-            originalUrl: '/api/users',
-            path: '/api/users'
-        };
-        response = {
-            status: jest.fn().mockReturnThis(),
-            json: jest.fn()
-        };
-        host = {
-            switchToHttp: ()=>({
-                    getRequest: ()=>request,
-                    getResponse: ()=>response
-                })
-        };
-    });
-    afterEach(()=>{
-        errorSpy.mockRestore();
-        warnSpy.mockRestore();
-    });
-    describe('request id resolution', ()=>{
-        it('should prefer the AsyncLocalStorage request id', ()=>{
-            mockGetRequestId.mockReturnValue('ctx-request-id');
-            request.headers['x-request-id'] = 'header-request-id';
-            filter.catch(new Error('boom'), host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload._meta.requestId).toBe('ctx-request-id');
-        });
-        it('should fall back to the x-request-id header', ()=>{
-            request.headers['x-request-id'] = 'header-request-id';
-            filter.catch(new Error('boom'), host);
-            expect(response.json.mock.calls[0][0]._meta.requestId).toBe('header-request-id');
-        });
-        it('should default to "no-request-id" when nothing is available', ()=>{
-            filter.catch(new Error('boom'), host);
-            expect(response.json.mock.calls[0][0]._meta.requestId).toBe('no-request-id');
-        });
-    });
-    describe('BaseAppException handling', ()=>{
-        it('should use the exception status, message, messageKey, and variables', ()=>{
-            const exception = new _baseappexception.ConflictException('User', 'email');
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.CONFLICT);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload).toMatchObject({
-                success: false,
-                message: 'User with this email already exists',
-                messageKey: _messagekeys.ERROR_MESSAGES.CONFLICT,
-                messageVariables: {
-                    entity: 'User',
-                    field: 'email'
-                }
-            });
-        });
-        it('should include validation errors when present', ()=>{
-            const exception = new _baseappexception.BaseAppException({
-                message: 'Validation failed',
-                messageKey: _messagekeys.ERROR_MESSAGES.VALIDATION,
-                status: _common.HttpStatus.BAD_REQUEST,
-                errors: [
-                    {
-                        field: 'email',
-                        message: 'must be an email'
-                    }
-                ]
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.errors).toEqual([
-                {
-                    field: 'email',
-                    message: 'must be an email'
-                }
-            ]);
-        });
-    });
-    describe('HttpException handling', ()=>{
-        it('should use the string response body as the message', ()=>{
-            const exception = new _common.HttpException('Not allowed', _common.HttpStatus.FORBIDDEN);
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.FORBIDDEN);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Not allowed');
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.HTTP);
-        });
-        it('should convert an array of validation messages into structured errors', ()=>{
-            const exception = new _common.HttpException({
-                message: [
-                    'email must be a valid email',
-                    'age must not be less than 0'
-                ]
-            }, _common.HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Validation failed');
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.VALIDATION);
-            expect(payload.errors).toEqual([
-                {
-                    field: 'email',
-                    message: 'must be a valid email'
-                },
-                {
-                    field: 'age',
-                    message: 'must not be less than 0'
-                }
-            ]);
-        });
-        it('should fall back the message when a validation message has no spaces', ()=>{
-            const exception = new _common.HttpException({
-                message: [
-                    'required'
-                ]
-            }, _common.HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.errors).toEqual([
-                {
-                    field: 'required',
-                    message: 'required'
-                }
-            ]);
-        });
-        it('should use the object messageKey/messageVariables/errors when present', ()=>{
-            const exception = new _common.HttpException({
-                message: 'Custom message',
-                messageKey: 'custom.key',
-                messageVariables: {
-                    foo: 'bar'
-                },
-                errors: [
-                    {
-                        field: 'x',
-                        message: 'y'
-                    }
-                ]
-            }, _common.HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload).toMatchObject({
-                message: 'Custom message',
-                messageKey: 'custom.key',
-                messageVariables: {
-                    foo: 'bar'
-                },
-                errors: [
-                    {
-                        field: 'x',
-                        message: 'y'
-                    }
-                ]
-            });
-        });
-        it('should default to Unknown error/HTTP messageKey when the object has no message', ()=>{
-            const exception = new _common.HttpException({}, _common.HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Unknown error');
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.HTTP);
-        });
-        it('should handle a non-string/non-object response body', ()=>{
-            const exception = new _common.HttpException(42, _common.HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Unknown error');
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.UNKNOWN);
-        });
-    });
-    describe('QueryFailedError handling', ()=>{
-        it('should map a postgres unique violation (23505) to a conflict', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23505',
-                    detail: 'Key (email)=(a@b.com) already exists.',
-                    table: 'users'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.CONFLICT);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.CONFLICT);
-            expect(payload.message).toContain('Email');
-        });
-        it('should map a mysql duplicate entry (ER_DUP_ENTRY) to a conflict using the sqlMessage key name', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: 'ER_DUP_ENTRY',
-                    sqlMessage: "Duplicate entry 'a@b.com' for key 'users.email_UNIQUE'",
-                    table: 'users'
-                }
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.CONFLICT);
-        });
-        it('should map an mssql duplicate constraint (2627) to a conflict', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    number: 2627,
-                    table: 'users'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(_messagekeys.ERROR_MESSAGES.CONFLICT);
-        });
-        it('should fall back to "record" when no table name is available for a duplicate', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23505'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].message).toContain('Record');
-        });
-        it('should map a foreign key violation (23503) to a bad request', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23503',
-                    detail: 'Key (company_id)=(x) is not present in table "companies".'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.BAD_REQUEST);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_FOREIGN_KEY);
-            expect(payload.message).toContain('Company ID');
-        });
-        it('should map a mysql foreign key violation via errno 1452', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    errno: 1452,
-                    sqlMessage: 'Cannot add or update a child row: a foreign key constraint fails (FOREIGN KEY (`company_id`) ...)'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_FOREIGN_KEY);
-        });
-        it('should map a not-null violation (23502) with the human-readable column name', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23502',
-                    column: 'user_name'
-                }
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_NOT_NULL);
-            expect(payload.message).toContain('User Name');
-        });
-        it('should map a mysql not-null violation using the sqlMessage column name', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: 'ER_BAD_NULL_ERROR',
-                    sqlMessage: "Column 'user_name' cannot be null"
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_NOT_NULL);
-        });
-        it('should map a postgres invalid input syntax error (22P02)', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '22P02',
-                    column: 'age'
-                }
-            }, 'invalid input syntax for type integer: "abc"');
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_INVALID_INPUT);
-            expect(payload.message).toContain('integer');
-            expect(payload.message).toContain('Age');
-        });
-        it('should map a value-too-long error (22001)', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '22001',
-                    column: 'name'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_VALUE_TOO_LONG);
-        });
-        it('should map a mysql data-too-long error using the sqlMessage column name', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: 'ER_DATA_TOO_LONG',
-                    sqlMessage: "Data too long for column 'name' at row 1"
-                }
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_VALUE_TOO_LONG);
-            expect(payload.message).toContain('Name');
-        });
-        it('should map a check constraint violation (23514)', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23514',
-                    table: 'orders',
-                    constraint: 'orders_total_check'
-                }
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_CHECK_CONSTRAINT);
-            expect(payload.messageVariables).toMatchObject({
-                constraint: 'orders_total_check'
-            });
-        });
-        it('should map a deadlock error (40P01) to service unavailable', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '40P01'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.SERVICE_UNAVAILABLE);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_DEADLOCK);
-        });
-        it('should map a mysql deadlock via errno 1213', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    errno: 1213
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(_messagekeys.ERROR_MESSAGES.DB_DEADLOCK);
-        });
-        it('should fall back to a generic 500 for an unrecognized db error code', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '99999'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.INTERNAL_SERVER_ERROR);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(_messagekeys.ERROR_MESSAGES.INTERNAL);
-        });
-        it('should read driver fields directly when driverError is absent', ()=>{
-            const exception = makeQueryFailedError({
-                code: '23505',
-                table: 'users'
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(_messagekeys.ERROR_MESSAGES.CONFLICT);
-        });
-    });
-    describe('unrecognized exceptions', ()=>{
-        it('should return a generic 500 for a plain Error', ()=>{
-            filter.catch(new Error('unexpected'), host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.INTERNAL_SERVER_ERROR);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Internal server error');
-            expect(payload.messageKey).toBe(_messagekeys.ERROR_MESSAGES.INTERNAL);
-        });
-        it('should return a generic 500 for a thrown non-Error value', ()=>{
-            filter.catch('just a string', host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.INTERNAL_SERVER_ERROR);
-        });
-        it('should return a generic 500 for undefined/null', ()=>{
-            filter.catch(undefined, host);
-            expect(response.status).toHaveBeenCalledWith(_common.HttpStatus.INTERNAL_SERVER_ERROR);
-        });
-    });
-    describe('logging behavior', ()=>{
-        it('should log at error level with the stack trace for 5xx responses', ()=>{
-            const exception = new Error('unexpected');
-            filter.catch(exception, host);
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('500'), exception.stack, expect.objectContaining({
-                statusCode: _common.HttpStatus.INTERNAL_SERVER_ERROR
-            }));
-            expect(warnSpy).not.toHaveBeenCalled();
-        });
-        it('should log at warn level without a stack trace for 4xx responses', ()=>{
-            const exception = new _common.HttpException('Not allowed', _common.HttpStatus.FORBIDDEN);
-            filter.catch(exception, host);
-            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('403'), expect.objectContaining({
-                statusCode: _common.HttpStatus.FORBIDDEN
-            }));
-            expect(errorSpy).not.toHaveBeenCalled();
-        });
-        it('should include correlation context (userId/tenantId/companyId) in the log payload', ()=>{
-            mockGetUserId.mockReturnValue('user-1');
-            mockGetTenantId.mockReturnValue('tenant-1');
-            mockGetCompanyId.mockReturnValue('company-1');
-            filter.catch(new Error('unexpected'), host);
-            expect(errorSpy).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.objectContaining({
-                userId: 'user-1',
-                tenantId: 'tenant-1',
-                companyId: 'company-1'
-            }));
-        });
-    });
-    it('should always set the response status and JSON body once', ()=>{
-        filter.catch(new Error('boom'), host);
-        expect(response.status).toHaveBeenCalledTimes(1);
-        expect(response.json).toHaveBeenCalledTimes(1);
-    });
-});

package/cjs/filters/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./global-exception.filter"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/guards/index.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./jwt-auth.guard"), exports);
-_export_star(require("./optional-jwt-auth.guard"), exports);
-_export_star(require("./permission.guard"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/guards/jwt-auth.guard.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "JwtAuthGuard", {
-    enumerable: true,
-    get: function() {
-        return JwtAuthGuard;
-    }
-});
-const _constants = require("../constants");
-const _common = require("@nestjs/common");
-const _core = require("@nestjs/core");
-const _passport = require("@nestjs/passport");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let JwtAuthGuard = class JwtAuthGuard extends (0, _passport.AuthGuard)('jwt') {
-    canActivate(context) {
-        // Check if route is marked as public
-        const isPublic = this.reflector.getAllAndOverride(_constants.IS_PUBLIC_KEY, [
-            context.getHandler(),
-            context.getClass()
-        ]);
-        if (isPublic) {
-            return true;
-        }
-        return super.canActivate(context);
-    }
-    handleRequest(err, user) {
-        if (err || !user) {
-            throw err || new _common.UnauthorizedException({
-                message: 'Invalid or expired token',
-                messageKey: _constants.AUTH_MESSAGES.TOKEN_INVALID
-            });
-        }
-        return user;
-    }
-    // NOTE: @Inject(Reflector) required for bundled code - external classes need explicit injection
-    constructor(reflector){
-        super(), _define_property(this, "reflector", void 0), this.reflector = reflector;
-    }
-};
-JwtAuthGuard = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_param(0, (0, _common.Inject)(_core.Reflector)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _core.Reflector === "undefined" ? Object : _core.Reflector
-    ])
-], JwtAuthGuard);

package/cjs/guards/jwt-auth.guard.spec.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _core = require("@nestjs/core");
-const _passport = require("@nestjs/passport");
-const _constants = require("../constants");
-const _jwtauthguard = require("./jwt-auth.guard");
-function buildContext() {
-    return {
-        getHandler: ()=>({}),
-        getClass: ()=>({})
-    };
-}
-describe('JwtAuthGuard', ()=>{
-    let reflector;
-    let guard;
-    let superCanActivateSpy;
-    beforeEach(()=>{
-        reflector = new _core.Reflector();
-        guard = new _jwtauthguard.JwtAuthGuard(reflector);
-        superCanActivateSpy = jest.spyOn((0, _passport.AuthGuard)('jwt').prototype, 'canActivate').mockReturnValue(true);
-    });
-    afterEach(()=>{
-        jest.restoreAllMocks();
-    });
-    describe('canActivate', ()=>{
-        it('should allow access without invoking the parent guard when the route is public', ()=>{
-            jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(true);
-            const result = guard.canActivate(buildContext());
-            expect(result).toBe(true);
-            expect(superCanActivateSpy).not.toHaveBeenCalled();
-        });
-        it('should check IS_PUBLIC_KEY metadata on both handler and class', ()=>{
-            const getAllAndOverrideSpy = jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(false);
-            const ctx = buildContext();
-            guard.canActivate(ctx);
-            expect(getAllAndOverrideSpy).toHaveBeenCalledWith(_constants.IS_PUBLIC_KEY, [
-                ctx.getHandler(),
-                ctx.getClass()
-            ]);
-        });
-        it('should delegate to the parent AuthGuard when the route is not public', ()=>{
-            jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(false);
-            const result = guard.canActivate(buildContext());
-            expect(result).toBe(true);
-            expect(superCanActivateSpy).toHaveBeenCalled();
-        });
-    });
-    describe('handleRequest', ()=>{
-        it('should return the user when authentication succeeds', ()=>{
-            const user = {
-                id: 'user-1'
-            };
-            expect(guard.handleRequest(null, user)).toBe(user);
-        });
-        it('should throw the original error when one is provided', ()=>{
-            const err = new Error('strategy failure');
-            expect(()=>guard.handleRequest(err, null)).toThrow(err);
-        });
-        it('should throw UnauthorizedException with AUTH_MESSAGES.TOKEN_INVALID when no error but no user', ()=>{
-            try {
-                guard.handleRequest(null, null);
-                fail('expected to throw');
-            } catch (error) {
-                expect(error).toBeInstanceOf(_common.UnauthorizedException);
-                expect(error.getResponse()).toMatchObject({
-                    message: 'Invalid or expired token',
-                    messageKey: _constants.AUTH_MESSAGES.TOKEN_INVALID
-                });
-            }
-        });
-    });
-});