6 use Test::More tests => 84;
15 sub hello { 'Hello World (from Thing)' }
16 sub goodbye { 'Goodbye World (from Thing)' }
20 use Moose::Util::TypeConstraints;
28 => via { 'FooArrayRef' };
30 has 'bar' => (is => 'ro', isa => 'Str', default => 'Foo::bar');
31 has 'baz' => (is => 'rw', isa => 'Ref');
32 has 'foo' => (is => 'rw', isa => 'FooStr');
34 has 'gorch' => (is => 'ro');
35 has 'gloum' => (is => 'ro', default => sub {[]});
36 has 'fleem' => (is => 'ro');
38 has 'bling' => (is => 'ro', isa => 'Thing');
39 has 'blang' => (is => 'ro', isa => 'Thing', handles => ['goodbye']);
41 has 'bunch_of_stuff' => (is => 'rw', isa => 'ArrayRef');
43 has 'one_last_one' => (is => 'rw', isa => 'Ref');
45 # this one will work here ....
46 has 'fail' => (isa => 'CodeRef', is => 'bare');
47 has 'other_fail' => (is => 'bare');
51 use Moose::Util::TypeConstraints;
56 has '+bar' => (default => 'Bar::bar');
57 } 'we can change the default attribute option';
60 has '+baz' => (isa => 'ArrayRef');
61 } 'we can add change the isa as long as it is a subtype';
64 has '+foo' => (coerce => 1);
65 } 'we can change/add coerce as an attribute option';
68 has '+gorch' => (required => 1);
69 } 'we can change/add required as an attribute option';
72 has '+gloum' => (lazy => 1);
73 } 'we can change/add lazy as an attribute option';
76 has '+gloum' => (lazy_build => 1);
77 } 'we can add lazy_build as an attribute option';
80 has '+bunch_of_stuff' => (isa => 'ArrayRef[Int]');
81 } 'extend an attribute with parameterized type';
84 has '+one_last_one' => (isa => subtype('Ref', where { blessed $_ eq 'CODE' }));
85 } 'extend an attribute with anon-subtype';
88 has '+one_last_one' => (isa => 'Value');
89 } 'now can extend an attribute with a non-subtype';
92 has '+fleem' => (weak_ref => 1);
93 } 'now allowed to add the weak_ref option via inheritance';
96 has '+bling' => (handles => ['hello']);
97 } 'we can add the handles attribute option';
99 # this one will *not* work here ....
101 has '+blang' => (handles => ['hello']);
102 } 'we can not alter the handles attribute option';
104 has '+fail' => (isa => 'Ref');
105 } 'can now create an attribute with an improper subtype relation';
107 has '+other_fail' => (trigger => sub {});
108 } 'cannot create an attribute with an illegal option';
110 has '+does_not_exist' => (isa => 'Str');
111 } qr/in Bar/, 'cannot extend a non-existing attribute';
117 is($foo->foo, undef, 'got the right undef default value');
118 lives_ok { $foo->foo('FooString') } 'assigned foo correctly';
119 is($foo->foo, 'FooString', 'got the right value for foo');
121 dies_ok { $foo->foo([]) } 'foo is not coercing (as expected)';
123 is($foo->bar, 'Foo::bar', 'got the right default value');
124 dies_ok { $foo->bar(10) } 'Foo::bar is a read/only attr';
126 is($foo->baz, undef, 'got the right undef default value');
130 lives_ok { $foo->baz($hash_ref) } 'Foo::baz accepts hash refs';
131 is($foo->baz, $hash_ref, 'got the right value assigned to baz');
134 lives_ok { $foo->baz($array_ref) } 'Foo::baz accepts an array ref';
135 is($foo->baz, $array_ref, 'got the right value assigned to baz');
137 my $scalar_ref = \(my $var);
138 lives_ok { $foo->baz($scalar_ref) } 'Foo::baz accepts scalar ref';
139 is($foo->baz, $scalar_ref, 'got the right value assigned to baz');
141 lives_ok { $foo->bunch_of_stuff([qw[one two three]]) } 'Foo::bunch_of_stuff accepts an array of strings';
143 lives_ok { $foo->one_last_one(sub { 'Hello World'}) } 'Foo::one_last_one accepts a code ref';
145 my $code_ref = sub { 1 };
146 lives_ok { $foo->baz($code_ref) } 'Foo::baz accepts a code ref';
147 is($foo->baz, $code_ref, 'got the right value assigned to baz');
152 } 'cannot create Bar without required gorch param';
154 my $bar = Bar->new(gorch => 'Bar::gorch');
158 is($bar->foo, undef, 'got the right undef default value');
159 lives_ok { $bar->foo('FooString') } 'assigned foo correctly';
160 is($bar->foo, 'FooString', 'got the right value for foo');
161 lives_ok { $bar->foo([]) } 'assigned foo correctly';
162 is($bar->foo, 'FooArrayRef', 'got the right value for foo');
164 is($bar->gorch, 'Bar::gorch', 'got the right default value');
166 is($bar->bar, 'Bar::bar', 'got the right default value');
167 dies_ok { $bar->bar(10) } 'Bar::bar is a read/only attr';
169 is($bar->baz, undef, 'got the right undef default value');
173 dies_ok { $bar->baz($hash_ref) } 'Bar::baz does not accept hash refs';
176 lives_ok { $bar->baz($array_ref) } 'Bar::baz can accept an array ref';
177 is($bar->baz, $array_ref, 'got the right value assigned to baz');
179 my $scalar_ref = \(my $var);
180 dies_ok { $bar->baz($scalar_ref) } 'Bar::baz does not accept a scalar ref';
182 lives_ok { $bar->bunch_of_stuff([1, 2, 3]) } 'Bar::bunch_of_stuff accepts an array of ints';
183 dies_ok { $bar->bunch_of_stuff([qw[one two three]]) } 'Bar::bunch_of_stuff does not accept an array of strings';
185 my $code_ref = sub { 1 };
186 dies_ok { $bar->baz($code_ref) } 'Bar::baz does not accept a code ref';
189 # check some meta-stuff
191 ok(Bar->meta->has_attribute('foo'), 'Bar has a foo attr');
192 ok(Bar->meta->has_attribute('bar'), 'Bar has a bar attr');
193 ok(Bar->meta->has_attribute('baz'), 'Bar has a baz attr');
194 ok(Bar->meta->has_attribute('gorch'), 'Bar has a gorch attr');
195 ok(Bar->meta->has_attribute('gloum'), 'Bar has a gloum attr');
196 ok(Bar->meta->has_attribute('bling'), 'Bar has a bling attr');
197 ok(Bar->meta->has_attribute('bunch_of_stuff'), 'Bar does have a bunch_of_stuff attr');
198 ok(!Bar->meta->has_attribute('blang'), 'Bar has a blang attr');
199 ok(Bar->meta->has_attribute('fail'), 'Bar has a fail attr');
200 ok(!Bar->meta->has_attribute('other_fail'), 'Bar does not have an other_fail attr');
202 isnt(Foo->meta->get_attribute('foo'),
203 Bar->meta->get_attribute('foo'),
204 'Foo and Bar have different copies of foo');
205 isnt(Foo->meta->get_attribute('bar'),
206 Bar->meta->get_attribute('bar'),
207 'Foo and Bar have different copies of bar');
208 isnt(Foo->meta->get_attribute('baz'),
209 Bar->meta->get_attribute('baz'),
210 'Foo and Bar have different copies of baz');
211 isnt(Foo->meta->get_attribute('gorch'),
212 Bar->meta->get_attribute('gorch'),
213 'Foo and Bar have different copies of gorch');
214 isnt(Foo->meta->get_attribute('gloum'),
215 Bar->meta->get_attribute('gloum'),
216 'Foo and Bar have different copies of gloum');
217 isnt(Foo->meta->get_attribute('bling'),
218 Bar->meta->get_attribute('bling'),
219 'Foo and Bar have different copies of bling');
220 isnt(Foo->meta->get_attribute('bunch_of_stuff'),
221 Bar->meta->get_attribute('bunch_of_stuff'),
222 'Foo and Bar have different copies of bunch_of_stuff');
224 ok(Bar->meta->get_attribute('bar')->has_type_constraint,
225 'Bar::bar inherited the type constraint too');
226 ok(Bar->meta->get_attribute('baz')->has_type_constraint,
227 'Bar::baz inherited the type constraint too');
229 is(Bar->meta->get_attribute('bar')->type_constraint->name,
230 'Str', 'Bar::bar inherited the right type constraint too');
232 is(Foo->meta->get_attribute('baz')->type_constraint->name,
233 'Ref', 'Foo::baz inherited the right type constraint too');
234 is(Bar->meta->get_attribute('baz')->type_constraint->name,
235 'ArrayRef', 'Bar::baz inherited the right type constraint too');
237 ok(!Foo->meta->get_attribute('gorch')->is_required,
238 'Foo::gorch is not a required attr');
239 ok(Bar->meta->get_attribute('gorch')->is_required,
240 'Bar::gorch is a required attr');
242 is(Foo->meta->get_attribute('bunch_of_stuff')->type_constraint->name,
244 'Foo::bunch_of_stuff is an ArrayRef');
245 is(Bar->meta->get_attribute('bunch_of_stuff')->type_constraint->name,
247 'Bar::bunch_of_stuff is an ArrayRef[Int]');
249 ok(!Foo->meta->get_attribute('gloum')->is_lazy,
250 'Foo::gloum is not a required attr');
251 ok(Bar->meta->get_attribute('gloum')->is_lazy,
252 'Bar::gloum is a required attr');
254 ok(!Foo->meta->get_attribute('foo')->should_coerce,
255 'Foo::foo should not coerce');
256 ok(Bar->meta->get_attribute('foo')->should_coerce,
257 'Bar::foo should coerce');
259 ok(!Foo->meta->get_attribute('bling')->has_handles,
260 'Foo::foo should not handles');
261 ok(Bar->meta->get_attribute('bling')->has_handles,
262 'Bar::foo should handles');