package MooX::Types::MooseLike::Test;
use strict;
use warnings FATAL => 'all';
use Moo;
use MooX::Types::MooseLike::Base qw(:all);
has 'a_bool' => (
is => 'ro',
isa => Bool,
);
has 'an_undef' => (
is => 'ro',
isa => Undef,
);
has 'a_defined' => (
is => 'ro',
isa => Defined,
);
has 'a_value' => (
is => 'ro',
isa => Value,
);
has 'a_string' => (
is => 'ro',
isa => Str,
);
has 'a_number' => (
is => 'ro',
isa => Num,
);
has 'an_integer' => (
is => 'ro',
isa => Int,
);
has 'a_ref' => (
is => 'ro',
isa => Ref,
);
has 'an_array' => (
is => 'ro',
isa => ArrayRef,
);
has 'a_hash' => (
is => 'ro',
isa => HashRef,
);
has 'a_code' => (
is => 'ro',
isa => CodeRef,
);
has 'a_regex' => (
is => 'ro',
isa => RegexpRef,
);
has 'a_glob' => (
is => 'ro',
isa => GlobRef,
);
has 'a_filehandle' => (
is => 'ro',
isa => FileHandle,
);
has 'an_object' => (
is => 'ro',
isa => Object,
);
has 'legal_age' => (
is => 'ro',
isa => sub {
die "$_[0] is not of legal age"
unless (is_Int($_[0]) && $_[0] > 17);
},
);
package main;
use strict;
use warnings FATAL => 'all';
use Test::More;
use Test::Fatal;
use IO::Handle;
use MooX::Types::MooseLike::Base qw(:all);
ok(is_Str('x'), 'is_Str');
ok(!is_Str([]), 'is_Str fails on ArrayRef');
ok(is_Num(3.142), 'is_Num');
ok(is_Num('9'), 'is_Num');
ok(!is_Num('xxx'), 'is_Num fails on a non-numeric string');
ok(is_Int(-3), 'is_Int');
ok(!is_Int(3.142), 'is_Int fails on a Float');
ok(is_Bool('0'), '0 is_Bool');
ok(is_Bool(''), 'empty string is_Bool');
ok(is_Bool(), 'undef is_Bool');
ok(is_Bool(1), '1 is_Bool');
ok(!is_Bool(-1), 'is_Bool fails on -1');
ok(is_ArrayRef([]), 'is_ArrayRef');
ok(!is_ArrayRef('1'), 'is_ArrayRef fails on 1');
ok(is_HashRef({}), 'is_HashRef');
ok(!is_HashRef([]), 'is_HashRef fails on []');
ok(is_CodeRef(sub { }), 'is_CodeRef');
ok(!is_CodeRef({}), 'is_CodeRef fails on {}');
ok(is_Object(IO::Handle->new), 'Object');
ok(!is_Object({}), 'is_Object fails on HashRef');
# Test Bool
ok(MooX::Types::MooseLike::Test->new(a_bool => undef), 'undef is a Bool');
ok(MooX::Types::MooseLike::Test->new(a_bool => 0), '0 is a Bool');
my $false_boolean_value = 0.001;
like(
exception {
MooX::Types::MooseLike::Test->new(a_bool => $false_boolean_value);
},
qr/$false_boolean_value is not a Boolean/,
'a non-boolean is an exception when we want a Bool'
);
# Undef
ok(MooX::Types::MooseLike::Test->new(an_undef => undef), 'Undef');
like(
exception { MooX::Types::MooseLike::Test->new(an_undef => '') },
qr/is not undef/,
'empty string is an exception when we want an Undef type'
);
# Defined
ok(MooX::Types::MooseLike::Test->new(a_defined => ''), 'Defined');
like(
exception { MooX::Types::MooseLike::Test->new(a_defined => undef) },
qr/is not defined/,
'undef is an exception when we want a Defined type'
);
# Test Value
ok(MooX::Types::MooseLike::Test->new(a_value => ''), 'empty string Value');
ok(MooX::Types::MooseLike::Test->new(a_value => 0), 'zero Value');
ok(MooX::Types::MooseLike::Test->new(a_value => 'yarn'), 'word Value');
like(
exception { MooX::Types::MooseLike::Test->new(a_value => undef) },
qr/undef is not a value/,
'undef is an exception when we want a Value'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_value => []) },
qr/ARRAY.*?is not a value/,
'an ArrayRef is an exception when we want a Value'
);
# Test Str
ok(MooX::Types::MooseLike::Test->new(a_string => ''), 'Empty string');
ok(MooX::Types::MooseLike::Test->new(a_string => '0'), 'Zero as a string');
ok(MooX::Types::MooseLike::Test->new(a_string => 'barn'), 'Word string');
like(
exception { MooX::Types::MooseLike::Test->new(a_string => undef) },
qr/undef is not a string/,
'undef is an exception when we want a Str'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_string => []) },
qr/ARRAY.*?is not a string/,
'an ArrayRef is an exception when we want a Str'
);
# Test Num
ok(MooX::Types::MooseLike::Test->new(a_number => 0), 'Num zero');
ok(MooX::Types::MooseLike::Test->new(a_number => 3.14), 'Num');
like(
exception { MooX::Types::MooseLike::Test->new(a_number => undef) },
qr/undef is not a number/,
'undef is an exception when we want a number'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_number => '') },
qr/The empty string is not a number/,
'The empty string is an exception when we want a number'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_number => '5x5') },
qr/is not a number/,
'a non number is an exception when we want a number'
);
# Test Int
ok(MooX::Types::MooseLike::Test->new(an_integer => -1), 'Int');
like(
exception { MooX::Types::MooseLike::Test->new(an_integer => undef) },
qr/undef is not an integer/,
'undef is an exception when we want an Integer'
);
like(
exception { MooX::Types::MooseLike::Test->new(an_integer => '') },
qr/The empty string is not an integer/,
'The empty string is an exception when we want an Integer'
);
like(
exception { MooX::Types::MooseLike::Test->new(an_integer => 1.01) },
qr/is not an integer/,
'a non-integer is an exception when we want an Integer'
);
# Test Ref
ok(MooX::Types::MooseLike::Test->new(a_ref => []), 'Ref: ArrayRef');
like(
exception { MooX::Types::MooseLike::Test->new(a_ref => undef) },
qr/is not a reference/,
'undef is an exception when we want a reference'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_ref => '') },
qr/is not a reference/,
'The empty string is an exception when we want a reference'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_ref => 0) },
qr/is not a reference/,
'zero is an exception when we want an reference'
);
# Test ArrayRef
ok(MooX::Types::MooseLike::Test->new(an_array => []), 'ArrayRef');
like(
exception { MooX::Types::MooseLike::Test->new(an_array => undef) },
qr/is not an ArrayRef/,
'undef is an exception when we want an ArrayRef'
);
like(
exception { MooX::Types::MooseLike::Test->new(an_array => '') },
qr/is not an ArrayRef/,
'The empty string is an exception when we want an ArrayRef'
);
like(
exception { MooX::Types::MooseLike::Test->new(an_array => 0) },
qr/is not an ArrayRef/,
'zero is an exception when we want an ArrayRef'
);
like(
exception { MooX::Types::MooseLike::Test->new(an_array => {}) },
qr/HASH.*?is not an ArrayRef/,
'a HashRef is an exception when we want an ArrayRef'
);
like(
exception { MooX::Types::MooseLike::Test->new(an_array => 'string') },
qr/string is not an ArrayRef/,
'a String is an exception when we want an ArrayRef'
);
# Test HashRef
ok(MooX::Types::MooseLike::Test->new(a_hash => {}), 'HashRef');
like(
exception { MooX::Types::MooseLike::Test->new(a_hash => undef) },
qr/is not a HashRef/,
'undef is an exception when we want a HashRef'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_hash => '') },
qr/is not a HashRef/,
'The empty string is an exception when we want a HashRef'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_hash => []) },
qr/ARRAY.*?is not a HashRef/,
'an ArrayRef is an exception when we want a HashRef'
);
like(
exception { MooX::Types::MooseLike::Test->new(a_hash => 'string') },
qr/string is not a HashRef/,
'a String is an exception when we want a HashRef'
);
# Test CodeRef
ok(MooX::Types::MooseLike::Test->new(a_code => sub { }), 'CodeRef');
like(
exception { MooX::Types::MooseLike::Test->new(a_code => []) },
qr/ARRAY.*?is not a CodeRef/,
'an ArrayRef is an exception when we want a CodeRef'
);
# Test RegexpRef
ok(MooX::Types::MooseLike::Test->new(a_regex => qr{}), 'RegexpRef');
like(
exception { MooX::Types::MooseLike::Test->new(a_regex => []) },
qr/ARRAY.*?is not a RegexpRef/,
'an ArrayRef is an exception when we want a RegexpRef'
);
# Test GlobRef
# avoid warning for using FOO only once
no warnings 'once';
ok(MooX::Types::MooseLike::Test->new(a_glob => \*FOO), 'GlobRef');
like(
exception { MooX::Types::MooseLike::Test->new(a_glob => []) },
qr/ARRAY.*?is not a GlobRef/,
'an ArrayRef is an exception when we want a GlobRef'
);
# Test FileHandle
ok(MooX::Types::MooseLike::Test->new(a_filehandle => IO::Handle->new),
'FileHandle');
like(
exception { MooX::Types::MooseLike::Test->new(a_filehandle => []) },
qr/ARRAY.*?is not a FileHandle/,
'an ArrayRef is an exception when we want a FileHandle'
);
# Test Object
ok(MooX::Types::MooseLike::Test->new(an_object => IO::Handle->new), 'Object');
like(
exception { MooX::Types::MooseLike::Test->new(an_object => []) },
qr/ARRAY.*?is not an Object/,
'an ArrayRef is an exception when we want an Object'
);
# Test legal_age attribute which has an 'isa' that uses 'is_Int'
ok(MooX::Types::MooseLike::Test->new(legal_age => 18), 'Legal Age');
my $minor_age = 17;
like(
exception { MooX::Types::MooseLike::Test->new(legal_age => $minor_age) },
qr/$minor_age is not of legal age/,
'an integer less than 18 is an exception when we want a legal age'
);
like(
exception { MooX::Types::MooseLike::Test->new(an_undef => '') },
qr/is not undef.*\n.*MooX::Types::MooseLike::Test::new.*basic\.t/s,
'The error looks like a useful stacktrace'
);
done_testing;