@jmruthers/pace-core 0.5.135 → 0.5.137

package/src/validation/__tests__/schemaUtils.unit.test.ts

@@ -1,451 +0,0 @@
-/**
- * @file Schema Utility Functions Tests
- * @package @jmruthers/pace-core
- * @module Validation/__tests__
- * @since 0.4.0
- * 
- * Comprehensive tests for schema utility functions following TEST_STANDARD.md
- */
-
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-import { pickSchema, combineSchemas } from '../schemaUtils';
-
-describe('[unit] Schema Utility Functions', () => {
-  describe('pickSchema', () => {
-    it('creates a subset schema with selected keys', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string().email(),
-        age: z.number(),
-      });
-
-      const pickedSchema = pickSchema(originalSchema, ['name', 'email']);
-      const result = pickedSchema.safeParse({
-        name: 'John Doe',
-        email: 'john@example.com',
-        age: 30, // This should be ignored
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toEqual({
-          name: 'John Doe',
-          email: 'john@example.com',
-        });
-      }
-    });
-
-    it('validates only picked fields', () => {
-      const originalSchema = z.object({
-        name: z.string().min(3),
-        email: z.string().email(),
-        phone: z.string().optional(),
-      });
-
-      const pickedSchema = pickSchema(originalSchema, ['name']);
-      const validResult = pickedSchema.safeParse({ name: 'John Doe' });
-      expect(validResult.success).toBe(true);
-
-      const invalidResult = pickedSchema.safeParse({ name: 'Jo' }); // Too short
-      expect(invalidResult.success).toBe(false);
-    });
-
-    it('handles single field selection', () => {
-      const originalSchema = z.object({
-        id: z.string(),
-        name: z.string(),
-        email: z.string(),
-      });
-
-      const pickedSchema = pickSchema(originalSchema, ['id']);
-      const result = pickedSchema.safeParse({ id: '123' });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toEqual({ id: '123' });
-      }
-    });
-
-    it('preserves validation rules', () => {
-      const originalSchema = z.object({
-        email: z.string().email(),
-        password: z.string().min(8),
-      });
-
-      const pickedSchema = pickSchema(originalSchema, ['email']);
-      
-      const validResult = pickedSchema.safeParse({ email: 'test@example.com' });
-      expect(validResult.success).toBe(true);
-
-      const invalidResult = pickedSchema.safeParse({ email: 'invalid-email' });
-      expect(invalidResult.success).toBe(false);
-    });
-
-    it('handles empty key array', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string(),
-      });
-
-      const pickedSchema = pickSchema(originalSchema, []);
-      const result = pickedSchema.safeParse({ name: 'Test' });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toEqual({});
-      }
-    });
-
-    it('handles key array with invalid keys', () => {
-      const originalSchema = z.object({
-        name: z.string(),
-        email: z.string(),
-      });
-
-      // Picking keys that don't exist should result in empty schema
-      const pickedSchema = pickSchema(originalSchema, ['invalidKey' as any]);
-      const result = pickedSchema.safeParse({ name: 'Test' });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(Object.keys(result.data)).toHaveLength(0);
-      }
-    });
-
-    it('handles complex nested validation', () => {
-      const originalSchema = z.object({
-        user: z.object({
-          name: z.string(),
-          email: z.string().email(),
-        }),
-        settings: z.object({
-          theme: z.string(),
-        }),
-      });
-
-      const pickedSchema = pickSchema(originalSchema, ['user']);
-      const result = pickedSchema.safeParse({
-        user: {
-          name: 'John',
-          email: 'john@example.com',
-        },
-      });
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('combineSchemas', () => {
-    it('merges multiple schemas into one', () => {
-      const schema1 = z.object({
-        name: z.string(),
-        email: z.string(),
-      });
-
-      const schema2 = z.object({
-        age: z.number(),
-        phone: z.string(),
-      });
-
-      const combined = combineSchemas([schema1, schema2]);
-      const result = combined.safeParse({
-        name: 'John',
-        email: 'john@example.com',
-        age: 30,
-        phone: '1234567890',
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toEqual({
-          name: 'John',
-          email: 'john@example.com',
-          age: 30,
-          phone: '1234567890',
-        });
-      }
-    });
-
-    it('validates all fields from combined schemas', () => {
-      const schema1 = z.object({
-        email: z.string().email(),
-      });
-
-      const schema2 = z.object({
-        password: z.string().min(8),
-      });
-
-      const combined = combineSchemas([schema1, schema2]);
-      
-      const validResult = combined.safeParse({
-        email: 'test@example.com',
-        password: 'SecurePass123',
-      });
-      expect(validResult.success).toBe(true);
-
-      const invalidResult = combined.safeParse({
-        email: 'invalid',
-        password: 'short',
-      });
-      expect(invalidResult.success).toBe(false);
-    });
-
-    it('handles overlapping field names (latter overwrites)', () => {
-      const schema1 = z.object({
-        name: z.string().min(1),
-        email: z.string(),
-      });
-
-      const schema2 = z.object({
-        email: z.string().email(),
-        age: z.number(),
-      });
-
-      const combined = combineSchemas([schema1, schema2]);
-      const result = combined.safeParse({
-        name: 'John',
-        email: 'john@example.com',
-        age: 30,
-      });
-
-      expect(result.success).toBe(true);
-      // email validation should be the stricter one from schema2
-      if (result.success) {
-        expect(result.data.email).toBe('john@example.com');
-      }
-    });
-
-    it('handles empty schema array', () => {
-      const combined = combineSchemas([]);
-      const result = combined.safeParse({});
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(Object.keys(result.data)).toHaveLength(0);
-      }
-    });
-
-    it('handles single schema', () => {
-      const schema1 = z.object({
-        name: z.string(),
-        email: z.string().email(),
-      });
-
-      const combined = combineSchemas([schema1]);
-      const result = combined.safeParse({
-        name: 'John',
-        email: 'john@example.com',
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toEqual({
-          name: 'John',
-          email: 'john@example.com',
-        });
-      }
-    });
-
-    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 schema4 = z.object({ age: z.number() });
-
-      const combined = combineSchemas([schema1, schema2, schema3, schema4]);
-      const result = combined.safeParse({
-        name: 'John',
-        email: 'john@example.com',
-        phone: '1234567890',
-        age: 30,
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(Object.keys(result.data)).toHaveLength(4);
-      }
-    });
-
-    it('preserves optional fields from original schemas', () => {
-      const schema1 = z.object({
-        name: z.string(),
-        email: z.string().optional(),
-      });
-
-      const schema2 = z.object({
-        phone: z.string().optional(),
-      });
-
-      const combined = combineSchemas([schema1, schema2]);
-      
-      const resultWithAll = combined.safeParse({
-        name: 'John',
-        email: 'john@example.com',
-        phone: '1234567890',
-      });
-      expect(resultWithAll.success).toBe(true);
-
-      const resultWithoutOptional = combined.safeParse({
-        name: 'John',
-      });
-      expect(resultWithoutOptional.success).toBe(true);
-    });
-
-    it('handles complex nested schema merging', () => {
-      const schema1 = z.object({
-        user: z.object({
-          name: z.string(),
-        }),
-      });
-
-      const schema2 = z.object({
-        user: z.object({
-          email: z.string().email(),
-        }),
-      });
-
-      const combined = combineSchemas([schema1, schema2]);
-      const result = combined.safeParse({
-        user: {
-          name: 'John',
-          email: 'john@example.com',
-        },
-      });
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('pickSchema handles schema with no keys picked', () => {
-      const schema = z.object({
-        name: z.string(),
-        email: z.string(),
-      });
-
-      const picked = pickSchema(schema, []);
-      const result = picked.safeParse({ name: 'Test', email: 'test@example.com' });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(Object.keys(result.data)).toHaveLength(0);
-      }
-    });
-
-    it('combineSchemas handles schemas with conflicting validation rules', () => {
-      const schema1 = z.object({
-        value: z.string().min(5),
-      });
-
-      const schema2 = z.object({
-        value: z.string().max(10),
-      });
-
-      const combined = combineSchemas([schema1, schema2]);
-      
-      // When schemas are merged, the last one's validation typically wins
-      // But we can test that it validates at least something
-      const longResult = combined.safeParse({ value: '123456789012' });
-      expect(longResult.success).toBe(false); // Too long
-
-      const validResult = combined.safeParse({ value: '12345' });
-      expect(validResult.success).toBe(true);
-      
-      // Very short strings may still fail depending on merge order
-      const veryShortResult = combined.safeParse({ value: '123' });
-      // The result depends on merge order - just check it's defined
-      expect(veryShortResult.success).toBeDefined();
-    });
-
-    it('handles schemas with multiple field types', () => {
-      const schema1 = z.object({
-        string: z.string(),
-        number: z.number(),
-        boolean: z.boolean(),
-      });
-
-      const schema2 = z.object({
-        array: z.array(z.string()),
-        object: z.object({ nested: z.string() }),
-      });
-
-      const combined = combineSchemas([schema1, schema2]);
-      const result = combined.safeParse({
-        string: 'test',
-        number: 42,
-        boolean: true,
-        array: ['a', 'b'],
-        object: { nested: 'value' },
-      });
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('Integration', () => {
-    it('combines picked schemas', () => {
-      const baseSchema = z.object({
-        name: z.string(),
-        email: z.string().email(),
-        age: z.number(),
-        phone: z.string(),
-      });
-
-      const userInfo = pickSchema(baseSchema, ['name', 'email']);
-      const contactInfo = pickSchema(baseSchema, ['email', 'phone']);
-
-      const combined = combineSchemas([userInfo, contactInfo]);
-      const result = combined.safeParse({
-        name: 'John',
-        email: 'john@example.com',
-        phone: '1234567890',
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toEqual({
-          name: 'John',
-          email: 'john@example.com',
-          phone: '1234567890',
-        });
-      }
-    });
-
-    it('handles real-world user registration scenario', () => {
-      const personalInfo = z.object({
-        firstName: z.string(),
-        lastName: z.string(),
-        dateOfBirth: z.string(),
-      });
-
-      const contactInfo = z.object({
-        email: z.string().email(),
-        phone: z.string(),
-      });
-
-      const preferences = z.object({
-        newsletter: z.boolean(),
-        notifications: z.boolean(),
-      });
-
-      const registrationSchema = combineSchemas([personalInfo, contactInfo, preferences]);
-      
-      const result = registrationSchema.safeParse({
-        firstName: 'John',
-        lastName: 'Doe',
-        dateOfBirth: '1990-01-01',
-        email: 'john@example.com',
-        phone: '1234567890',
-        newsletter: true,
-        notifications: false,
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(Object.keys(result.data)).toHaveLength(7);
-      }
-    });
-  });
-});
-