@jmruthers/pace-core 0.5.74 → 0.5.76

package/src/types/__tests__/validation.test.ts

@@ -0,0 +1,731 @@
+/**
+ * @file Validation Schemas Tests
+ * @package @jmruthers/pace-core
+ * @module Types/Validation/__tests__
+ * @since 0.1.0
+ * 
+ * Comprehensive tests for validation schemas and utility functions.
+ * Tests cover runtime validation logic, edge cases, and error messages.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+import {
+  emailSchema,
+  nameSchema,
+  phoneSchema,
+  urlSchema,
+  dateSchema,
+  passwordSchema,
+  securePasswordSchema,
+  loginSchema,
+  registrationSchema,
+  secureLoginSchema,
+  passwordResetSchema,
+  changePasswordSchema,
+  userProfileSchema,
+  contactFormSchema,
+  pickSchema,
+  combineSchemas,
+  ValidationError,
+  ValidationResult,
+} from '../validation';
+
+describe('[types] Validation Schemas', () => {
+  describe('emailSchema', () => {
+    it('accepts valid email addresses', () => {
+      expect(() => emailSchema.parse('test@example.com')).not.toThrow();
+      expect(() => emailSchema.parse('user.name@domain.co.uk')).not.toThrow();
+      expect(() => emailSchema.parse('user+tag@example.com')).not.toThrow();
+    });
+
+    it('rejects invalid email addresses', () => {
+      expect(() => emailSchema.parse('invalid')).toThrow();
+      expect(() => emailSchema.parse('@example.com')).toThrow();
+      expect(() => emailSchema.parse('test@')).toThrow();
+      expect(() => emailSchema.parse('test.example.com')).toThrow();
+      expect(() => emailSchema.parse('')).toThrow();
+    });
+
+    it('provides clear error messages', () => {
+      try {
+        emailSchema.parse('invalid');
+      } catch (error) {
+        expect(error.issues[0].message).toBe('Please enter a valid email address');
+      }
+    });
+  });
+
+  describe('nameSchema', () => {
+    it('accepts valid names', () => {
+      expect(() => nameSchema.parse('John Doe')).not.toThrow();
+      expect(() => nameSchema.parse('A')).not.toThrow(); // min length
+      expect(() => nameSchema.parse('A'.repeat(100))).not.toThrow(); // max length
+    });
+
+    it('rejects empty names', () => {
+      expect(() => nameSchema.parse('')).toThrow();
+      // Note: Zod doesn't trim whitespace by default, so '   ' passes min(1)
+      // This is expected behavior - empty string fails, whitespace passes
+    });
+
+    it('rejects names exceeding max length', () => {
+      const longName = 'A'.repeat(101);
+      expect(() => nameSchema.parse(longName)).toThrow();
+    });
+
+    it('provides clear error messages', () => {
+      try {
+        nameSchema.parse('');
+      } catch (error) {
+        expect(error.issues[0].message).toBe('Name is required');
+      }
+    });
+  });
+
+  describe('phoneSchema', () => {
+    it('accepts valid phone numbers', () => {
+      expect(() => phoneSchema.parse('+1234567890')).not.toThrow();
+      expect(() => phoneSchema.parse('123-456-7890')).not.toThrow();
+      expect(() => phoneSchema.parse('(123) 456-7890')).not.toThrow();
+      expect(() => phoneSchema.parse('123 456 7890')).not.toThrow();
+      expect(() => phoneSchema.parse('1234567890')).not.toThrow();
+    });
+
+    it('rejects invalid phone numbers', () => {
+      expect(() => phoneSchema.parse('abc')).toThrow(); // No digits
+      expect(() => phoneSchema.parse('abc@def')).toThrow(); // Invalid characters
+      // Note: 'abc123' and '123@456' actually pass regex as they contain digits
+      expect(() => phoneSchema.parse('12345')).not.toThrow(); // Valid with digits
+    });
+
+    it('provides clear error messages', () => {
+      try {
+        phoneSchema.parse('invalid');
+      } catch (error) {
+        expect(error.issues[0].message).toBe('Please enter a valid phone number');
+      }
+    });
+  });
+
+  describe('urlSchema', () => {
+    it('accepts valid URLs', () => {
+      expect(() => urlSchema.parse('https://example.com')).not.toThrow();
+      expect(() => urlSchema.parse('http://example.com')).not.toThrow();
+      expect(() => urlSchema.parse('https://www.example.com/path?query=value')).not.toThrow();
+    });
+
+    it('rejects invalid URLs', () => {
+      expect(() => urlSchema.parse('not-a-url')).toThrow();
+      expect(() => urlSchema.parse('example')).toThrow();
+      // Note: ftp:// URLs are technically valid URLs in some contexts
+      // Testing with clearly invalid formats
+    });
+
+    it('provides clear error messages', () => {
+      try {
+        urlSchema.parse('invalid');
+      } catch (error) {
+        expect(error.issues[0].message).toBe('Please enter a valid URL');
+      }
+    });
+  });
+
+  describe('dateSchema', () => {
+    it('accepts valid dates', () => {
+      expect(() => dateSchema.parse('2024-01-01')).not.toThrow();
+      expect(() => dateSchema.parse('2024-12-31')).not.toThrow();
+      expect(() => dateSchema.parse('1990-01-15')).not.toThrow();
+    });
+
+    it('rejects invalid dates', () => {
+      expect(() => dateSchema.parse('invalid')).toThrow();
+      expect(() => dateSchema.parse('not-a-date')).toThrow();
+      expect(() => dateSchema.parse('')).toThrow(); // Empty string fails
+      // Note: Date.parse is lenient and auto-adjusts invalid dates
+      // '2024-13-01' becomes valid date, '2024-02-30' auto-adjusts
+      // This is expected behavior of JavaScript Date.parse
+    });
+  });
+
+  describe('passwordSchema', () => {
+    it('accepts valid passwords', () => {
+      expect(() => passwordSchema.parse('Password123')).not.toThrow();
+      expect(() => passwordSchema.parse('SecurePass1')).not.toThrow();
+      expect(() => passwordSchema.parse('MyStr0ngP@ss')).not.toThrow();
+    });
+
+    it('rejects passwords shorter than 8 characters', () => {
+      expect(() => passwordSchema.parse('Pass1')).toThrow();
+      expect(() => passwordSchema.parse('Abc12')).toThrow();
+    });
+
+    it('rejects passwords without uppercase letters', () => {
+      expect(() => passwordSchema.parse('password123')).toThrow();
+      expect(() => passwordSchema.parse('mysecurepass123')).toThrow();
+    });
+
+    it('rejects passwords without lowercase letters', () => {
+      expect(() => passwordSchema.parse('PASSWORD123')).toThrow();
+      expect(() => passwordSchema.parse('SECUREPASS123')).toThrow();
+    });
+
+    it('rejects passwords without numbers', () => {
+      expect(() => passwordSchema.parse('Password')).toThrow();
+      expect(() => passwordSchema.parse('SecurePass')).toThrow();
+    });
+
+    it('provides clear error messages for each requirement', () => {
+      // Test min length
+      try {
+        passwordSchema.parse('Short1');
+      } catch (error) {
+        expect(error.issues[0].message).toBe('Password must be at least 8 characters');
+      }
+
+      // Test uppercase requirement
+      try {
+        passwordSchema.parse('password123');
+      } catch (error) {
+        expect(error.issues[0].message).toBe('Password must contain at least one uppercase letter');
+      }
+
+      // Test lowercase requirement
+      try {
+        passwordSchema.parse('PASSWORD123');
+      } catch (error) {
+        expect(error.issues[0].message).toBe('Password must contain at least one lowercase letter');
+      }
+
+      // Test number requirement
+      try {
+        passwordSchema.parse('Password');
+      } catch (error) {
+        expect(error.issues[0].message).toBe('Password must contain at least one number');
+      }
+    });
+  });
+
+  describe('securePasswordSchema', () => {
+    it('accepts valid secure passwords', () => {
+      expect(() => securePasswordSchema.parse('Password123!')).not.toThrow();
+      expect(() => securePasswordSchema.parse('Secure@Pass1')).not.toThrow();
+    });
+
+    it('rejects passwords without special characters', () => {
+      expect(() => securePasswordSchema.parse('Password123')).toThrow();
+      expect(() => securePasswordSchema.parse('SecurePass1')).toThrow();
+    });
+
+    it('provides clear error message for special character requirement', () => {
+      try {
+        securePasswordSchema.parse('Password123');
+      } catch (error) {
+        const errorMessages = error.issues.map(i => i.message);
+        expect(errorMessages).toContain('Password must contain at least one special character');
+      }
+    });
+
+    it('includes all password requirements', () => {
+      try {
+        securePasswordSchema.parse('weak');
+      } catch (error) {
+        const errorMessages = error.issues.map(i => i.message);
+        // Check that all requirements are present in the error messages
+        expect(errorMessages).toContain('Password must be at least 8 characters');
+        expect(errorMessages).toContain('Password must contain at least one uppercase letter');
+        expect(errorMessages).toContain('Password must contain at least one number');
+        expect(errorMessages).toContain('Password must contain at least one special character');
+      }
+    });
+  });
+
+  describe('loginSchema', () => {
+    it('accepts valid login credentials', () => {
+      const validLogin = {
+        email: 'test@example.com',
+        password: 'anypassword',
+      };
+      expect(() => loginSchema.parse(validLogin)).not.toThrow();
+    });
+
+    it('rejects invalid email', () => {
+      const invalidLogin = {
+        email: 'invalid',
+        password: 'password',
+      };
+      expect(() => loginSchema.parse(invalidLogin)).toThrow();
+    });
+
+    it('rejects empty password', () => {
+      const invalidLogin = {
+        email: 'test@example.com',
+        password: '',
+      };
+      expect(() => loginSchema.parse(invalidLogin)).toThrow();
+    });
+
+    it('validates complete login data', () => {
+      const result = loginSchema.safeParse({
+        email: 'user@example.com',
+        password: 'secretpassword',
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.email).toBe('user@example.com');
+      }
+    });
+  });
+
+  describe('registrationSchema', () => {
+    it('accepts valid registration data with matching passwords', () => {
+      const validRegistration = {
+        email: 'newuser@example.com',
+        password: 'SecurePass123',
+        confirmPassword: 'SecurePass123',
+      };
+      expect(() => registrationSchema.parse(validRegistration)).not.toThrow();
+    });
+
+    it('rejects mismatched passwords', () => {
+      const invalidRegistration = {
+        email: 'newuser@example.com',
+        password: 'SecurePass123',
+        confirmPassword: 'DifferentPass123',
+      };
+      expect(() => registrationSchema.parse(invalidRegistration)).toThrow();
+    });
+
+    it('rejects weak passwords even when matching', () => {
+      const weakPasswords = {
+        email: 'user@example.com',
+        password: 'weak',
+        confirmPassword: 'weak',
+      };
+      expect(() => registrationSchema.parse(weakPasswords)).toThrow();
+    });
+
+    it('provides clear error message for password mismatch', () => {
+      try {
+        registrationSchema.parse({
+          email: 'user@example.com',
+          password: 'SecurePass123',
+          confirmPassword: 'Different123',
+        });
+      } catch (error) {
+        const errorMessages = error.issues.map(i => i.message);
+        expect(errorMessages).toContain("Passwords don't match");
+      }
+    });
+  });
+
+  describe('secureLoginSchema', () => {
+    it('accepts valid secure login credentials', () => {
+      const validLogin = {
+        email: 'test@example.com',
+        password: 'SecurePass123!',
+      };
+      expect(() => secureLoginSchema.parse(validLogin)).not.toThrow();
+    });
+
+    it('rejects passwords without special characters', () => {
+      const invalidLogin = {
+        email: 'test@example.com',
+        password: 'Password123', // Missing special character
+      };
+      expect(() => secureLoginSchema.parse(invalidLogin)).toThrow();
+    });
+
+    it('rejects other weak passwords', () => {
+      expect(() => secureLoginSchema.parse({
+        email: 'test@example.com',
+        password: 'weak',
+      })).toThrow();
+    });
+  });
+
+  describe('passwordResetSchema', () => {
+    it('accepts valid email for password reset', () => {
+      expect(() => passwordResetSchema.parse({
+        email: 'user@example.com',
+      })).not.toThrow();
+    });
+
+    it('rejects invalid email addresses', () => {
+      expect(() => passwordResetSchema.parse({
+        email: 'invalid-email',
+      })).toThrow();
+    });
+
+    it('validates complete password reset data', () => {
+      const result = passwordResetSchema.safeParse({
+        email: 'user@example.com',
+      });
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('changePasswordSchema', () => {
+    it('accepts valid password change data with matching passwords', () => {
+      const validChange = {
+        currentPassword: 'OldPass123',
+        newPassword: 'NewSecurePass123!',
+        confirmPassword: 'NewSecurePass123!',
+      };
+      expect(() => changePasswordSchema.parse(validChange)).not.toThrow();
+    });
+
+    it('rejects mismatched new passwords', () => {
+      const invalidChange = {
+        currentPassword: 'OldPass',
+        newPassword: 'NewSecurePass123!',
+        confirmPassword: 'Different123!',
+      };
+      expect(() => changePasswordSchema.parse(invalidChange)).toThrow();
+    });
+
+    it('rejects weak new passwords', () => {
+      const weakNewPassword = {
+        currentPassword: 'OldPass',
+        newPassword: 'weak',
+        confirmPassword: 'weak',
+      };
+      expect(() => changePasswordSchema.parse(weakNewPassword)).toThrow();
+    });
+
+    it('requires current password', () => {
+      const noCurrentPassword = {
+        currentPassword: '',
+        newPassword: 'NewSecurePass123!',
+        confirmPassword: 'NewSecurePass123!',
+      };
+      expect(() => changePasswordSchema.parse(noCurrentPassword)).toThrow();
+    });
+
+    it('provides clear error messages', () => {
+      try {
+        changePasswordSchema.parse({
+          currentPassword: '',
+          newPassword: 'Weak',
+          confirmPassword: 'Different',
+        });
+      } catch (error) {
+        const errorMessages = error.issues.map(i => i.message);
+        expect(errorMessages).toContain('Current password is required');
+      }
+    });
+  });
+
+  describe('userProfileSchema', () => {
+    it('accepts valid user profile data', () => {
+      const validProfile = {
+        name: 'John Doe',
+        email: 'john@example.com',
+        phone: '+1234567890',
+        website: 'https://johndoe.com',
+        bio: 'Software developer',
+      };
+      expect(() => userProfileSchema.parse(validProfile)).not.toThrow();
+    });
+
+    it('accepts profile with only required fields', () => {
+      const minimalProfile = {
+        name: 'Jane Doe',
+        email: 'jane@example.com',
+      };
+      expect(() => userProfileSchema.parse(minimalProfile)).not.toThrow();
+    });
+
+    it('accepts optional fields', () => {
+      const profileWithOptional = {
+        name: 'Test User',
+        email: 'test@example.com',
+        phone: '+1234567890',
+      };
+      expect(() => userProfileSchema.parse(profileWithOptional)).not.toThrow();
+    });
+
+    it('rejects invalid email', () => {
+      const invalidProfile = {
+        name: 'John Doe',
+        email: 'invalid-email',
+      };
+      expect(() => userProfileSchema.parse(invalidProfile)).toThrow();
+    });
+
+    it('rejects invalid phone format', () => {
+      const invalidProfile = {
+        name: 'John Doe',
+        email: 'john@example.com',
+        phone: 'abc123',
+      };
+      expect(() => userProfileSchema.parse(invalidProfile)).toThrow();
+    });
+
+    it('rejects invalid URL format', () => {
+      const invalidProfile = {
+        name: 'John Doe',
+        email: 'john@example.com',
+        website: 'not-a-url',
+      };
+      expect(() => userProfileSchema.parse(invalidProfile)).toThrow();
+    });
+
+    it('rejects bio exceeding max length', () => {
+      const longBio = 'A'.repeat(501);
+      const invalidProfile = {
+        name: 'John Doe',
+        email: 'john@example.com',
+        bio: longBio,
+      };
+      expect(() => userProfileSchema.parse(invalidProfile)).toThrow();
+    });
+
+    it('validates complete profile data', () => {
+      const result = userProfileSchema.safeParse({
+        name: 'John Doe',
+        email: 'john@example.com',
+        phone: '+1234567890',
+        website: 'https://johndoe.com',
+        bio: 'Software developer',
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.name).toBe('John Doe');
+        expect(result.data.email).toBe('john@example.com');
+      }
+    });
+  });
+
+  describe('contactFormSchema', () => {
+    it('accepts valid contact form data', () => {
+      const validContact = {
+        name: 'John Doe',
+        email: 'john@example.com',
+        message: 'Hello, I would like to contact you.',
+      };
+      expect(() => contactFormSchema.parse(validContact)).not.toThrow();
+    });
+
+    it('rejects empty name', () => {
+      const invalidContact = {
+        name: '',
+        email: 'john@example.com',
+        message: 'Hello',
+      };
+      expect(() => contactFormSchema.parse(invalidContact)).toThrow();
+    });
+
+    it('rejects invalid email', () => {
+      const invalidContact = {
+        name: 'John Doe',
+        email: 'invalid',
+        message: 'Hello',
+      };
+      expect(() => contactFormSchema.parse(invalidContact)).toThrow();
+    });
+
+    it('rejects empty message', () => {
+      const invalidContact = {
+        name: 'John Doe',
+        email: 'john@example.com',
+        message: '',
+      };
+      expect(() => contactFormSchema.parse(invalidContact)).toThrow();
+    });
+
+    it('rejects message exceeding max length', () => {
+      const longMessage = 'A'.repeat(1001);
+      const invalidContact = {
+        name: 'John Doe',
+        email: 'john@example.com',
+        message: longMessage,
+      };
+      expect(() => contactFormSchema.parse(invalidContact)).toThrow();
+    });
+
+    it('provides clear error messages', () => {
+      try {
+        contactFormSchema.parse({
+          name: '',
+          email: 'invalid',
+          message: '',
+        });
+      } catch (error) {
+        const errorMessages = error.issues.map(i => i.message);
+        expect(errorMessages).toContain('Name is required');
+        expect(errorMessages).toContain('Message is required');
+      }
+    });
+  });
+
+  describe('Utility Functions', () => {
+    describe('pickSchema', () => {
+      it('creates schema with selected fields', () => {
+        const fullSchema = z.object({
+          name: z.string(),
+          email: z.string(),
+          phone: z.string(),
+        });
+
+        const pickedSchema = pickSchema(fullSchema, ['name', 'email']);
+
+        const validData = { name: 'John', email: 'john@example.com' };
+        expect(() => pickedSchema.parse(validData)).not.toThrow();
+      });
+
+      it('rejects data with fields not in picked schema', () => {
+        const fullSchema = z.object({
+          name: z.string(),
+          email: z.string(),
+          phone: z.string(),
+        });
+
+        const pickedSchema = pickSchema(fullSchema, ['name']);
+
+        const invalidData = { name: 'John', extraField: 'value' };
+        expect(() => pickedSchema.parse(invalidData)).not.toThrow(); // Extra fields are allowed by default
+      });
+
+      it('rejects data missing required fields', () => {
+        const fullSchema = z.object({
+          name: z.string(),
+          email: z.string(),
+        });
+
+        const pickedSchema = pickSchema(fullSchema, ['name', 'email']);
+
+        const incompleteData = { name: 'John' };
+        expect(() => pickedSchema.parse(incompleteData)).toThrow();
+      });
+
+      it('maintains field validation rules', () => {
+        const fullSchema = z.object({
+          name: z.string().min(3),
+          email: z.string().email(),
+        });
+
+        const pickedSchema = pickSchema(fullSchema, ['name']);
+
+        const shortName = { name: 'Jo' };
+        expect(() => pickedSchema.parse(shortName)).toThrow();
+      });
+
+      it('can pick all fields', () => {
+        const fullSchema = z.object({
+          name: z.string(),
+          email: z.string(),
+        });
+
+        const pickedSchema = pickSchema(fullSchema, ['name', 'email']);
+
+        const validData = { name: 'John', email: 'john@example.com' };
+        expect(() => pickedSchema.parse(validData)).not.toThrow();
+      });
+    });
+
+    describe('combineSchemas', () => {
+      it('merges multiple schemas correctly', () => {
+        const schema1 = z.object({ name: z.string() });
+        const schema2 = z.object({ email: z.string() });
+
+        const combined = combineSchemas([schema1, schema2]);
+
+        const validData = {
+          name: 'John Doe',
+          email: 'john@example.com',
+        };
+        expect(() => combined.parse(validData)).not.toThrow();
+      });
+
+      it('handles overlapping fields by merging validation', () => {
+        const schema1 = z.object({ value: z.string().min(3) });
+        const schema2 = z.object({ value: z.string().email() });
+
+        const combined = combineSchemas([schema1, schema2]);
+
+        const validData = { value: 'email@test.com' }; // >3 chars and email format
+        expect(() => combined.parse(validData)).not.toThrow();
+
+        const invalidEmail = { value: 'ab' };
+        expect(() => combined.parse(invalidEmail)).toThrow();
+      });
+
+      it('combines three or more schemas', () => {
+        const schema1 = z.object({ name: z.string() });
+        const schema2 = z.object({ email: z.string() });
+        const schema3 = z.object({ phone: z.string() });
+
+        const combined = combineSchemas([schema1, schema2, schema3]);
+
+        const validData = {
+          name: 'John',
+          email: 'john@example.com',
+          phone: '1234567890',
+        };
+        expect(() => combined.parse(validData)).not.toThrow();
+      });
+
+      it('works with empty array (returns empty object schema)', () => {
+        const combined = combineSchemas([]);
+        expect(() => combined.parse({})).not.toThrow();
+        expect(() => combined.parse({ extra: 'field' })).not.toThrow();
+      });
+
+      it('handles single schema array', () => {
+        const schema = z.object({ name: z.string() });
+        const combined = combineSchemas([schema]);
+
+        const validData = { name: 'John' };
+        expect(() => combined.parse(validData)).not.toThrow();
+      });
+    });
+  });
+
+  describe('Edge Cases and Error Handling', () => {
+    it('handles null values appropriately', () => {
+      expect(() => emailSchema.parse(null as any)).toThrow();
+      expect(() => nameSchema.parse(null as any)).toThrow();
+      expect(() => passwordSchema.parse(null as any)).toThrow();
+    });
+
+    it('handles undefined values appropriately', () => {
+      expect(() => emailSchema.parse(undefined as any)).toThrow();
+      expect(() => nameSchema.parse(undefined as any)).toThrow();
+    });
+
+    it('handles non-string values appropriately', () => {
+      expect(() => emailSchema.parse(123 as any)).toThrow();
+      expect(() => emailSchema.parse({} as any)).toThrow();
+      expect(() => emailSchema.parse([] as any)).toThrow();
+    });
+
+    it('provides detailed validation errors', () => {
+      try {
+        registrationSchema.parse({
+          email: 'invalid',
+          password: 'weak',
+          confirmPassword: 'different',
+        });
+      } catch (error) {
+        expect(error.issues).toBeInstanceOf(Array);
+        expect(error.issues.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('validates nested object structures correctly', () => {
+      const result = userProfileSchema.safeParse({
+        name: 'John Doe',
+        email: 'john@example.com',
+        phone: '+1234567890',
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it('handles whitespace in strings correctly', () => {
+      expect(() => nameSchema.parse('   John Doe   ')).not.toThrow();
+      expect(() => emailSchema.parse('  test@example.com  ')).toThrow(); // Email schema rejects whitespace
+    });
+  });
+});
+