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

Error handling utilities for GreenPay microservices and validation middleware

const { z } = require('zod');
const { ZodError } = require('../src/ZodError');

describe('ZodError', () => {
  describe('Constructor', () => {
    it('should create a ZodError with default values', () => {
      const error = new ZodError('Test error');
      
      expect(error.name).toBe('ZodError');
      expect(error.message).toBe('Test error');
      expect(error.type).toBe('ZOD_ERROR');
      expect(error.errorCode).toBe('ZOD_GENERAL');
      expect(error.description).toBe('Test error');
      expect(error.integration).toBe('zod-validation');
      expect(error.statusCode).toBe(400);
      expect(error.field).toBeNull();
      expect(error.value).toBeNull();
      expect(error.zodError).toBeNull();
    });

    it('should create a ZodError with custom values', () => {
      const error = new ZodError('Test error', 'email', 'invalid@', null);
      
      expect(error.field).toBe('email');
      expect(error.value).toBe('invalid@');
      expect(error.errorCode).toBe('ZOD_EMAIL');
    });
  });

  describe('Static methods', () => {
    describe('fromZodError', () => {
      it('should create ZodError from Zod validation error', () => {
        const schema = z.object({
          email: z.string().email('Invalid email'),
        });

        try {
          schema.parse({ email: 'invalid-email' });
        } catch (zodError) {
          const error = ZodError.fromZodError(zodError, 'test-service');
          
          expect(error.name).toBe('ZodError');
          expect(error.message).toContain('Event object failed validation');
          expect(error.errorCode).toBe('ZOD-001');
          expect(error.description).toBe('Schema validation failed');
          expect(error.integration).toBe('test-service');
          expect(error.statusCode).toBe(400);
          expect(error.additionalData.validation.errors).toHaveLength(1);
          expect(error.additionalData.validation.errors[0].field).toBe('email');
        }
      });
    });

    describe('required', () => {
      it('should create required field error', () => {
        const error = ZodError.required('email', 'auth-service');
        
        expect(error.message).toBe('email is required');
        expect(error.errorCode).toBe('ZOD-002');
        expect(error.description).toBe('Campo \'email\' es requerido para validación dinámica');
        expect(error.integration).toBe('auth-service');
        expect(error.statusCode).toBe(400);
        expect(error.field).toBe('email');
      });
    });

    describe('unsupportedProvider', () => {
      it('should create unsupported provider error', () => {
        const error = ZodError.unsupportedProvider('paypal', 'credit-card', 'payment-service');
        
        expect(error.message).toBe('Proveedor \'paypal\' no soportado para transacción tipo \'credit-card\'');
        expect(error.errorCode).toBe('ZOD-003');
        expect(error.description).toBe('Proveedor \'paypal\' no soportado para transacción tipo \'credit-card\'');
        expect(error.integration).toBe('payment-service');
        expect(error.statusCode).toBe(400);
        expect(error.field).toBe('provider');
        expect(error.value).toBe('paypal');
      });
    });

    describe('generic', () => {
      it('should create generic error', () => {
        const originalError = new Error('Internal error');
        const error = ZodError.generic(originalError, 'validation-service');
        
        expect(error.message).toBe('Internal error');
        expect(error.errorCode).toBe('ZOD-004');
        expect(error.description).toBe('Unexpected validation error');
        expect(error.integration).toBe('validation-service');
        expect(error.statusCode).toBe(500);
        expect(error.field).toBe('general');
        expect(error.zodError).toBe(originalError);
      });
    });

    describe('schemaValidation', () => {
      it('should create schema validation error', () => {
        const error = ZodError.schemaValidation('Schema failed', 'user', { invalid: 'data' }, 'user-service');
        
        expect(error.message).toBe('Schema failed');
        expect(error.errorCode).toBe('ZOD-005');
        expect(error.description).toBe('Schema validation failed');
        expect(error.integration).toBe('user-service');
        expect(error.statusCode).toBe(400);
        expect(error.field).toBe('user');
        expect(error.value).toEqual({ invalid: 'data' });
      });
    });

    describe('dynamicSchema', () => {
      it('should create dynamic schema error', () => {
        const error = ZodError.dynamicSchema('Dynamic schema failed', 'stripe', 'payment-service');
        
        expect(error.message).toBe('Dynamic schema failed');
        expect(error.errorCode).toBe('ZOD-006');
        expect(error.description).toBe('Dynamic schema creation failed');
        expect(error.integration).toBe('payment-service');
        expect(error.statusCode).toBe(400);
        expect(error.field).toBe('dynamicSchema');
        expect(error.value).toBe('stripe');
      });
    });
  });

  describe('Instance methods', () => {
    describe('getZodDetails', () => {
      it('should return Zod error details', () => {
        const error = new ZodError('Test error', 'email', 'invalid@', null);
        const details = error.getZodDetails();
        
        expect(details).toEqual({
          field: 'email',
          value: 'invalid@',
          message: 'Test error',
          type: 'ZOD_ERROR',
          zodError: null,
          errorCode: 'ZOD_EMAIL',
          description: 'Test error',
          integration: 'zod-validation',
        });
      });
    });

    describe('getValidationErrors', () => {
      it('should return empty array when no Zod error', () => {
        const error = new ZodError('Test error');
        const errors = error.getValidationErrors();
        
        expect(errors).toEqual([]);
      });

      it('should return validation errors from Zod error', () => {
        const schema = z.object({
          email: z.string().email('Invalid email'),
          name: z.string().min(2, 'Name too short'),
        });

        try {
          schema.parse({ email: 'invalid', name: 'A' });
        } catch (zodError) {
          const error = ZodError.fromZodError(zodError, 'test-service');
          const errors = error.getValidationErrors();
          
          expect(errors).toHaveLength(2);
          expect(errors[0].field).toBe('email');
          expect(errors[1].field).toBe('name');
        }
      });
    });

    describe('hasZodDetails', () => {
      it('should return false when no Zod error', () => {
        const error = new ZodError('Test error');
        expect(error.hasZodDetails()).toBe(false);
      });

      it('should return true when has Zod error', () => {
        const schema = z.object({
          email: z.string().email('Invalid email'),
        });

        try {
          schema.parse({ email: 'invalid' });
        } catch (zodError) {
          const error = ZodError.fromZodError(zodError, 'test-service');
          expect(error.hasZodDetails()).toBe(true);
        }
      });
    });
  });

  describe('Inheritance', () => {
    it('should inherit from CustomError', () => {
      const error = new ZodError('Test error');
      
      expect(error).toBeInstanceOf(Error);
      expect(error).toBeInstanceOf(ZodError);
      expect(error.hasRequiredFields()).toBe(true);
    });

    it('should have required fields', () => {
      const error = ZodError.required('email', 'auth-service');
      
      expect(error.errorCode).toBeTruthy();
      expect(error.description).toBeTruthy();
      expect(error.integration).toBeTruthy();
      expect(error.hasRequiredFields()).toBe(true);
    });
  });
});