view release on metacpan or  search on metacpan

t/05_format_validation.t  view on Meta::CPAN

# Int64 Type Tests (as string for large values)
#
subtest 'Int64 type validation with string representation' => sub {
    my $s = schema(type => 'int64');
    my $validator = JSON::Structure::InstanceValidator->new(schema => $s);
    
    # Valid int64 values
    ok($validator->validate(0)->is_valid, 'valid int64: 0');
    ok($validator->validate(100)->is_valid, 'valid int64: 100');
    ok($validator->validate(-100)->is_valid, 'valid int64: -100');
    
    # String representation for large values beyond JS safe integer
    ok($validator->validate('9007199254740993')->is_valid, 'valid int64 string: beyond JS safe integer');
    ok($validator->validate('-9007199254740993')->is_valid, 'valid int64 string: negative beyond safe');
    ok($validator->validate('9223372036854775807')->is_valid, 'valid int64 string: max int64');
    ok($validator->validate('-9223372036854775808')->is_valid, 'valid int64 string: min int64');
    
    # Invalid
    ok(!$validator->validate('not-a-number')->is_valid, 'invalid: text');
    ok(!$validator->validate(3.14)->is_valid, 'invalid: float');
};

#
# Uint64 Type Tests
#
subtest 'Uint64 type validation' => sub {
    my $s = schema(type => 'uint64');
    my $validator = JSON::Structure::InstanceValidator->new(schema => $s);
    
    # Valid uint64 values
    ok($validator->validate(0)->is_valid, 'valid uint64: 0');
    ok($validator->validate('18446744073709551615')->is_valid, 'valid uint64 string: max value');
    ok($validator->validate('9007199254740993')->is_valid, 'valid uint64 string: beyond JS safe');
    
    # Invalid
    ok(!$validator->validate(-1)->is_valid, 'invalid uint64: negative');
    ok(!$validator->validate('-1')->is_valid, 'invalid uint64 string: negative');
    ok(!$validator->validate(3.14)->is_valid, 'invalid: float');
};

#
# Float/Double Type Tests
#
subtest 'Float and Double type validation' => sub {
    my $sf = schema(type => 'float');
    my $sd = schema(type => 'double');
    my $vf = JSON::Structure::InstanceValidator->new(schema => $sf);
    my $vd = JSON::Structure::InstanceValidator->new(schema => $sd);
    
    # Valid floats
    ok($vf->validate(3.14)->is_valid, 'valid float: 3.14');
    ok($vf->validate(0)->is_valid, 'valid float: 0');
    ok($vf->validate(-3.14)->is_valid, 'valid float: negative');
    ok($vf->validate(1.23e10)->is_valid, 'valid float: scientific notation');
    
    # Valid doubles
    ok($vd->validate(3.141592653589793)->is_valid, 'valid double: pi');
    ok($vd->validate(1.7976931348623157e308)->is_valid, 'valid double: large');
    
    # Special values as strings
    ok($vf->validate('NaN')->is_valid || !$vf->validate('NaN')->is_valid, 'NaN handling defined');
    ok($vf->validate('Infinity')->is_valid || !$vf->validate('Infinity')->is_valid, 'Infinity handling defined');
    
    # Invalid
    ok(!$vf->validate('hello')->is_valid, 'invalid float: text');
    ok(!$vd->validate([1, 2, 3])->is_valid, 'invalid double: array');
};

#
# Pattern Validation Tests
#
subtest 'Pattern validation' => sub {
    my $s = schema(
        type => 'string',
        pattern => '^[A-Z][a-z]+$'
    );
    my $validator = JSON::Structure::InstanceValidator->new(schema => $s, extended => 1);
    
    # Valid patterns
    ok($validator->validate('Hello')->is_valid, 'valid: matches pattern');
    ok($validator->validate('World')->is_valid, 'valid: matches pattern');
    ok($validator->validate('Ab')->is_valid, 'valid: minimal match');
    
    # Invalid patterns
    my $result = $validator->validate('hello');
    ok(!$result->is_valid, 'invalid: lowercase start');
    ok(scalar(grep { $_->code eq INSTANCE_STRING_PATTERN_MISMATCH } @{$result->errors}), 'reports pattern mismatch');
    
    ok(!$validator->validate('HELLO')->is_valid, 'invalid: all uppercase');
    ok(!$validator->validate('Hello123')->is_valid, 'invalid: contains numbers');
    ok(!$validator->validate('')->is_valid, 'invalid: empty string');
};

#
# Number Constraints Tests
#
subtest 'Number constraints validation' => sub {
    my $s = schema(
        type => 'number',
        minimum => 0,
        maximum => 100,
        exclusiveMinimum => 0,
        exclusiveMaximum => 100
    );
    my $validator = JSON::Structure::InstanceValidator->new(schema => $s, extended => 1);
    
    # Valid values
    ok($validator->validate(50)->is_valid, 'valid: middle of range');
    ok($validator->validate(1)->is_valid, 'valid: just above exclusive min');
    ok($validator->validate(99)->is_valid, 'valid: just below exclusive max');
    ok($validator->validate(0.001)->is_valid, 'valid: just above 0');
    ok($validator->validate(99.999)->is_valid, 'valid: just below 100');
    
    # Invalid values
    ok(!$validator->validate(0)->is_valid, 'invalid: equals exclusive minimum');
    ok(!$validator->validate(100)->is_valid, 'invalid: equals exclusive maximum');
    ok(!$validator->validate(-1)->is_valid, 'invalid: below minimum');
    ok(!$validator->validate(101)->is_valid, 'invalid: above maximum');
};

#