view release on metacpan or  search on metacpan

t/extended_tests.t  view on Meta::CPAN

		my $input_spec = { val => { type => $type } };
		my $e = App::Test::Generator::Emitter::Perl->new(
			schema  => { foo => { input => $input_spec } },
			plans   => { foo => { getset_test => 1 } },
			package => 'My::Module',
		);
		my $code    = $e->emit();
		my $tmpdir  = tempdir(CLEANUP => 1);
		my $outfile = File::Spec->catfile($tmpdir, "getset_$type.t");
		open my $fh, '>', $outfile or die $!;
		print $fh $code;
		close $fh;
		is(system($^X, '-c', $outfile), 0,
			"getset with $type type produces compilable code");
	}
};

# ==================================================================
# Generator render helpers — branch coverage
# Target specific branches not yet exercised
# ==================================================================

subtest 'perl_quote: boolean string "true" -> !!1' => sub {
	is(App::Test::Generator::perl_quote('true'), '!!1',
		'"true" -> !!1');
};

subtest 'perl_quote: boolean string "false" -> !!0' => sub {
	is(App::Test::Generator::perl_quote('false'), '!!0',
		'"false" -> !!0');
};

subtest 'perl_quote: numeric value returned unquoted' => sub {
	is(App::Test::Generator::perl_quote(42),   '42',   'integer unquoted');
	is(App::Test::Generator::perl_quote(3.14), '3.14', 'float unquoted');
	is(App::Test::Generator::perl_quote(-1),   '-1',   'negative unquoted');
	is(App::Test::Generator::perl_quote(0),    '0',    'zero unquoted');
};

subtest 'perl_quote: string value returned single-quoted' => sub {
	like(App::Test::Generator::perl_quote('hello'), qr/^'hello'$/, 'string single-quoted');
};

subtest 'perl_quote: regexp rendered as qr{}' => sub {
	my $result = App::Test::Generator::perl_quote(qr/^\d+$/);
	like($result, qr/qr\{/, 'regexp rendered as qr{}');
};

subtest 'perl_quote: regexp with modifiers includes modifiers' => sub {
	my $result = App::Test::Generator::perl_quote(qr/foo/i);
	like($result, qr/i/, 'case-insensitive modifier included');
};

subtest 'perl_quote: hashref falls through to render_fallback' => sub {
	my $result = App::Test::Generator::perl_quote({ key => 'val' });
	ok(defined $result,       'hashref handled');
	like($result, qr/key/,    'key present in output');
	like($result, qr/val/,    'value present in output');
};

subtest 'perl_sq: backslash escaped correctly' => sub {
	my $result = App::Test::Generator::perl_sq('a\\b');
	like($result, qr/\\\\/, 'backslash doubled');
};

subtest 'perl_sq: single quote escaped correctly' => sub {
	my $result = App::Test::Generator::perl_sq("it's");
	like($result, qr/\\'/, 'apostrophe escaped');
};

subtest 'perl_sq: control characters escaped' => sub {
	is(App::Test::Generator::perl_sq("\n"), '\\n', 'newline escaped');
	is(App::Test::Generator::perl_sq("\t"), '\\t', 'tab escaped');
	is(App::Test::Generator::perl_sq("\r"), '\\r', 'CR escaped');
};

subtest 'perl_sq: NUL byte escaped as \\0' => sub {
	is(App::Test::Generator::perl_sq("\0"), '\\0', 'NUL escaped');
};

subtest 'q_wrap: prefers bracket form when available' => sub {
	my $result = App::Test::Generator::q_wrap('hello');
	like($result, qr/^q\{hello\}$/, 'bracket form preferred');
};

subtest 'q_wrap: falls back to () when {} used in string' => sub {
	my $result = App::Test::Generator::q_wrap('a{b}c');
	ok(defined $result, 'string with braces handled');
	unlike($result, qr/^q\{/, 'does not use {} delimiter');
};

subtest 'q_wrap: falls back to [] when {} and () used' => sub {
	my $result = App::Test::Generator::q_wrap('a{b}(c)d');
	ok(defined $result, 'string with braces and parens handled');
};

subtest 'render_args_hash: sorts keys deterministically' => sub {
	my $r1 = App::Test::Generator::render_args_hash({ b => 2, a => 1, c => 3 });
	my $r2 = App::Test::Generator::render_args_hash({ c => 3, a => 1, b => 2 });
	is($r1, $r2, 'sorted output is identical regardless of input order');
};

subtest 'render_args_hash: handles Regexp values' => sub {
	my $result = App::Test::Generator::render_args_hash({ matches => qr/^\d+$/ });
	like($result, qr/qr\{/, 'Regexp rendered as qr{}');
};

subtest 'render_args_hash: handles arrayref values' => sub {
	my $result = App::Test::Generator::render_args_hash({ values => [1, 2, 3] });
	like($result, qr/1.*2.*3/s, 'arrayref values rendered');
};

subtest 'render_hash: matches and nomatch compiled to Regexp' => sub {
	my $result = App::Test::Generator::render_hash({
		param => { type => 'string', matches => '^[a-z]+$' }
	});
	like($result, qr/qr\{/, 'matches pattern compiled to qr{}');
};

subtest 'render_hash: scalar type shorthand expanded' => sub {
	my $result = App::Test::Generator::render_hash({
		name => 'string'
	});
	like($result, qr/type.*string/, 'scalar shorthand expanded to type spec');
};

subtest 'render_arrayref_map: returns empty string for empty hashref' => sub {
	my $result = App::Test::Generator::render_arrayref_map({});
	ok(defined $result, 'empty hashref: returns defined value');
	# Empty hash has no arrayref entries so result is empty string
	is($result, '', 'empty hashref -> empty string');
};

subtest 'render_arrayref_map: returns () for undef input' => sub {
	my $result = App::Test::Generator::render_arrayref_map(undef);
	is($result, '()', 'undef input -> ()');
};