t/020_attributes/012_misc_attribute_tests.t

   1 #!/usr/bin/perl
   2
   3 use strict;
   4 use warnings;
   5
   6 use Test::More tests => 40;
   7 use Test::Exception;
   8
   9 BEGIN {
  10     use_ok('Moose');
  11 }
  12
  13 {
  14     {
  15         package Test::Attribute::Inline::Documentation;
  16         use Moose;
  17
  18         has 'foo' => (
  19             documentation => q{
  20                 The 'foo' attribute is my favorite
  21                 attribute in the whole wide world.
  22             }
  23         );
  24     }
  25
  26     my $foo_attr = Test::Attribute::Inline::Documentation->meta->get_attribute('foo');
  27
  28     ok($foo_attr->has_documentation, '... the foo has docs');
  29     is($foo_attr->documentation,
  30             q{
  31                 The 'foo' attribute is my favorite
  32                 attribute in the whole wide world.
  33             },
  34     '... got the foo docs');
  35 }
  36
  37 {
  38     {
  39         package Test::For::Lazy::TypeConstraint;
  40         use Moose;
  41         use Moose::Util::TypeConstraints;
  42
  43         has 'bad_lazy_attr' => (
  44             is => 'rw',
  45             isa => 'ArrayRef',
  46             lazy => 1,
  47             default => sub { "test" },
  48         );
  49
  50         has 'good_lazy_attr' => (
  51             is => 'rw',
  52             isa => 'ArrayRef',
  53             lazy => 1,
  54             default => sub { [] },
  55         );
  56
  57     }
  58
  59     my $test = Test::For::Lazy::TypeConstraint->new;
  60     isa_ok($test, 'Test::For::Lazy::TypeConstraint');
  61
  62     dies_ok {
  63         $test->bad_lazy_attr;
  64     } '... this does not work';
  65
  66     lives_ok {
  67         $test->good_lazy_attr;
  68     } '... this does not work';
  69 }
  70
  71 {
  72     {
  73         package Test::Arrayref::Attributes;
  74         use Moose;
  75
  76         has [qw(foo bar baz)] => (
  77             is => 'rw',
  78         );
  79
  80     }
  81
  82     my $test = Test::Arrayref::Attributes->new;
  83     isa_ok($test, 'Test::Arrayref::Attributes');
  84     can_ok($test, qw(foo bar baz));
  85
  86 }
  87
  88 {
  89     {
  90         package Test::UndefDefault::Attributes;
  91         use Moose;
  92
  93         has 'foo' => (
  94             is      => 'ro',
  95             isa     => 'Str',
  96             default => sub { return }
  97         );
  98
  99     }
 100
 101     dies_ok {
 102         Test::UndefDefault::Attributes->new;
 103     } '... default must return a value which passes the type constraint';
 104
 105 }
 106
 107 {
 108     {
 109         package OverloadedStr;
 110         use Moose;
 111         use overload '""' => sub { 'this is *not* a string' };
 112
 113         has 'a_str' => ( isa => 'Str' , is => 'rw' );
 114     }
 115
 116     my $moose_obj = OverloadedStr->new;
 117
 118     is($moose_obj->a_str( 'foobar' ), 'foobar', 'setter took string');
 119     ok($moose_obj, 'this is a *not* a string');
 120
 121     throws_ok {
 122         $moose_obj->a_str( $moose_obj )
 123     } qr/Attribute \(a_str\) does not pass the type constraint \(Str\) with OverloadedStr\=HASH\(.*?\)/, '... dies without overloading the string';
 124
 125 }
 126
 127 {
 128     {
 129         package OverloadBreaker;
 130         use Moose;
 131
 132         has 'a_num' => ( isa => 'Int' , is => 'rw', default => 7.5 );
 133     }
 134
 135     throws_ok {
 136         OverloadBreaker->new;
 137     } qr/Attribute \(a_num\) does not pass the type constraint \(Int\) with \'7\.5\'/, '... this doesnt trip overload to break anymore ';
 138
 139     lives_ok {
 140         OverloadBreaker->new(a_num => 5);
 141     } '... this works fine though';
 142
 143 }
 144
 145 {
 146     {
 147       package Test::Builder::Attribute;
 148         use Moose;
 149
 150         has 'foo'  => ( required => 1, builder => 'build_foo', is => 'ro');
 151         sub build_foo { return "works" };
 152     }
 153
 154     my $meta = Test::Builder::Attribute->meta;
 155     my $foo_attr  = $meta->get_attribute("foo");
 156
 157     ok($foo_attr->is_required, "foo is required");
 158     ok($foo_attr->has_builder, "foo has builder");
 159     is($foo_attr->builder, "build_foo",  ".. and it's named build_foo");
 160
 161     my $instance = Test::Builder::Attribute->new;
 162     is($instance->foo, 'works', "foo builder works");
 163 }
 164
 165
 166
 167 {
 168     {
 169       package Test::LazyBuild::Attribute;
 170         use Moose;
 171
 172         has 'foo'  => ( lazy_build => 1, is => 'ro');
 173         has '_foo' => ( lazy_build => 1, is => 'ro');
 174         sub build_foo { return "works" };
 175         sub _build_foo { return "works too" };
 176     }
 177
 178     my $meta = Test::LazyBuild::Attribute->meta;
 179     my $foo_attr  = $meta->get_attribute("foo");
 180     my $_foo_attr = $meta->get_attribute("_foo");
 181
 182     ok($foo_attr->is_lazy, "foo is lazy");
 183     ok($foo_attr->is_required, "foo is required");
 184     ok($foo_attr->is_lazy_build, "foo is lazy_build");
 185
 186     ok($foo_attr->has_clearer, "foo has clearer");
 187     is($foo_attr->clearer, "clear_foo",  ".. and it's named clear_foo");
 188
 189     ok($foo_attr->has_builder, "foo has builder");
 190     is($foo_attr->builder, "build_foo",  ".. and it's named build_foo");
 191
 192     ok($foo_attr->has_predicate, "foo has predicate");
 193     is($foo_attr->predicate, "has_foo",  ".. and it's named has_foo");
 194
 195     ok($_foo_attr->is_lazy, "_foo is lazy");
 196     ok($_foo_attr->is_required, "_foo is required");
 197     ok($_foo_attr->is_lazy_build, "_foo is lazy_build");
 198
 199     ok($_foo_attr->has_clearer, "_foo has clearer");
 200     is($_foo_attr->clearer, "_clear_foo",  ".. and it's named _clear_foo");
 201
 202     ok($_foo_attr->has_builder, "_foo has builder");
 203     is($_foo_attr->builder, "_build_foo",  ".. and it's named _build_foo");
 204
 205     ok($_foo_attr->has_predicate, "_foo has predicate");
 206     is($_foo_attr->predicate, "_has_foo",  ".. and it's named _has_foo");
 207
 208     my $instance = Test::LazyBuild::Attribute->new;
 209     ok(!$instance->has_foo, "noo foo value yet");
 210     ok(!$instance->_has_foo, "noo _foo value yet");
 211     is($instance->foo, 'works', "foo builder works");
 212     is($instance->_foo, 'works too', "foo builder works too");
 213
 214 }
 215