refactor: reorganize test suite into focused files

- Split monolithic ValidatorTest.php into 8 focused test files
- Create AssociativeValidatorTest.php for associative array validation
- Create ObjectValidatorTest.php for stdClass object validation
- Create ArrayValidatorTest.php for plain array validation
- Create StringValidatorTest.php for string validation and formats
- Create IntValidatorTest.php for integer validation
- Create FloatValidatorTest.php for float validation
- Create FieldValidatorTest.php for base validator functionality
- Create NumericConstraintsTraitTest.php for trait-specific tests
- Improve test organization and maintainability
- All 57 tests pass with 154 assertions

Author: lemmon

tests/ArrayValidatorTest.php

@@ -0,0 +1,127 @@
+<?php
+
+use Lemmon\Validator;
+
+it('should validate plain arrays', function () {
+    $validator = Validator::isArray();
+
+    $data = $validator->validate([1, 2, 3, 'foo']);
+    expect($data)->toBe([1, 2, 3, 'foo']);
+
+    $data = $validator->validate(['a', 'b', 'c']);
+    expect($data)->toBe(['a', 'b', 'c']);
+
+    $data = $validator->validate([]);
+    expect($data)->toBe([]);
+});
+
+it('should reject associative arrays', function () {
+    $validator = Validator::isArray();
+
+    $validator->validate(['key' => 'value']);
+})->throws(Lemmon\ValidationException::class);
+
+it('should validate array items with type validator', function () {
+    $validator = Validator::isArray()->items(Validator::isString());
+
+    $data = $validator->validate(['foo', 'bar', 'baz']);
+    expect($data)->toBe(['foo', 'bar', 'baz']);
+});
+
+it('should reject array items that do not match type validator', function () {
+    $validator = Validator::isArray()->items(Validator::isString());
+
+    $validator->validate(['foo', 123, 'baz']);
+})->throws(Lemmon\ValidationException::class);
+
+it('should coerce string to single-item array', function () {
+    $validator = Validator::isArray()->coerce();
+
+    // Any string becomes single-item array
+    $data = $validator->validate('single');
+    expect($data)->toBe(['single']);
+
+    $data = $validator->validate('[1,2,3]');
+    expect($data)->toBe(['[1,2,3]']);
+
+    $data = $validator->validate('a,b,c');
+    expect($data)->toBe(['a,b,c']);
+});
+
+it('should coerce associative arrays to indexed arrays', function () {
+    $validator = Validator::isArray()->coerce();
+
+    $data = $validator->validate(['key1' => 'value1', 'key2' => 'value2']);
+    expect($data)->toBe(['value1', 'value2']);
+
+    $data = $validator->validate(['a' => 1, 'b' => 2, 'c' => 3]);
+    expect($data)->toBe([1, 2, 3]);
+});
+
+it('should coerce scalar values to array', function () {
+    $validator = Validator::isArray()->coerce();
+
+    $data = $validator->validate(123);
+    expect($data)->toBe([123]);
+
+    $data = $validator->validate(true);
+    expect($data)->toBe([true]);
+});
+
+it('should work with required and default values', function () {
+    $validator = Validator::isArray()->default(['default']);
+
+    $data = $validator->validate(null, 'test', []);
+    expect($data)->toBe(['default']);
+
+    // Test with required
+    $validator = Validator::isArray()->required();
+    $validator->validate(null, 'test', []);
+})->throws(Lemmon\ValidationException::class);
+
+it('should work with oneOf constraint', function () {
+    $validator = Validator::isArray()->oneOf([[1, 2], [3, 4]]);
+
+    $data = $validator->validate([1, 2]);
+    expect($data)->toBe([1, 2]);
+
+    $validator->validate([1, 2, 3]);
+})->throws(Lemmon\ValidationException::class);
+
+it('should handle null correctly with coercion', function () {
+    // Without required - null should stay null
+    $validator = Validator::isArray()->coerce();
+    $data = $validator->validate(null, 'test', []);
+    expect($data)->toBe(null);
+
+    // With default - null should use default
+    $validator = Validator::isArray()->coerce()->default(['default']);
+    $data = $validator->validate(null, 'test', []);
+    expect($data)->toBe(['default']);
+
+    // With required - null should throw error
+    $validator = Validator::isArray()->coerce()->required();
+    $validator->validate(null, 'test', []);
+})->throws(Lemmon\ValidationException::class);
+
+it('should allow null for optional array validator', function () {
+    $validator = Validator::isArray();
+    [$valid, $data, $errors] = $validator->tryValidate(null);
+    expect($valid)->toBe(true);
+    expect($data)->toBe(null);
+    expect($errors)->toBe(null);
+});
+
+it('should coerce empty string to empty array', function () {
+    $validator = Validator::isArray()->coerce();
+    $data = $validator->validate('');
+    expect($data)->toBe([]);
+});
+
+it('should nullify empty string and empty array when nullifyEmpty is called', function () {
+    $arrayValidator = Validator::isArray()->nullifyEmpty();
+    expect($arrayValidator->validate([]))->toBe(null);
+
+    // Should not nullify non-empty values
+    expect($arrayValidator->validate([1, 2]))->toBe([1, 2]);
+});

tests/AssociativeValidatorTest.php

@@ -0,0 +1,119 @@
+<?php
+
+use Lemmon\Validator;
+
+it('should validate a correct payload', function () {
+    $schema = Validator::isAssociative([
+        'required' => Validator::isString()->required(),
+        'optional' => Validator::isString(),
+        'forced'   => Validator::isString()->default('Hello!'),
+        'level'    => Validator::isInt()->coerce()->oneOf([3, 5, 8])->default(3),
+        'override' => Validator::isBool()->coerce()->default(false),
+    ])->coerceAll();
+
+    $input = [
+        'required' => 'test',
+        'level' => '5',
+    ];
+
+    $data = $schema->validate($input);
+
+    expect($data)->toBe([
+        'required' => 'test',
+        'optional' => null,
+        'forced'   => 'Hello!',
+        'level'    => 5,
+        'override' => false,
+    ]);
+});
+
+it('should throw a validation exception for invalid payload', function () {
+    $schema = Validator::isAssociative([
+        'required' => Validator::isString()->required(),
+        'level'    => Validator::isInt()->oneOf([3, 5, 8]),
+    ]);
+
+    $input = [
+        'level' => 10,
+    ];
+
+    $schema->validate($input);
+})->throws(Lemmon\ValidationException::class);
+
+it('should throw a validation exception for non-array input in AssociativeValidator', function () {
+    $schema = Validator::isAssociative([]);
+
+    try {
+        $schema->validate('not an array');
+    } catch (Lemmon\ValidationException $e) {
+        expect($e->getErrors())->toBe(['Input must be an associative array.']);
+    }
+});
+
+it('should validate an empty associative array with an empty schema', function () {
+    $schema = Validator::isAssociative([]);
+    $data = $schema->validate([]);
+    expect($data)->toBe([]);
+});
+
+it('should allow Validator::isAssociative() to be called without arguments', function () {
+    $schema = Validator::isAssociative();
+    $data = $schema->validate([]);
+    expect($data)->toBe([]);
+});
+
+it('should handle null input for AssociativeValidator created without arguments gracefully', function () {
+    $schema = Validator::isAssociative();
+    [$valid, $data, $errors] = $schema->tryValidate(null);
+    expect($valid)->toBe(true);
+    expect($data)->toBe(null);
+    expect($errors)->toBe(null);
+});
+
+it('should allow null for optional associative array validator', function () {
+    $validator = Validator::isAssociative();
+    $data = $validator->validate(null);
+    expect($data)->toBe(null);
+});
+
+it('should allow null for optional nested associative array in schema', function () {
+    $schema = Validator::isAssociative([
+        'nested' => Validator::isAssociative(),
+    ]);
+
+    $input = [
+        'nested' => null,
+    ];
+
+    $data = $schema->validate($input);
+    expect($data)->toBe(['nested' => null]);
+});
+
+it('should coerce stdClass object to associative array when coerce is enabled', function () {
+    $schema = Lemmon\Validator::isAssociative([
+        'name' => Lemmon\Validator::isString(),
+        'age' => Lemmon\Validator::isInt(),
+    ])->coerce();
+
+    $object = new stdClass();
+    $object->name = 'John Doe';
+    $object->age = 42;
+
+    $validated = $schema->validate($object);
+
+    expect($validated)->toBe([
+        'name' => 'John Doe',
+        'age' => 42,
+    ]);
+});
+
+it('should fail to validate stdClass object when coerce is not enabled', function () {
+    $schema = Lemmon\Validator::isAssociative([
+        'name' => Lemmon\Validator::isString(),
+    ]);
+
+    $object = new stdClass();
+    $object->name = 'John Doe';
+
+    $schema->validate($object);
+})->throws(Lemmon\ValidationException::class, 'Input must be an associative array.');

tests/FieldValidatorTest.php

@@ -0,0 +1,86 @@
+<?php
+
+use Lemmon\Validator;
+
+it('should throw a validation exception with a generic message for standalone validators', function () {
+    try {
+        Validator::isString()->validate(123);
+    } catch (Lemmon\ValidationException $e) {
+        expect($e->getErrors())->toBe(['Value must be a string.']);
+    }
+});
+
+it('should return a result tuple for standalone validators', function () {
+    [$valid, $data, $errors] = Validator::isString()->tryValidate('hello');
+    expect($valid)->toBe(true);
+    expect($data)->toBe('hello');
+    expect($errors)->toBe(null);
+
+    [$valid, $data, $errors] = Validator::isString()->tryValidate(123);
+    expect($valid)->toBe(false);
+    expect($data)->toBe(123);
+    expect($errors)->toBe(['Value must be a string.']);
+});
+
+it('should collect all validation errors', function () {
+    $validator = Validator::isString()->minLength(10)->maxLength(3)->email();
+
+    [$valid, $data, $errors] = $validator->tryValidate('short');
+
+    expect($valid)->toBe(false);
+    expect($errors)->toHaveCount(3);
+    expect($errors)->toContain('Value must be at least 10 characters long.');
+    expect($errors)->toContain('Value must be at most 3 characters long.');
+    expect($errors)->toContain('Value must be a valid email address.');
+});
+
+it('should pass context to custom validators', function () {
+    $validator = Validator::isString()->addValidation(
+        function ($value, $key, $input) {
+            return $key === 'test' && is_array($input) && isset($input['other']);
+        },
+        'Custom validation failed.'
+    );
+
+    [$valid, $data, $errors] = $validator->tryValidate('value', 'test', ['other' => 'data']);
+    expect($valid)->toBe(true);
+
+    [$valid, $data, $errors] = $validator->tryValidate('value', 'wrong', ['other' => 'data']);
+    expect($valid)->toBe(false);
+    expect($errors)->toContain('Custom validation failed.');
+});
+
+it('should validate allOf combinator', function () {
+    $validator = Validator::isString()->allOf([
+        Validator::isString()->minLength(3),
+        Validator::isString()->maxLength(10),
+        Validator::isString()->pattern('/^[a-z]+$/')
+    ]);
+
+    expect($validator->validate('hello'))->toBe('hello');
+
+    $validator->validate('hi'); // Too short
+})->throws(Lemmon\ValidationException::class, 'Value must satisfy all validation rules.');
+
+it('should validate anyOf combinator', function () {
+    $validator = Validator::isString()->anyOf([
+        Validator::isString()->email(),
+        Validator::isString()->url(),
+        Validator::isString()->uuid()
+    ]);
+
+    expect($validator->validate('test@example.com'))->toBe('test@example.com');
+    expect($validator->validate('https://example.com'))->toBe('https://example.com');
+    expect($validator->validate('550e8400-e29b-41d4-a716-446655440000'))->toBe('550e8400-e29b-41d4-a716-446655440000');
+
+    $validator->validate('invalid-value');
+})->throws(Lemmon\ValidationException::class, 'Value must satisfy at least one validation rule.');
+
+it('should validate not combinator', function () {
+    $validator = Validator::isString()->not(Validator::isString()->email());
+
+    expect($validator->validate('not-an-email'))->toBe('not-an-email');
+    expect($validator->validate('hello world'))->toBe('hello world');
+
+    $validator->validate('test@example.com');
+})->throws(Lemmon\ValidationException::class, 'Value must not satisfy the validation rule.');

tests/FloatValidatorTest.php

@@ -0,0 +1,41 @@
+<?php
+
+use Lemmon\Validator;
+
+it('should validate floats', function () {
+    $validator = Validator::isFloat();
+
+    expect($validator->validate(42.5))->toBe(42.5);
+    expect($validator->validate(100))->toBe(100.0);
+    expect($validator->validate('123.45'))->toBe(123.45);
+
+    $validator->validate('not-a-float');
+})->throws(Lemmon\ValidationException::class, 'Value must be a float.');
+
+it('should validate float ranges', function () {
+    $rangeValidator = Validator::isFloat()->min(10)->max(100);
+
+    expect($rangeValidator->validate(50))->toBe(50.0);
+    expect($rangeValidator->validate(10))->toBe(10.0);
+    expect($rangeValidator->validate(100))->toBe(100.0);
+
+    $rangeValidator->validate(5);
+})->throws(Lemmon\ValidationException::class);
+
+it('should validate float multiples', function () {
+    $multipleValidator = Validator::isFloat()->multipleOf(5);
+
+    expect($multipleValidator->validate(15))->toBe(15.0);
+    expect($multipleValidator->validate(20))->toBe(20.0);
+
+    $multipleValidator->validate(13);
+})->throws(Lemmon\ValidationException::class, 'Value must be a multiple of 5.');
+
+it('should validate positive floats', function () {
+    $positiveValidator = Validator::isFloat()->positive();
+
+    expect($positiveValidator->validate(1))->toBe(1.0);
+    expect($positiveValidator->validate(0.1))->toBe(0.1);
+
+    $positiveValidator->validate(-1);
+})->throws(Lemmon\ValidationException::class, 'Value must be positive.');