Skip to content

Commit

Permalink
test tweaks
Browse files Browse the repository at this point in the history
  • Loading branch information
@kraih
kraih committed May 14, 2013
1 parent 08ac740 commit 93f9536
Show file tree
Hide file tree
Showing 5 changed files with 300 additions and 552 deletions.
50 changes: 14 additions & 36 deletions t/mojo/parameters.t
View file
Expand Up @@ -10,18 +10,13 @@ is $params->to_string, 'foo=b%3Bar&baz=23', 'right format';
is $params2->to_string, 'x=1&y=2', 'right format';
is $params->to_string, 'foo=b%3Bar&baz=23', 'right format';
is_deeply $params->params, ['foo', 'b;ar', 'baz', 23], 'right structure';
is $params->[0], 'foo', 'right value';
is $params->[1], 'b;ar', 'right value';
is $params->[2], 'baz', 'right value';
is $params->[3], 23, 'right value';
is $params->[4], undef, 'no value';

# Append
is_deeply $params->params, ['foo', 'b;ar', 'baz', 23], 'right structure';
$params->append(a => 4, a => 5, b => 6, b => 7);
is $params->to_string, "foo=b%3Bar&baz=23&a=4&a=5&b=6&b=7", 'right format';
is $params->to_string, 'foo=b%3Bar&baz=23&a=4&a=5&b=6&b=7', 'right format';
push @$params, c => 'f;oo';
is $params->to_string, "foo=b%3Bar&baz=23&a=4&a=5&b=6&b=7&c=f%3Boo",
is $params->to_string, 'foo=b%3Bar&baz=23&a=4&a=5&b=6&b=7&c=f%3Boo',
'right format';

# Clone
Expand Down Expand Up @@ -63,17 +58,17 @@ is_deeply [$params->param], [qw(q t w)], 'right structure';
$params->append('a', 4, 'a', 5, 'b', 6, 'b', 7);
is_deeply $params->to_hash,
{a => [4, 5], b => [6, 7], q => 1, w => 2, t => 7}, 'right structure';
$params = Mojo::Parameters->new(foo => undef, bar => 'bar');
$params = Mojo::Parameters->new(foo => '', bar => 'bar');
is $params->to_string, 'foo=&bar=bar', 'right format';
$params = Mojo::Parameters->new(bar => 'bar', foo => undef);
$params = Mojo::Parameters->new(bar => 'bar', foo => '');
is $params->to_string, 'bar=bar&foo=', 'right format';

# "0"
$params = Mojo::Parameters->new(foo => 0);
is_deeply $params->param('foo'), 0, 'right structure';
is $params->param('foo'), 0, 'right value';
is $params->to_string, 'foo=0', 'right format';
$params = Mojo::Parameters->new($params->to_string);
is_deeply $params->param('foo'), 0, 'right structure';
is $params->param('foo'), 0, 'right value';
is $params->to_hash->{foo}, 0, 'right value';
is_deeply $params->to_hash, {foo => 0}, 'right structure';
is $params->to_string, 'foo=0', 'right format';
Expand All @@ -95,41 +90,26 @@ is "$params", 'foo=bar&baz=23', 'right format';
$params = Mojo::Parameters->new('foo=bar;baz=23');
is "$params", 'foo=bar;baz=23', 'right format';

# Undefined params
$params = Mojo::Parameters->new;
$params->append('c', undef);
$params->append(undef, 'c');
$params->append(undef, undef);
is $params->to_string, "c=&=c&=", 'right format';
is_deeply $params->to_hash, {c => '', '' => ['c', '']}, 'right structure';
$params->remove('c');
is $params->to_string, "=c&=", 'right format';
$params->remove(undef);
ok !$params->to_string, 'empty';
$params->parse('');
ok !$params->to_string, 'empty';
is_deeply $params->to_hash, {}, 'right structure';

# Empty params
$params = Mojo::Parameters->new('c=');
is $params->to_hash->{c}, '', 'right value';
is_deeply $params->to_hash, {c => ''}, 'right structure';
$params = Mojo::Parameters->new('c=&d=');
is $params->to_hash->{c}, '', 'right value';
$params = Mojo::Parameters->new('c=&c=&d=');
is_deeply $params->to_hash->{c}, ['', ''], 'right values';
is $params->to_hash->{d}, '', 'right value';
is_deeply $params->to_hash, {c => '', d => ''}, 'right structure';
is_deeply $params->to_hash, {c => ['', ''], d => ''}, 'right structure';
$params = Mojo::Parameters->new('c=&d=0&e=');
is $params->to_hash->{c}, '', 'right value';
is $params->to_hash->{d}, 0, 'right value';
is $params->to_hash->{e}, '', 'right value';
is_deeply $params->to_hash, {c => '', d => 0, e => ''}, 'right structure';

# +
# "+"
$params = Mojo::Parameters->new('foo=%2B');
is $params->param('foo'), '+', 'right value';
is_deeply $params->to_hash, {foo => '+'}, 'right structure';
$params->param('foo ' => 'a');
is $params->to_string, "foo=%2B&foo+=a", 'right format';
is $params->to_string, 'foo=%2B&foo+=a', 'right format';
$params->remove('foo ');
is_deeply $params->to_hash, {foo => '+'}, 'right structure';
$params->append('1 2', '3+3');
Expand Down Expand Up @@ -166,17 +146,15 @@ is_deeply [$params->param('foo')], [qw(ba;r b;az)], 'right values';
# Unicode
$params = Mojo::Parameters->new;
$params->parse('input=say%20%22%C2%AB~%22;');
is $params->params->[1], 'say "«~"', 'right value';
is_deeply $params->params, ['input', 'say "«~"'], 'right structure';
is $params->param('input'), 'say "«~"', 'right value';
is "$params", 'input=say+%22%C2%AB~%22', 'right result';
$params = Mojo::Parameters->new('♥=☃');
is $params->params->[0], '♥', 'right value';
is $params->params->[1], '☃', 'right value';
is_deeply $params->params, ['♥', '☃'], 'right structure';
is $params->param('♥'), '☃', 'right value';
is "$params", '%E2%99%A5=%E2%98%83', 'right result';
$params = Mojo::Parameters->new('%E2%99%A5=%E2%98%83');
is $params->params->[0], '♥', 'right value';
is $params->params->[1], '☃', 'right value';
is_deeply $params->params, ['♥', '☃'], 'right structure';
is $params->param('♥'), '☃', 'right value';
is "$params", '%E2%99%A5=%E2%98%83', 'right result';

Expand Down
159 changes: 32 additions & 127 deletions t/mojo/path.t
View file
Expand Up @@ -7,15 +7,13 @@ use Mojo::Path;
my $path = Mojo::Path->new;
is $path->parse('/path')->to_string, '/path', 'right path';
is $path->to_dir, '/', 'right directory';
is $path->parts->[0], 'path', 'right part';
is $path->parts->[1], undef, 'no part';
is_deeply $path->parts, ['path'], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';
is $path->parse('path/')->to_string, 'path/', 'right path';
is $path->to_dir, 'path/', 'right directory';
is $path->to_dir->to_abs_string, '/path/', 'right directory';
is $path->parts->[0], 'path', 'right part';
is $path->parts->[1], undef, 'no part';
is_deeply $path->parts, ['path'], 'right structure';
ok !$path->leading_slash, 'no leading slash';
ok $path->trailing_slash, 'has trailing slash';
$path = Mojo::Path->new;
Expand All @@ -35,33 +33,24 @@ is "$path", '/AZaz09-._~!$&\'()*+,;=:@/f%2Foo', 'right path';
# Unicode
is $path->parse('/foo/♥/bar')->to_string, '/foo/%E2%99%A5/bar', 'right path';
is $path->to_dir, '/foo/%E2%99%A5/', 'right directory';
is $path->parts->[0], 'foo', 'right part';
is $path->parts->[1], '♥', 'right part';
is $path->parts->[2], 'bar', 'right part';
is $path->parts->[3], undef, 'no part';
is_deeply $path->parts, [qw(foo ♥ bar)], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';
is $path->to_route, '/foo/♥/bar', 'right route';
is $path->parse('/foo/%E2%99%A5/~b@a:r+')->to_string,
'/foo/%E2%99%A5/~b@a:r+', 'right path';
is $path->parts->[0], 'foo', 'right part';
is $path->parts->[1], '♥', 'right part';
is $path->parts->[2], '~b@a:r+', 'right part';
is $path->parts->[3], undef, 'no part';
is_deeply $path->parts, [qw(foo ♥ ~b@a:r+)], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';
is $path->to_route, '/foo/♥/~b@a:r+', 'right route';

# Zero in path
is $path->parse('/path/0')->to_string, '/path/0', 'right path';
is $path->parts->[0], 'path', 'right part';
is $path->parts->[1], '0', 'right part';
is $path->parts->[2], undef, 'no part';
is_deeply $path->parts, [qw(path 0)], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';
$path = Mojo::Path->new('0');
is $path->parts->[0], '0', 'right part';
is $path->parts->[1], undef, 'no part';
is_deeply $path->parts, [0], 'right structure';
is $path->to_string, '0', 'right path';
is $path->to_abs_string, '/0', 'right absolute path';
is $path->to_route, '/0', 'right route';
Expand All @@ -72,36 +61,13 @@ $path = Mojo::Path->new(
is "$path",
'/%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2fetc%2fpasswd',
'same path';
is $path->parts->[0], '', 'right part';
is $path->parts->[1], '..', 'right part';
is $path->parts->[2], '..', 'right part';
is $path->parts->[3], '..', 'right part';
is $path->parts->[4], '..', 'right part';
is $path->parts->[5], '..', 'right part';
is $path->parts->[6], '..', 'right part';
is $path->parts->[7], '..', 'right part';
is $path->parts->[8], '..', 'right part';
is $path->parts->[9], '..', 'right part';
is $path->parts->[10], '..', 'right part';
is $path->parts->[11], 'etc', 'right part';
is $path->parts->[12], 'passwd', 'right part';
is $path->parts->[13], undef, 'no part';
is_deeply $path->parts, ['', qw(.. .. .. .. .. .. .. .. .. .. etc passwd)],
'right structure';
is "$path", '//../../../../../../../../../../etc/passwd', 'normalized path';
is $path->canonicalize, '/../../../../../../../../../../etc/passwd',
'canonicalized path';
is $path->parts->[0], '..', 'right part';
is $path->parts->[1], '..', 'right part';
is $path->parts->[2], '..', 'right part';
is $path->parts->[3], '..', 'right part';
is $path->parts->[4], '..', 'right part';
is $path->parts->[5], '..', 'right part';
is $path->parts->[6], '..', 'right part';
is $path->parts->[7], '..', 'right part';
is $path->parts->[8], '..', 'right part';
is $path->parts->[9], '..', 'right part';
is $path->parts->[10], 'etc', 'right part';
is $path->parts->[11], 'passwd', 'right part';
is $path->parts->[12], undef, 'no part';
is_deeply $path->parts, [qw(.. .. .. .. .. .. .. .. .. .. etc passwd)],
'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';

Expand All @@ -111,53 +77,24 @@ $path = Mojo::Path->new(
is "$path",
'%2ftest%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2fetc%2fpasswd',
'same path';
is $path->parts->[0], 'test', 'right part';
is $path->parts->[1], '..', 'right part';
is $path->parts->[2], '..', 'right part';
is $path->parts->[3], '..', 'right part';
is $path->parts->[4], '..', 'right part';
is $path->parts->[5], '..', 'right part';
is $path->parts->[6], '..', 'right part';
is $path->parts->[7], '..', 'right part';
is $path->parts->[8], '..', 'right part';
is $path->parts->[9], '..', 'right part';
is $path->parts->[10], 'etc', 'right part';
is $path->parts->[11], 'passwd', 'right part';
is $path->parts->[12], undef, 'no part';
is_deeply $path->parts, [qw(test .. .. .. .. .. .. .. .. .. etc passwd)],
'right structure';
is "$path", '/test/../../../../../../../../../etc/passwd', 'normalized path';
is $path->canonicalize, '/../../../../../../../../etc/passwd',
'canonicalized path';
is $path->parts->[0], '..', 'right part';
is $path->parts->[1], '..', 'right part';
is $path->parts->[2], '..', 'right part';
is $path->parts->[3], '..', 'right part';
is $path->parts->[4], '..', 'right part';
is $path->parts->[5], '..', 'right part';
is $path->parts->[6], '..', 'right part';
is $path->parts->[7], '..', 'right part';
is $path->parts->[8], 'etc', 'right part';
is $path->parts->[9], 'passwd', 'right part';
is $path->parts->[10], undef, 'no part';
is_deeply $path->parts, [qw(.. .. .. .. .. .. .. .. etc passwd)],
'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';

# Canonicalizing (with escaped "%")
$path = Mojo::Path->new('%2ftest%2f..%252f..%2f..%2f..%2f..%2fetc%2fpasswd');
is "$path", '%2ftest%2f..%252f..%2f..%2f..%2f..%2fetc%2fpasswd', 'same path';
is $path->parts->[0], 'test', 'right part';
is $path->parts->[1], '..%2f..', 'right part';
is $path->parts->[2], '..', 'right part';
is $path->parts->[3], '..', 'right part';
is $path->parts->[4], '..', 'right part';
is $path->parts->[5], 'etc', 'right part';
is $path->parts->[6], 'passwd', 'right part';
is $path->parts->[7], undef, 'no part';
is_deeply $path->parts, [qw(test ..%2f.. .. .. .. etc passwd)],
'right structure';
is "$path", '/test/..%252f../../../../etc/passwd', 'normalized path';
is $path->canonicalize, '/../etc/passwd', 'canonicalized path';
is $path->parts->[0], '..', 'right part';
is $path->parts->[1], 'etc', 'right part';
is $path->parts->[2], 'passwd', 'right part';
is $path->parts->[3], undef, 'no part';
is_deeply $path->parts, [qw(.. etc passwd)], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';

Expand Down Expand Up @@ -228,83 +165,55 @@ is $path->to_route, '/foo/baz/yada', 'right route';
# Empty path elements
$path = Mojo::Path->new('//');
is "$path", '//', 'right path';
is $path->parts->[0], undef, 'no part';
is_deeply $path->parts, [], 'no parts';
ok $path->leading_slash, 'has leading slash';
ok $path->trailing_slash, 'has trailing slash';
is "$path", '//', 'right normalized path';
$path = Mojo::Path->new('%2F%2f');
is "$path", '%2F%2f', 'right path';
is $path->parts->[0], undef, 'no part';
is_deeply $path->parts, [], 'no parts';
ok $path->leading_slash, 'has leading slash';
ok $path->trailing_slash, 'has trailing slash';
is "$path", '//', 'right normalized path';
$path = Mojo::Path->new('/foo//bar/23/');
is "$path", '/foo//bar/23/', 'right path';
is $path->parts->[0], 'foo', 'right part';
is $path->parts->[1], '', 'right part';
is $path->parts->[2], 'bar', 'right part';
is $path->parts->[3], '23', 'right part';
is $path->parts->[4], undef, 'no part';
is_deeply $path->parts, ['foo', '', 'bar', 23], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok $path->trailing_slash, 'has trailing slash';
$path = Mojo::Path->new('//foo/bar/23/');
is "$path", '//foo/bar/23/', 'right path';
is $path->parts->[0], '', 'right part';
is $path->parts->[1], 'foo', 'right part';
is $path->parts->[2], 'bar', 'right part';
is $path->parts->[3], '23', 'right part';
is $path->parts->[4], undef, 'no part';
is_deeply $path->parts, ['', 'foo', 'bar', 23], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok $path->trailing_slash, 'has trailing slash';
$path = Mojo::Path->new('/foo///bar/23/');
is "$path", '/foo///bar/23/', 'right path';
is $path->parts->[0], 'foo', 'right part';
is $path->parts->[1], '', 'right part';
is $path->parts->[2], '', 'right part';
is $path->parts->[3], 'bar', 'right part';
is $path->parts->[4], '23', 'right part';
is $path->parts->[5], undef, 'no part';
is_deeply $path->parts, ['foo', '', '', 'bar', 23], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok $path->trailing_slash, 'has trailing slash';
$path = Mojo::Path->new('///foo/bar/23/');
is "$path", '///foo/bar/23/', 'right path';
is $path->parts->[0], '', 'right part';
is $path->parts->[1], '', 'right part';
is $path->parts->[2], 'foo', 'right part';
is $path->parts->[3], 'bar', 'right part';
is $path->parts->[4], '23', 'right part';
is $path->parts->[5], undef, 'no part';
is_deeply $path->parts, ['', '', 'foo', 'bar', 23], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok $path->trailing_slash, 'has trailing slash';
$path = Mojo::Path->new('///foo///bar/23///');
is "$path", '///foo///bar/23///', 'right path';
is $path->parts->[0], '', 'right part';
is $path->parts->[1], '', 'right part';
is $path->parts->[2], 'foo', 'right part';
is $path->parts->[3], '', 'right part';
is $path->parts->[4], '', 'right part';
is $path->parts->[5], 'bar', 'right part';
is $path->parts->[6], '23', 'right part';
is $path->parts->[7], '', 'right part';
is $path->parts->[8], '', 'right part';
is $path->parts->[9], undef, 'no part';
is_deeply $path->parts, ['', '', 'foo', '', '', 'bar', 23, '', ''],
'right structure';
ok $path->leading_slash, 'has leading slash';
ok $path->trailing_slash, 'has trailing slash';

# Escaped slash
$path = Mojo::Path->new->parts(['foo/bar']);
is $path->parts->[0], 'foo/bar', 'right part';
is $path->parts->[1], undef, 'no part';
is_deeply $path->parts, ['foo/bar'], 'right structure';
is "$path", 'foo%2Fbar', 'right path';
is $path->to_string, 'foo%2Fbar', 'right path';
is $path->to_abs_string, '/foo%2Fbar', 'right absolute path';
is $path->to_route, '/foo/bar', 'right route';

# Unchanged path
$path = Mojo::Path->new('/foob%E4r/-._~!$&\'()*+,;=:@');
is $path->clone->parts->[0], "foob\xe4r", 'right part';
is $path->clone->parts->[1], '-._~!$&\'()*+,;=:@', 'right part';
is $path->clone->parts->[2], undef, 'no part';
is_deeply $path->clone->parts, ["foob\xe4r", '-._~!$&\'()*+,;=:@'],
'right structure';
ok $path->contains("/foob\xe4r"), 'contains path';
ok $path->contains("/foob\xe4r/-._~!\$&'()*+,;=:@"), 'contains path';
ok !$path->contains("/foob\xe4r/-._~!\$&'()*+,;=:."), 'does not contain path';
Expand All @@ -319,17 +228,14 @@ is $path->clone->to_route, "/foob\xe4r/-._~!\$&'()*+,;=:@", 'right route';
# Reuse path
$path = Mojo::Path->new('/foob%E4r');
is $path->to_string, '/foob%E4r', 'right path';
is $path->parts->[0], "foob\xe4r", 'right part';
is $path->parts->[1], undef, 'no part';
is_deeply $path->parts, ["foob\xe4r"], 'right structure';
$path->parse('/foob%E4r');
is $path->to_string, '/foob%E4r', 'right path';
is $path->parts->[0], "foob\xe4r", 'right part';
is $path->parts->[1], undef, 'no part';
is_deeply $path->parts, ["foob\xe4r"], 'right structure';

# Latin-1
$path = Mojo::Path->new->charset('Latin-1')->parse('/foob%E4r');
is $path->parts->[0], 'foobär', 'right part';
is $path->parts->[1], undef, 'no part';
is_deeply $path->parts, ['foobär'], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';
is "$path", '/foob%E4r', 'right path';
Expand All @@ -340,8 +246,7 @@ is $path->clone->to_string, '/foob%E4r', 'right path';

# No charset
$path = Mojo::Path->new->charset(undef)->parse('/%E4');
is $path->parts->[0], "\xe4", 'right part';
is $path->parts->[1], undef, 'no part';
is_deeply $path->parts, ["\xe4"], 'right structure';
ok $path->leading_slash, 'has leading slash';
ok !$path->trailing_slash, 'no trailing slash';
is "$path", '/%E4', 'right path';
Expand Down

0 comments on commit 93f9536

Please sign in to comment.