projects / gitmo/MooseX-Types-Common.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw (parent: 265ef5d)
remove needless use of moose attributes when testing
Karen Etheridge [Sat, 14 Sep 2013 21:15:40 +0000 (14:15 -0700)]
t/01-string.t patch | blob | blame | history
t/02-numeric.t patch | blob | blame | history
t/04-coerce.t patch | blob | blame | history

diff --git a/t/01-string.t b/t/01-string.t
index bbf5c83..63f2298 100644 (file)
--- a/t/01-string.t
+++ b/t/01-string.t
@@ -1,80 +1,62 @@
 use strict;
 use warnings FATAL => 'all';
 use Test::More tests => 33;
-use Test::Fatal;
 
-{
-  package FooTest;
-  use Moose;
-  use MooseX::Types::Common::String (
-    qw(SimpleStr
-       NonEmptySimpleStr
-       LowerCaseSimpleStr
-       UpperCaseSimpleStr
-       Password
-       StrongPassword
-       NonEmptyStr
-       LowerCaseStr
-       UpperCaseStr
-       NumericCode
-       ),
-  );
-
-  has simplestr => ( is => 'rw', isa => SimpleStr );
-  has nestr => ( is => 'rw', isa => NonEmptyStr );
-  has nesimplestr => ( is => 'rw', isa => NonEmptySimpleStr );
-  has lcsimplestr => ( is => 'rw', isa => LowerCaseSimpleStr );
-  has ucsimplestr => ( is => 'rw', isa => UpperCaseSimpleStr );
-  has password => ( is => 'rw', isa => Password );
-  has strongpassword => ( is => 'rw', isa => StrongPassword );
-  has lowercasestr => ( is => 'rw', isa => LowerCaseStr );
-  has uppercasestr => ( is => 'rw', isa => UpperCaseStr );
-  has numericcode => ( is => 'rw', isa => NumericCode );
-}
-
-my $ins = FooTest->new;
+use MooseX::Types::Common::String qw(
+    SimpleStr
+    NonEmptySimpleStr
+    LowerCaseSimpleStr
+    UpperCaseSimpleStr
+    Password
+    StrongPassword
+    NonEmptyStr
+    LowerCaseStr
+    UpperCaseStr
+    NumericCode
+);
 
 # TODO: need to check both the inlined and non-inlined versions!
 
-is(exception { $ins->simplestr('') }, undef, 'SimpleStr');
-is(exception { $ins->simplestr('good string') }, undef, 'SimpleStr 2');
-isnt(exception { $ins->simplestr("bad\nstring") }, 'SimpleStr 3');
-isnt(exception { $ins->simplestr(join('', ("long string" x 25))) }, undef, 'SimpleStr 4');
+ok(is_SimpleStr(''), 'SimpleStr');
+ok(is_SimpleStr('a string'), 'SimpleStr 2');
+ok(!is_SimpleStr("another\nstring"), 'SimpleStr 3');
+ok(!is_SimpleStr(join('', ("long string" x 25))), 'SimpleStr 4');
+
+ok(!is_NonEmptyStr(''), 'NonEmptyStr');
+ok(is_NonEmptyStr('a string'), 'NonEmptyStr 2');
+ok(is_NonEmptyStr("another string"), 'NonEmptyStr 3');
+ok(is_NonEmptyStr(join('', ("long string" x 25))), 'NonEmptyStr 4');
 
-isnt(exception { $ins->nestr('') }, undef, 'NonEmptyStr');
-is(exception { $ins->nestr('good string') }, undef, 'NonEmptyStr 2');
-is(exception { $ins->nestr("bad\nstring") }, undef, 'NonEmptyStr 3');
-is(exception { $ins->nestr(join('', ("long string" x 25))) }, undef, 'NonEmptyStr 4');
+ok(is_NonEmptySimpleStr('good str'), 'NonEmptySimplrStr');
+ok(!is_NonEmptySimpleStr(''), 'NonEmptyStr 2');
 
-is(exception { $ins->nesimplestr('good str') }, undef, 'NonEmptySimplrStr');
-isnt(exception { $ins->nesimplestr('') }, undef, 'NonEmptyStr 2');
+ok(!is_Password('no'), 'Password');
+ok(is_Password('okay'), 'Password 2');
 
-isnt(exception { $ins->password('no') }, undef, 'Password');
-is(exception { $ins->password('okay') }, undef, 'Password 2');
+ok(!is_StrongPassword('notokay'), 'StrongPassword');
+ok(is_StrongPassword('83773r_ch01c3'), 'StrongPassword 2');
 
-isnt(exception { $ins->strongpassword('notokay') }, undef, 'StrongPassword');
-is(exception { $ins->strongpassword('83773r_ch01c3') }, undef, 'StrongPassword 2');
+ok(!is_LowerCaseSimpleStr('NOTOK'), 'LowerCaseSimpleStr');
+ok(is_LowerCaseSimpleStr('ok'), 'LowerCaseSimpleStr 2');
+ok(!is_LowerCaseSimpleStr('NOTOK_123`"'), 'LowerCaseSimpleStr 3');
+ok(is_LowerCaseSimpleStr('ok_123`"'), 'LowerCaseSimpleStr 4');
 
-isnt(exception { $ins->lcsimplestr('NOTOK') }, undef, 'LowerCaseSimpleStr');
-is(exception { $ins->lcsimplestr('ok') }, undef, 'LowerCaseSimpleStr 2');
-isnt(exception { $ins->lcsimplestr('NOTOK_123`"') }, undef, 'LowerCaseSimpleStr 3');
-is(exception { $ins->lcsimplestr('ok_123`"') }, undef, 'LowerCaseSimpleStr 4');
+ok(!is_UpperCaseSimpleStr('notok'), 'UpperCaseSimpleStr');
+ok(is_UpperCaseSimpleStr('OK'), 'UpperCaseSimpleStr 2');
+ok(!is_UpperCaseSimpleStr('notok_123`"'), 'UpperCaseSimpleStr 3');
+ok(is_UpperCaseSimpleStr('OK_123`"'), 'UpperCaseSimpleStr 4');
 
-isnt(exception { $ins->ucsimplestr('notok') }, undef, 'UpperCaseSimpleStr');
-is(exception { $ins->ucsimplestr('OK') }, undef, 'UpperCaseSimpleStr 2');
-isnt(exception { $ins->ucsimplestr('notok_123`"') }, undef, 'UpperCaseSimpleStr 3');
-is(exception { $ins->ucsimplestr('OK_123`"') }, undef, 'UpperCaseSimpleStr 4');
+ok(!is_LowerCaseStr('NOTOK'), 'LowerCaseStr');
+ok(is_LowerCaseStr("ok\nok"), 'LowerCaseStr 2');
+ok(!is_LowerCaseStr('NOTOK_123`"'), 'LowerCaseStr 3');
+ok(is_LowerCaseStr("ok\n_123`'"), 'LowerCaseStr 4');
 
-isnt(exception { $ins->lowercasestr('NOTOK') }, undef, 'LowerCaseStr');
-is(exception { $ins->lowercasestr("ok\nok") }, undef, 'LowerCaseStr 2');
-isnt(exception { $ins->lowercasestr('NOTOK_123`"') }, undef, 'LowerCaseStr 3');
-is(exception { $ins->lowercasestr("ok\n_123`'") }, undef, 'LowerCaseStr 4');
+ok(!is_UpperCaseStr('notok'), 'UpperCaseStr');
+ok(is_UpperCaseStr("OK\nOK"), 'UpperCaseStr 2');
+ok(!is_UpperCaseStr('notok_123`"'), 'UpperCaseStr 3');
+ok(is_UpperCaseStr("OK\n_123`'"), 'UpperCaseStr 4');
 
-isnt(exception { $ins->uppercasestr('notok') }, undef, 'UpperCaseStr');
-is(exception { $ins->uppercasestr("OK\nOK") }, undef, 'UpperCaseStr 2');
-isnt(exception { $ins->uppercasestr('notok_123`"') }, undef, 'UpperCaseStr 3');
-is(exception { $ins->uppercasestr("OK\n_123`'") }, undef, 'UpperCaseStr 4');
+ok(is_NumericCode('032'),  'NumericCode lives');
+ok(!is_NumericCode('abc'),  'NumericCode dies' );
+ok(!is_NumericCode('x18'),  'mixed NumericCode dies');
 
-is(   exception { $ins->numericcode('032') }, undef,  'NumericCode lives');
-isnt( exception { $ins->numericcode('abc') }, undef,  'NumericCode dies' );
-isnt( exception { $ins->numericcode('x18') }, undef,  'mixed NumericCode dies');
diff --git a/t/02-numeric.t b/t/02-numeric.t
index e794948..6e12e96 100644 (file)
--- a/t/02-numeric.t
+++ b/t/02-numeric.t
@@ -3,65 +3,49 @@ use warnings FATAL => 'all';
 use Test::More tests => 34;
 use Test::Fatal;
 
-{
-  package FooTest;
-  use Moose;
-  use MooseX::Types::Common::Numeric (
-    qw(PositiveNum PositiveOrZeroNum
-       PositiveInt PositiveOrZeroInt
-       NegativeNum NegativeOrZeroNum
-       NegativeInt NegativeOrZeroInt
-       SingleDigit)
-  );
-
-  has digit => ( is => 'rw', isa => SingleDigit);
-  has posnum => ( is => 'rw', isa => PositiveNum);
-  has posint => ( is => 'rw', isa => PositiveInt);
-  has negnum => ( is => 'rw', isa => NegativeNum);
-  has negint => ( is => 'rw', isa => NegativeInt);
-  has posorzeronum => ( is => 'rw', isa => PositiveOrZeroNum);
-  has posorzeroint => ( is => 'rw', isa => PositiveOrZeroInt);
-  has negorzeronum => ( is => 'rw', isa => NegativeOrZeroNum);
-  has negorzeroint => ( is => 'rw', isa => NegativeOrZeroInt);
-}
-
-my $ins = FooTest->new;
-
-isnt(exception { $ins->digit(100); }, undef, 'SingleDigit');
-is(exception { $ins->digit(1); }, undef, 'SingleDigit 2');
-
-isnt(exception { $ins->posint(-100); }, undef, 'PositiveInt (-100)');
-isnt(exception { $ins->posint(0); }, undef, 'PositiveInt (0)');
-isnt(exception { $ins->posint(100.885); }, undef, 'PositiveInt (100.885)');
-is(exception { $ins->posint(100); }, undef, 'PositiveInt (100)');
-isnt(exception { $ins->posnum(0); }, undef, 'PositiveNum (0)');
-is(exception { $ins->posnum(100.885); }, undef, 'PositiveNum (100.885)');
-isnt(exception { $ins->posnum(-100.885); }, undef, 'PositiveNum (-100.885)');
-is(exception { $ins->posnum(0.0000000001); }, undef, 'PositiveNum (0.0000000001)');
-
-isnt(exception { $ins->posorzeroint(-100); }, undef, 'PositiveOrZeroInt (-100)');
-is(exception { $ins->posorzeroint(0); }, undef, 'PositiveOrZeroInt (0)');
-isnt(exception { $ins->posorzeroint(100.885); }, undef, 'PositiveOrZeroInt (100.885)');
-is(exception { $ins->posorzeroint(100); }, undef, 'PositiveOrZeroInt (100)');
-is(exception { $ins->posorzeronum(0); }, undef, 'PositiveOrZeroNum (0)');
-is(exception { $ins->posorzeronum(100.885); }, undef, 'PositiveOrZeroNum (100.885)');
-isnt(exception { $ins->posorzeronum(-100.885); }, undef, 'PositiveOrZeroNum (-100.885)');
-is(exception { $ins->posorzeronum(0.0000000001); }, undef, 'PositiveOrZeroNum (0.0000000001)');
-
-isnt(exception { $ins->negint(100); }, undef, 'NegativeInt (100)');
-isnt(exception { $ins->negint(-100.885); }, undef, 'NegativeInt (-100.885)');
-is(exception { $ins->negint(-100); }, undef, 'NegativeInt (-100)');
-isnt(exception { $ins->negint(0); }, undef, 'NegativeInt (0)');
-is(exception { $ins->negnum(-100.885); }, undef, 'NegativeNum (-100.885)');
-isnt(exception { $ins->negnum(100.885); }, undef, 'NegativeNum (100.885)');
-isnt(exception { $ins->negnum(0); }, undef, 'NegativeNum (0)');
-is(exception { $ins->negnum(-0.0000000001); }, undef, 'NegativeNum (-0.0000000001)');
-
-isnt(exception { $ins->negorzeroint(100); }, undef, 'NegativeOrZeroInt (100)');
-isnt(exception { $ins->negorzeroint(-100.885); }, undef, 'NegativeOrZeroInt (-100.885)');
-is(exception { $ins->negorzeroint(-100); }, undef, 'NegativeOrZeroInt (-100)');
-is(exception { $ins->negorzeroint(0); }, undef, 'NegativeOrZeroInt (0)');
-is(exception { $ins->negorzeronum(-100.885); }, undef, 'NegativeOrZeroNum (-100.885)');
-isnt(exception { $ins->negorzeronum(100.885); }, undef, 'NegativeOrZeroNum (100.885)');
-is(exception { $ins->negorzeronum(0); }, undef, 'NegativeOrZeroNum (0)');
-is(exception { $ins->negorzeronum(-0.0000000001); }, undef, 'NegativeOrZeroNum (-0.0000000001)');
+use MooseX::Types::Common::Numeric qw(
+    PositiveNum PositiveOrZeroNum
+    PositiveInt PositiveOrZeroInt
+    NegativeNum NegativeOrZeroNum
+    NegativeInt NegativeOrZeroInt
+    SingleDigit
+);
+
+ok(!is_SingleDigit(100), 'SingleDigit');
+ok(is_SingleDigit(1), 'SingleDigit 2');
+
+ok(!is_PositiveInt(-100), 'PositiveInt (-100)');
+ok(!is_PositiveInt(0), 'PositiveInt (0)');
+ok(!is_PositiveInt(100.885), 'PositiveInt (100.885)');
+ok(is_PositiveInt(100), 'PositiveInt (100)');
+ok(!is_PositiveNum(0), 'PositiveNum (0)');
+ok(is_PositiveNum(100.885), 'PositiveNum (100.885)');
+ok(!is_PositiveNum(-100.885), 'PositiveNum (-100.885)');
+ok(is_PositiveNum(0.0000000001), 'PositiveNum (0.0000000001)');
+
+ok(!is_PositiveOrZeroInt(-100), 'PositiveOrZeroInt (-100)');
+ok(is_PositiveOrZeroInt(0), 'PositiveOrZeroInt (0)');
+ok(!is_PositiveOrZeroInt(100.885), 'PositiveOrZeroInt (100.885)');
+ok(is_PositiveOrZeroInt(100), 'PositiveOrZeroInt (100)');
+ok(is_PositiveOrZeroNum(0), 'PositiveOrZeroNum (0)');
+ok(is_PositiveOrZeroNum(100.885), 'PositiveOrZeroNum (100.885)');
+ok(!is_PositiveOrZeroNum(-100.885), 'PositiveOrZeroNum (-100.885)');
+ok(is_PositiveOrZeroNum(0.0000000001), 'PositiveOrZeroNum (0.0000000001)');
+
+ok(!is_NegativeInt(100), 'NegativeInt (100)');
+ok(!is_NegativeInt(-100.885), 'NegativeInt (-100.885)');
+ok(is_NegativeInt(-100), 'NegativeInt (-100)');
+ok(!is_NegativeInt(0), 'NegativeInt (0)');
+ok(is_NegativeNum(-100.885), 'NegativeNum (-100.885)');
+ok(!is_NegativeNum(100.885), 'NegativeNum (100.885)');
+ok(!is_NegativeNum(0), 'NegativeNum (0)');
+ok(is_NegativeNum(-0.0000000001), 'NegativeNum (-0.0000000001)');
+
+ok(!is_NegativeOrZeroInt(100), 'NegativeOrZeroInt (100)');
+ok(!is_NegativeOrZeroInt(-100.885), 'NegativeOrZeroInt (-100.885)');
+ok(is_NegativeOrZeroInt(-100), 'NegativeOrZeroInt (-100)');
+ok(is_NegativeOrZeroInt(0), 'NegativeOrZeroInt (0)');
+ok(is_NegativeOrZeroNum(-100.885), 'NegativeOrZeroNum (-100.885)');
+ok(!is_NegativeOrZeroNum(100.885), 'NegativeOrZeroNum (100.885)');
+ok(is_NegativeOrZeroNum(0), 'NegativeOrZeroNum (0)');
+ok(is_NegativeOrZeroNum(-0.0000000001), 'NegativeOrZeroNum (-0.0000000001)');
diff --git a/t/04-coerce.t b/t/04-coerce.t
index 3c46c41..8560e6d 100644 (file)
--- a/t/04-coerce.t
+++ b/t/04-coerce.t
@@ -2,36 +2,18 @@ use strict;
 use warnings FATAL => 'all';
 use Test::More tests => 5;
 
-{
-  package FooTest;
-  use Moose;
-  use MooseX::Types::Common::String ( qw(
+use MooseX::Types::Common::String qw(
     LowerCaseSimpleStr
     UpperCaseSimpleStr
     LowerCaseStr
     UpperCaseStr
-       NumericCode
-  ) );
+    NumericCode
+);
 
-  has uppercasesimplestr => ( is => 'rw', isa => UpperCaseSimpleStr, coerce => 1 );
-  has lowercasesimplestr => ( is => 'rw', isa => LowerCaseSimpleStr, coerce => 1 );
-  has uppercasestr => ( is => 'rw', isa => UpperCaseStr, coerce => 1 );
-  has lowercasestr => ( is => 'rw', isa => LowerCaseStr, coerce => 1 );
-  has numericcode  => ( is => 'rw', isa => NumericCode,  coerce => 1 );
-}
+is(to_UpperCaseSimpleStr('foo'), 'FOO', 'uppercase str' );
+is(to_LowerCaseSimpleStr('BAR'), 'bar', 'lowercase str' );
 
-my $ins = FooTest->new({
-  uppercasesimplestr => 'foo',
-  lowercasesimplestr => 'BAR',
-  uppercasestr => 'foo',
-  lowercasestr => 'BAR',
-  numericcode  => '4111-1111-1111-1111',
-});
+is(to_UpperCaseStr('foo'), 'FOO', 'uppercase str' );
+is(to_LowerCaseStr('BAR'), 'bar', 'lowercase str' );
 
-is( $ins->uppercasesimplestr, 'FOO', 'uppercase str' );
-is( $ins->lowercasesimplestr, 'bar', 'lowercase str' );
-
-is( $ins->uppercasestr, 'FOO', 'uppercase str' );
-is( $ins->lowercasestr, 'bar', 'lowercase str' );
-
-is( $ins->numericcode, '4111111111111111', 'numeric code' );
+is(to_NumericCode('4111-1111-1111-1111'), '4111111111111111', 'numeric code' );
A library of commonly used type constraints - now lives at https://github.com/moose/MooseX-Types-Common