@gp_jcisneros/errors/__tests__/ResponseHandler.test.js

Error handling utilities for GreenPay microservices and validation middleware

const { ResponseHandler, HttpError } = require('../src/index');

describe('ResponseHandler', () => {
  let mockResponse;

  beforeEach(() => {
    mockResponse = {
      status: jest.fn().mockReturnThis(),
      json: jest.fn().mockReturnThis()
    };
  });

  describe('Constructor', () => {
    it('should create ResponseHandler with default values', () => {
      const handler = new ResponseHandler();
      
      expect(handler.defaultSuccessMessage).toBe('Operation completed successfully');
      expect(handler.defaultErrorMessage).toBe('Internal server error');
      expect(handler.defaultSuccessCode).toBe(200);
      expect(handler.defaultErrorCode).toBe(500);
      expect(handler.includeStack).toBe(false);
    });

    it('should create ResponseHandler with custom values', () => {
      const handler = new ResponseHandler({
        defaultSuccessMessage: 'Custom success',
        defaultErrorMessage: 'Custom error',
        defaultSuccessCode: 201,
        defaultErrorCode: 400,
        includeStack: true
      });
      
      expect(handler.defaultSuccessMessage).toBe('Custom success');
      expect(handler.defaultErrorMessage).toBe('Custom error');
      expect(handler.defaultSuccessCode).toBe(201);
      expect(handler.defaultErrorCode).toBe(400);
      expect(handler.includeStack).toBe(true);
    });
  });

  describe('success method', () => {
    it('should create success response with default values', () => {
      const handler = new ResponseHandler();
      const data = { id: 123, name: 'Test' };
      
      handler.success(mockResponse, data);
      
      expect(mockResponse.status).toHaveBeenCalledWith(200);
      expect(mockResponse.json).toHaveBeenCalledWith({
        code: 200,
        status: 'success',
        message: 'Operation completed successfully',
        data: data,
        additionalData: {}
      });
    });

    it('should create success response with custom values', () => {
      const handler = new ResponseHandler();
      const data = { id: 123 };
      const message = 'Custom success message';
      const code = 201;
      const additionalData = { metadata: 'test' };
      
      handler.success(mockResponse, data, message, code, additionalData);
      
      expect(mockResponse.status).toHaveBeenCalledWith(201);
      expect(mockResponse.json).toHaveBeenCalledWith({
        code: 201,
        status: 'success',
        message: 'Custom success message',
        data: data,
        additionalData: additionalData
      });
    });
  });

  describe('error method', () => {
    it('should create error response with default values', () => {
      const handler = new ResponseHandler();
      const error = new Error('Test error');
      
      handler.error(mockResponse, error);
      
      expect(mockResponse.status).toHaveBeenCalledWith(500);
      expect(mockResponse.json).toHaveBeenCalledWith({
        code: 500,
        status: 'failed',
        message: 'Test error',
        error: {
          code: 'GP-500',
          message: 'Test error'
        },
        data: {},
        additionalData: {}
      });
    });

    it('should create error response with CustomError', () => {
      const handler = new ResponseHandler();
      const error = HttpError.badRequest('Invalid data');
      
      handler.error(mockResponse, error);
      
      expect(mockResponse.status).toHaveBeenCalledWith(400);
      expect(mockResponse.json).toHaveBeenCalledWith({
        code: 400,
        status: 'failed',
        message: 'Invalid data',
        error: {
          code: 'HTTP_400',
          message: 'Invalid data'
        },
        data: {},
        additionalData: {}
      });
    });

    it('should create error response with custom values', () => {
      const handler = new ResponseHandler();
      const error = new Error('Test error');
      const data = { context: 'test' };
      const message = 'Custom error message';
      const code = 400;
      const additionalData = { metadata: 'test' };
      
      handler.error(mockResponse, error, data, message, code, additionalData);
      
      expect(mockResponse.status).toHaveBeenCalledWith(400);
      expect(mockResponse.json).toHaveBeenCalledWith({
        code: 400,
        status: 'failed',
        message: 'Custom error message',
        error: {
          code: 'GP-500',
          message: 'Custom error message'
        },
        data: { context: 'test' },
        additionalData: {
          metadata: 'test'
        }
      });
    });

    it('should include stack trace when includeStack is true', () => {
      const handler = new ResponseHandler({ includeStack: true });
      const error = new Error('Test error');
      
      handler.error(mockResponse, error);
      
      const response = mockResponse.json.mock.calls[0][0];
      expect(response.additionalData.stack).toBeDefined();
    });
  });

  describe('Static methods', () => {
    describe('createHandler', () => {
      it('should create a handler function', () => {
        const handler = ResponseHandler.createHandler();
        
        expect(typeof handler).toBe('function');
      });

      it('should handle success case', () => {
        const handler = ResponseHandler.createHandler();
        const data = { id: 123 };
        
        handler(mockResponse, data);
        
        expect(mockResponse.status).toHaveBeenCalledWith(200);
        expect(mockResponse.json).toHaveBeenCalledWith({
          code: 200,
          status: 'success',
          message: 'Operation completed successfully',
          data: data,
          additionalData: {}
        });
      });

      it('should handle error case', () => {
        const handler = ResponseHandler.createHandler();
        const error = new Error('Test error');
        
        handler(mockResponse, null, error);
        
        expect(mockResponse.status).toHaveBeenCalledWith(500);
        expect(mockResponse.json).toHaveBeenCalledWith({
          code: 500,
          status: 'failed',
          message: 'Test error',
          error: {
            code: 'GP-500',
            message: 'Test error'
          },
          data: {},
          additionalData: {}
        });
      });
    });

    describe('createCustomHandler', () => {
      it('should create handler with custom messages', () => {
        const handler = ResponseHandler.createCustomHandler(
          'Custom success',
          'Custom error'
        );
        
        handler(mockResponse, { id: 123 });
        
        expect(mockResponse.json).toHaveBeenCalledWith({
          code: 200,
          status: 'success',
          message: 'Custom success',
          data: { id: 123 },
          additionalData: {}
        });
      });
    });

    describe('createTransactionHandler', () => {
      it('should create transaction handler', () => {
        const handler = ResponseHandler.createTransactionHandler();
        
        handler(mockResponse, { transactionId: 'TXN-123' });
        
        expect(mockResponse.json).toHaveBeenCalledWith({
          code: 200,
          status: 'success',
          message: 'La transacción fue procesada correctamente',
          data: { transactionId: 'TXN-123' },
          additionalData: {}
        });
      });

      it('should handle transaction errors', () => {
        const handler = ResponseHandler.createTransactionHandler();
        const error = new Error('Transaction failed');
        
        handler(mockResponse, null, error);
        
        expect(mockResponse.json).toHaveBeenCalledWith({
          code: 500,
          status: 'failed',
          message: 'Transaction failed',
          error: {
            code: 'GP-500',
            message: 'Transaction failed'
          },
          data: {},
          additionalData: {}
        });
      });
    });

    describe('createCRUDHandler', () => {
      it('should create CRUD handler', () => {
        const handler = ResponseHandler.createCRUDHandler();
        
        handler(mockResponse, { id: 123 });
        
        expect(mockResponse.json).toHaveBeenCalledWith({
          code: 200,
          status: 'success',
          message: 'Operación completada exitosamente',
          data: { id: 123 },
          additionalData: {}
        });
      });
    });
  });
});