schema_test_implementation_guide

GoZod Schema Test Implementation Guide

A concise and practical guide for building GoZod Schema test files, updated with the latest practices from string_test.go, object_test.go, and complex_test.go.

---

🎯 Core Principles

• Complete Strict Type Semantics: Test both Parse(any) and StrictParse(T) methods thoroughly.
• Parse vs StrictParse Duality: Verify Parse provides runtime flexibility while StrictParse provides compile-time type safety.
• Generic Type Safety: All tests must verify compile-time type safety and proper constraint handling.
• Modifier Behavior: Test immutability, correct type transformations, and Default/Prefault semantics.
• Comprehensive & Organized: Follow the unified section structure for clarity. Test boundaries and edge cases thoroughly.
• Real-World Patterns: Tests should reflect actual API usage, including modifier chaining and error handling.
• Default vs Prefault: Verify Default short-circuits validation while Prefault goes through full parsing pipeline.

---

🏗️ Test File Architecture

Each test file for a schema type should follow this consolidated architecture based on latest implementations:

package types

// ... imports

// =============================================================================
// Basic functionality tests
// =============================================================================
func Test<Type>_BasicFunctionality(t *testing.T) {
    t.Run("valid <type> inputs", func(t *testing.T) { /* ... */ })
    t.Run("invalid type inputs", func(t *testing.T) { /* ... */ })
    t.Run("Parse and MustParse methods", func(t *testing.T) { /* ... */ })
    t.Run("custom error message", func(t *testing.T) { /* ... */ })
}

// =============================================================================
// StrictParse and MustStrictParse tests
// =============================================================================
func Test<Type>_StrictParse(t *testing.T) {
    t.Run("basic functionality", func(t *testing.T) { /* ... */ })
    t.Run("with validation constraints", func(t *testing.T) { /* ... */ })
    t.Run("with pointer types", func(t *testing.T) { /* ... */ })
    t.Run("with default values", func(t *testing.T) { /* ... */ })
    t.Run("with prefault values", func(t *testing.T) { /* ... */ })
}

func Test<Type>_MustStrictParse(t *testing.T) { /* ... */ }

// =============================================================================
// Type safety tests
// =============================================================================
func Test<Type>_TypeSafety(t *testing.T) { /* ... */ }

// =============================================================================
// Modifier methods tests
// =============================================================================
func Test<Type>_Modifiers(t *testing.T) { /* ... */ }

// =============================================================================
// Chaining tests
// =============================================================================
func Test<Type>_Chaining(t *testing.T) { /* ... */ }

// =============================================================================
// Default and prefault tests
// =============================================================================
func Test<Type>_DefaultAndPrefault(t *testing.T) {
    t.Run("Default has higher priority than Prefault", func(t *testing.T) { /* ... */ })
    t.Run("Default short-circuits validation", func(t *testing.T) { /* ... */ })
    t.Run("Prefault goes through full validation", func(t *testing.T) { /* ... */ })
    t.Run("Prefault only triggers for nil input", func(t *testing.T) { /* ... */ })
}

// =============================================================================
// Refine tests
// =============================================================================
func Test<Type>_Refine(t *testing.T) { /* ... */ }
func Test<Type>_RefineAny(t *testing.T) { /* ... */ }

// =============================================================================
// Coercion tests (Primitives only)
// =============================================================================
func Test<Type>_Coercion(t *testing.T) { /* ... */ }

// =============================================================================
// Error handling and edge case tests
// =============================================================================
func Test<Type>_ErrorHandling(t *testing.T) { /* ... */ }

// =============================================================================
// OVERWRITE TESTS (Transform/Pipe operations)
// =============================================================================
func Test<Type>_Overwrite(t *testing.T) { /* ... */ }