projects / gitmo/MooseX-Params-Validate.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw
Fix bad prereqs and make sure we explicitly ask for module versions we need
[gitmo/MooseX-Params-Validate.git] / t / 001_basic.t
diff --git a/t/001_basic.t b/t/001_basic.t
index 4bede46..b5787ca 100644 (file)
--- a/t/001_basic.t
+++ b/t/001_basic.t
@@ -3,8 +3,8 @@
 use strict;
 use warnings;
 
-use Test::More tests => 35;
-use Test::Exception;
+use Test::More 0.88;
+use Test::Fatal;
 
 {
     package Roles::Blah;
@@ -45,7 +45,7 @@ use Test::Exception;
         my %params = validated_hash(
             \@_,
             foo => {
-                isa => subtype( 'Object' => where { $_->isa('Foo') } ),
+                isa      => subtype( 'Object' => where { $_->isa('Foo') } ),
                 optional => 1
             },
             bar => { does => 'Roles::Blah', optional => 1 },
@@ -64,7 +64,8 @@ use Test::Exception;
             foo => {
                 isa       => 'ArrayRef',
                 callbacks => {
-                    'some random callback' => sub { @{ $_[0] } <= 2 },
+                    'some random callback' =>
+                        sub { !ref( $_[0] ) || @{ $_[0] } <= 2 },
                 },
             },
         );
@@ -77,46 +78,77 @@ my $foo = Foo->new;
 isa_ok( $foo, 'Foo' );
 
 is( $foo->foo, 'Horray for Moose!', '... got the right return value' );
-is( $foo->foo( bar => 'Rolsky' ), 'Horray for Rolsky!',
-    '... got the right return value' );
+is(
+    $foo->foo( bar => 'Rolsky' ), 'Horray for Rolsky!',
+    '... got the right return value'
+);
 
 is( $foo->baz( foo => $foo ), $foo, '... foo param must be a Foo instance' );
 
-throws_ok { $foo->baz( foo => 10 ) } qr/\QThe 'foo' parameter ("10")/,
-    '... the foo param in &baz must be a Foo instance';
-throws_ok { $foo->baz( foo => "foo" ) } qr/\QThe 'foo' parameter ("foo")/,
-    '... the foo param in &baz must be a Foo instance';
-throws_ok { $foo->baz( foo => [] ) } qr/\QThe 'foo' parameter/,
-    '... the foo param in &baz must be a Foo instance';
+like(
+    exception { $foo->baz( foo => 10 ) }, qr/\QThe 'foo' parameter ("10")/,
+    '... the foo param in &baz must be a Foo instance'
+);
+like(
+    exception { $foo->baz( foo => "foo" ) },
+    qr/\QThe 'foo' parameter ("foo")/,
+    '... the foo param in &baz must be a Foo instance'
+);
+like(
+    exception { $foo->baz( foo => [] ) }, qr/\QThe 'foo' parameter/,
+    '... the foo param in &baz must be a Foo instance'
+);
 
 is( $foo->baz( bar => $foo ), $foo, '... bar param must do Roles::Blah' );
 
-throws_ok { $foo->baz( bar => 10 ) } qr/\QThe 'bar' parameter ("10")/,
-'... the bar param in &baz must be do Roles::Blah';
-throws_ok { $foo->baz( bar => "foo" ) } qr/\QThe 'bar' parameter ("foo")/,
-'... the bar param in &baz must be do Roles::Blah';
-throws_ok { $foo->baz( bar => [] ) } qr/\QThe 'bar' parameter/,
-'... the bar param in &baz must be do Roles::Blah';
+like(
+    exception { $foo->baz( bar => 10 ) }, qr/\QThe 'bar' parameter ("10")/,
+    '... the bar param in &baz must be do Roles::Blah'
+);
+like(
+    exception { $foo->baz( bar => "foo" ) },
+    qr/\QThe 'bar' parameter ("foo")/,
+    '... the bar param in &baz must be do Roles::Blah'
+);
+like(
+    exception { $foo->baz( bar => [] ) }, qr/\QThe 'bar' parameter/,
+    '... the bar param in &baz must be do Roles::Blah'
+);
 
 is( $foo->baz( boo => $foo ), $foo, '... boo param must do Roles::Blah' );
 
-throws_ok { $foo->baz( boo => 10 ) } qr/\QThe 'boo' parameter ("10")/,
-'... the boo param in &baz must be do Roles::Blah';
-throws_ok { $foo->baz( boo => "foo" ) } qr/\QThe 'boo' parameter ("foo")/,
-'... the boo param in &baz must be do Roles::Blah';
-throws_ok { $foo->baz( boo => [] ) } qr/\QThe 'boo' parameter/,
-'... the boo param in &baz must be do Roles::Blah';
-
-throws_ok { $foo->bar } qr/\QMandatory parameter 'foo'/,
-    '... bar has a required param';
-throws_ok { $foo->bar( foo => 10 ) } qr/\QThe 'foo' parameter ("10")/,
-    '... the foo param in &bar must be a Foo instance';
-throws_ok { $foo->bar( foo => "foo" ) } qr/\QThe 'foo' parameter ("foo")/,
-    '... the foo param in &bar must be a Foo instance';
-throws_ok { $foo->bar( foo => [] ) } qr/\QThe 'foo' parameter/,
-    '... the foo param in &bar must be a Foo instance';
-throws_ok { $foo->bar( baz => [] ) } qr/\QMandatory parameter 'foo'/,,
-    '... bar has a required foo param';
+like(
+    exception { $foo->baz( boo => 10 ) }, qr/\QThe 'boo' parameter ("10")/,
+    '... the boo param in &baz must be do Roles::Blah'
+);
+like(
+    exception { $foo->baz( boo => "foo" ) },
+    qr/\QThe 'boo' parameter ("foo")/,
+    '... the boo param in &baz must be do Roles::Blah'
+);
+like(
+    exception { $foo->baz( boo => [] ) }, qr/\QThe 'boo' parameter/,
+    '... the boo param in &baz must be do Roles::Blah'
+);
+
+like(
+    exception { $foo->bar }, qr/\QMandatory parameter 'foo'/,
+    '... bar has a required param'
+);
+like(
+    exception { $foo->bar( foo => 10 ) }, qr/\QThe 'foo' parameter ("10")/,
+    '... the foo param in &bar must be a Foo instance'
+);
+like(
+    exception { $foo->bar( foo => "foo" ) },
+    qr/\QThe 'foo' parameter ("foo")/,
+    '... the foo param in &bar must be a Foo instance'
+);
+like(
+    exception { $foo->bar( foo => [] ) }, qr/\QThe 'foo' parameter/,
+    '... the foo param in &bar must be a Foo instance'
+);
+like( exception { $foo->bar( baz => [] ) }, qr/\QMandatory parameter 'foo'/ );
 
 is_deeply(
     $foo->bar( foo => $foo ),
@@ -136,18 +168,25 @@ is_deeply(
     '... the foo param and baz param in &bar got a correct args'
 );
 
-throws_ok { $foo->bar( foo => $foo, baz => undef ) }
-qr/\QThe 'baz' parameter (undef)/,
-    '... baz requires a ArrayRef | HashRef';
-throws_ok { $foo->bar( foo => $foo, baz => 10 ) }
-qr/\QThe 'baz' parameter ("10")/,
-    '... baz requires a ArrayRef | HashRef';
-throws_ok { $foo->bar( foo => $foo, baz => 'Foo' ) }
-qr/\QThe 'baz' parameter ("Foo")/,
-    '... baz requires a ArrayRef | HashRef';
-throws_ok { $foo->bar( foo => $foo, baz => \( my $var ) ) }
-qr/\QThe 'baz' parameter/,
-    '... baz requires a ArrayRef | HashRef';
+like(
+    exception { $foo->bar( foo => $foo, baz => undef ) },
+    qr/\QThe 'baz' parameter (undef)/,
+    '... baz requires a ArrayRef | HashRef'
+);
+like(
+    exception { $foo->bar( foo => $foo, baz => 10 ) },
+    qr/\QThe 'baz' parameter ("10")/,
+    '... baz requires a ArrayRef | HashRef'
+);
+like(
+    exception { $foo->bar( foo => $foo, baz => 'Foo' ) },
+    qr/\QThe 'baz' parameter ("Foo")/,
+    '... baz requires a ArrayRef | HashRef'
+);
+like(
+    exception { $foo->bar( foo => $foo, baz => \( my $var ) ) },
+    qr/\QThe 'baz' parameter/, '... baz requires a ArrayRef | HashRef'
+);
 
 is_deeply(
     $foo->bar( foo => $foo, gorch => [ 1, 2, 3 ] ),
@@ -155,26 +194,40 @@ is_deeply(
     '... the foo param in &bar got a Foo instance'
 );
 
-throws_ok { $foo->bar( foo => $foo, gorch => undef ) }
-qr/\QThe 'gorch' parameter (undef)/,
-    '... gorch requires a ArrayRef[Int]';
-throws_ok { $foo->bar( foo => $foo, gorch => 10 ) }
-qr/\QThe 'gorch' parameter ("10")/,
-    '... gorch requires a ArrayRef[Int]';
-throws_ok { $foo->bar( foo => $foo, gorch => 'Foo' ) }
-qr/\QThe 'gorch' parameter ("Foo")/,
-    '... gorch requires a ArrayRef[Int]';
-throws_ok { $foo->bar( foo => $foo, gorch => \( my $var ) ) }
-qr/\QThe 'gorch' parameter/,
-    '... gorch requires a ArrayRef[Int]';
-throws_ok { $foo->bar( foo => $foo, gorch => [qw/one two three/] ) }
-qr/\QThe 'gorch' parameter/,
-    '... gorch requires a ArrayRef[Int]';
-
-throws_ok { $foo->quux( foo => '123456790' ) }
-qr/\QThe 'foo' parameter\E.+\Qchecking type constraint/,
-'... foo parameter must be an ArrayRef';
-
-throws_ok { $foo->quux( foo => [ 1, 2, 3, 4 ] ) }
-qr/\QThe 'foo' parameter\E.+\Qsome random callback/,
-'... foo parameter additional callback requires that arrayref be 0-2 elements';
+like(
+    exception { $foo->bar( foo => $foo, gorch => undef ) },
+    qr/\QThe 'gorch' parameter (undef)/,
+    '... gorch requires a ArrayRef[Int]'
+);
+like(
+    exception { $foo->bar( foo => $foo, gorch => 10 ) },
+    qr/\QThe 'gorch' parameter ("10")/,
+    '... gorch requires a ArrayRef[Int]'
+);
+like(
+    exception { $foo->bar( foo => $foo, gorch => 'Foo' ) },
+    qr/\QThe 'gorch' parameter ("Foo")/,
+    '... gorch requires a ArrayRef[Int]'
+);
+like(
+    exception { $foo->bar( foo => $foo, gorch => \( my $var ) ) },
+    qr/\QThe 'gorch' parameter/, '... gorch requires a ArrayRef[Int]'
+);
+like(
+    exception { $foo->bar( foo => $foo, gorch => [qw/one two three/] ) },
+    qr/\QThe 'gorch' parameter/, '... gorch requires a ArrayRef[Int]'
+);
+
+like(
+    exception { $foo->quux( foo => '123456790' ) },
+    qr/\QThe 'foo' parameter\E.+\Qchecking type constraint/,
+    '... foo parameter must be an ArrayRef'
+);
+
+like(
+    exception { $foo->quux( foo => [ 1, 2, 3, 4 ] ) },
+    qr/\QThe 'foo' parameter\E.+\Qsome random callback/,
+    '... foo parameter additional callback requires that arrayref be 0-2 elements'
+);
+
+done_testing();
an extension of Params::Validate using Moose's types - now lives at https://github.com/moose/MooseX-Params-Validate