view release on metacpan or  search on metacpan

t/Generator.t  view on Meta::CPAN

# ------------------------------------------------------------------
# Import additional private functions under test
# ------------------------------------------------------------------
{
	no warnings 'once';
	*_validate_input_semantics	= \&App::Test::Generator::_validate_input_semantics;
	*_validate_transform_properties = \&App::Test::Generator::_validate_transform_properties;
	*_validate_module			 = \&App::Test::Generator::_validate_module;
	*_generate_transform_properties = \&App::Test::Generator::_generate_transform_properties;
	*_process_custom_properties   = \&App::Test::Generator::_process_custom_properties;
}

# ==================================================================
# _validate_input_semantics
# ==================================================================
subtest '_validate_input_semantics() passes for known semantic type' => sub {
	lives_ok(
		sub {
			_validate_input_semantics({
				input => {
					email => { type => 'string', semantic => 'email' },
				}
			})
		},
		'known semantic type lives',
	);
};

subtest '_validate_input_semantics() carps for unknown semantic type' => sub {
	my @warnings;
	local $SIG{__WARN__} = sub { push @warnings, @_ };
	_validate_input_semantics({
		input => { x => { type => 'string', semantic => 'banana' } }
	});
	ok((grep { /Unknown semantic type/ } @warnings),
		'unknown semantic type carps');
};

subtest '_validate_input_semantics() croaks when both enum and memberof present' => sub {
	throws_ok(
		sub {
			_validate_input_semantics({
				input => {
					status => {
						type	 => 'string',
						enum	 => ['a', 'b'],
						memberof => ['a', 'b'],
					},
				}
			})
		},
		qr/enum.*memberof|memberof.*enum/,
		'both enum and memberof croaks',
	);
};

subtest '_validate_input_semantics() croaks when enum is not an arrayref' => sub {
	throws_ok(
		sub {
			_validate_input_semantics({
				input => { x => { type => 'string', enum => 'not_array' } }
			})
		},
		qr/enum must be an arrayref/,
		'non-arrayref enum croaks',
	);
};

subtest '_validate_input_semantics() croaks when memberof is not an arrayref' => sub {
	throws_ok(
		sub {
			_validate_input_semantics({
				input => { x => { type => 'string', memberof => 'not_array' } }
			})
		},
		qr/memberof must be an arrayref/,
		'non-arrayref memberof croaks',
	);
};

subtest '_validate_input_semantics() passes for valid enum arrayref' => sub {
	lives_ok(
		sub {
			_validate_input_semantics({
				input => {
					status => { type => 'string', enum => ['ok', 'error'] }
				}
			})
		},
		'valid enum arrayref lives',
	);
};

subtest '_validate_input_semantics() skips non-hashref field specs' => sub {
	lives_ok(
		sub {
			_validate_input_semantics({
				input => { x => 'string' }
			})
		},
		'non-hashref field spec skipped without error',
	);
};

# ==================================================================
# _validate_transform_properties
# ==================================================================
subtest '_validate_transform_properties() passes for valid builtin property name' => sub {
	lives_ok(
		sub {
			_validate_transform_properties({
				transforms => {
					positive => {
						properties => ['non_negative'],
					}
				}
			})
		},
		'known builtin property name lives',
	);
};

subtest '_validate_transform_properties() carps for unknown builtin name' => sub {
	my @warnings;
	local $SIG{__WARN__} = sub { push @warnings, @_ };
	_validate_transform_properties({
		transforms => {
			my_transform => {
				properties => ['banana_property'],
			}
		}
	});
	ok((grep { /unknown built-in property/i } @warnings),
		'unknown builtin name carps');
};

subtest '_validate_transform_properties() passes for valid custom property hashref' => sub {
	lives_ok(
		sub {
			_validate_transform_properties({
				transforms => {
					t => {
						properties => [
							{ name => 'my_prop', code => '$result > 0' }
						]
					}
				}
			})
		},
		'valid custom property hashref lives',
	);
};

subtest '_validate_transform_properties() croaks when custom property missing code' => sub {
	throws_ok(
		sub {
			_validate_transform_properties({
				transforms => {
					t => {
						properties => [
							{ name => 'bad_prop' }
						]
					}
				}
			})
		},
		qr/name.*code|code.*name/,
		'custom property missing code croaks',
	);
};

subtest '_validate_transform_properties() croaks when properties is not an arrayref' => sub {
	throws_ok(
		sub {
			_validate_transform_properties({
				transforms => {
					t => { properties => 'not_array' }
				}
			})
		},
		qr/must be an array/,
		'non-arrayref properties croaks',
	);
};

subtest '_validate_transform_properties() skips transforms with no properties key' => sub {
	lives_ok(
		sub {
			_validate_transform_properties({
				transforms => {
					t => { input => { x => { type => 'string' } } }
				}
			})
		},
		'transform without properties key lives',
	);
};

subtest '_validate_transform_properties() croaks for invalid property definition type' => sub {
	throws_ok(
		sub {
			_validate_transform_properties({
				transforms => {
					t => { properties => [ [1, 2, 3] ] }
				}
			})
		},
		qr/invalid property definition/i,
		'invalid property definition type croaks',
	);
};

# ==================================================================
# _validate_module
# ==================================================================
subtest '_validate_module() returns 1 for undef module' => sub {
	is(_validate_module(undef, 'test.yml'), 1, 'undef module returns 1');
};

subtest '_validate_module() returns 1 for empty string module' => sub {
	is(_validate_module('', 'test.yml'), 1, 'empty module returns 1');
};

subtest '_validate_module() returns 1 for core module in @INC' => sub {
	# Scalar::Util is always available
	is(_validate_module('Scalar::Util', 'test.yml'), 1,
		'Scalar::Util found in @INC');
};

subtest '_validate_module() carps and returns 0 for unknown module' => sub {
	my @warnings;
	local $SIG{__WARN__} = sub { push @warnings, @_ };
	my $result = _validate_module('No::Such::Module::XYZ', 'test.yml');
	is($result, 0, 'unknown module returns 0');
	ok((grep { /not found/i } @warnings), 'carps about module not found');
};