1Mock::Quick(3) User Contributed Perl Documentation Mock::Quick(3)
2
6 Mock::Quick - Quickly mock objects and classes, even temporarily
7 replace them, side-effect free.
8
10 Mock-Quick is here to solve the current problems with Mocking
11 libraries.
12 There are a couple Mocking libraries available on CPAN. The primary
14 problems with these libraries include verbose syntax, and most
15 importantly side-effects. Some Mocking libraries expect you to mock a
16 specific class, and will unload it then redefine it. This is
17 particularly a problem if you only want to override a class on a
18 lexical level.
19 Mock-Quick provides a declarative mocking interface that results in a
21 very concise, but clear syntax. There are separate facilities for
22 mocking object instances, and classes. You can quickly create an
23 instance of an object with custom attributes and methods. You can also
24 quickly create an anonymous class, optionally inheriting from another,
25 with whatever methods you desire.
26 Mock-Quick also provides a tool that provides an OO interface to
28 overriding methods in existing classes. This tool also allows for the
29 restoration of the original class methods. Best of all this is a
30 localized tool, when your control object falls out of scope the
31 original class is restored.
32
34 MOCKING OBJECTS
35 use Mock::Quick;
36 my $obj = qobj(
38 foo => 'bar', # define attribute
39 do_it => qmeth { ... }, # define method
40 ...
41 );
42 is( $obj->foo, 'bar' );
44 $obj->foo( 'baz' );
45 is( $obj->foo, 'baz' );
46 $obj->do_it();
48 # define the new attribute automatically
50 $obj->bar( 'xxx' );
51 # define a new method on the fly
53 $obj->baz( qmeth { ... });
54 # remove an attribute or method
56 $obj->baz( qclear() );
57 STRICTER MOCK
59 use Mock::Quick;
60 my $obj = qstrict(
62 foo => 'bar', # define attribute
63 do_it => qmeth { ... }, # define method
64 ...
65 );
66 is( $obj->foo, 'bar' );
68 $obj->foo( 'baz' );
69 is( $obj->foo, 'baz' );
70 $obj->do_it();
72 # remove an attribute or method
74 $obj->baz( qclear() );
75 You can no longer auto-vivify accessors and methods in strict mode:
77 # Cannot define the new attribute automatically
79 dies_ok { $obj->bar( 'xxx' ) };
80 # Cannot define a new method on the fly
82 dies_ok { $obj->baz( qmeth { ... }) };
83 In order to add methods/accessors you need to create a control object.
85 CONTROL OBJECTS
87 Control objects are objects that let you interface a mocked object.
88 They let you add attributes and methods, or even clear them. This is
89 unnecessary unless you use strict mocking, or choose not to import
90 qmeth() and qclear().
91 Take Control
93 my $control = qcontrol( $obj );
94 Add Attributes
96 $control->set_attributes(
97 foo => 'bar',
98 ...
99 );
100 Add Methods
102 $control->set_methods(
103 do_it => sub { ... }, # No need to use qmeth()
104 ...
105 );
106 Clear Attributes/Methods
108 $control->clear( qw/foo do_it .../ );
109 Toggle strict
111 $control->strict( $BOOL );
112 Create With Control
114 my $obj = qobj ...;
115 my $obj = qstrict ...;
116 my ( $obj, $control ) = qobjc ...;
117 my ( $sobj, $scontrol ) = qstrictc ...;
118 MOCKING CLASSES
120 Note: the control object returned here is of type Mock::Quick::Class,
121 whereas control objects for qobj style objects are of
122 Mock::Quick::Object::Control.
123 IMPLEMENT A CLASS
125 This will implement a class at the namespace provided via the
127 -implement argument. The class must not already be loaded. Once
128 complete the real class will be prevented from loading until you call
129 undefine() on the control object.
130 use Mock::Quick;
132 my $control = qclass(
134 -implement => 'My::Package',
135 # Insert a generic new() method (blessed hash)
137 -with_new => 1,
138 # Inheritance
140 -subclass => 'Some::Class',
141 # Can also do
142 -subclass => [ 'Class::A', 'Class::B' ],
143 # generic get/set attribute methods.
145 -attributes => [ qw/a b c d/ ],
146 # Method that simply returns a value.
148 simple => 'value',
149 # Custom method.
151 method => sub { ... },
152 );
153 my $obj = $control->package->new;
155 # OR
156 my $obj = My::Package->new;
157 # Override a method
159 $control->override( foo => sub { ... });
160 # Restore it to the original
162 $control->restore( 'foo' );
163 # Remove the namespace we created, which would allow the real thing to load
165 # in a require or use statement.
166 $control->undefine();
167 You can also use the qimplement() method instead of qclass:
169 use Mock::Quick;
171 my $control = qimplement 'Some::Package' => ( %args );
173 ANONYMOUS MOCKED CLASS
175 This is if you just need to generate a class where the package name
177 does not matter. This is done when the -takeover and -implement
178 arguments are both omitted.
179 use Mock::Quick;
181 my $control = qclass(
183 # Insert a generic new() method (blessed hash)
184 -with_new => 1,
185 # Inheritance
187 -subclass => 'Some::Class',
188 # Can also do
189 -subclass => [ 'Class::A', 'Class::B' ],
190 # generic get/set attribute methods.
192 -attributes => [ qw/a b c d/ ],
193 # Method that simply returns a value.
195 simple => 'value',
196 # Custom method.
198 method => sub { ... },
199 );
200 my $obj = $control->package->new;
202 # Override a method
204 $control->override( foo => sub { ... });
205 # Restore it to the original
207 $control->restore( 'foo' );
208 # Remove the anonymous namespace we created.
210 $control->undefine();
211 TAKING OVER EXISTING/LOADED CLASSES
213 use Mock::Quick;
215 my $control = qtakeover 'Some::Package' => ( %overrides );
217 # Override a method
219 $control->override( foo => sub { ... });
220 # Restore it to the original
222 $control->restore( 'foo' );
223 # Destroy the control object and completely restore the original class
225 # Some::Package.
226 $control = undef;
227 You can also do this through qclass():
229 use Mock::Quick;
231 my $control = qclass(
233 -takeover => 'Some::Package',
234 %overrides
235 );
236
238 All control objects have a 'metrics' method. The metrics method returns
239 a hash where keys are method names, and values are the number of times
240 the method has been called. When a method is altered or removed the key
241 is deleted.
242 Metrics only apply to mocked methods. When you takeover an already
244 loaded class metrics will only track overridden methods.
245
247 Mock-Quick uses Exporter::Declare. This allows for exports to be
248 prefixed or renamed. See "RENAMING IMPORTED ITEMS" in
249 Exporter::Declare for more information.
250 $obj = qobj( attribute => value, ... )
252 ( $obj, $control ) = qobjc( attribute => value, ... )
253 Create an object. Every possible attribute works fine as a get/set
254 accessor. You can define other methods using qmeth {...} and
255 assigning that to an attribute. You can clear a method using
256 qclear() as an argument.
257 See Mock::Quick::Object for more.
259 $obj = qstrict( attribute => value, ... )
261 ( $obj, $control ) = qstrictc( attribute => value, ... )
262 Create a stricter object, get/set accessors will not autovivify
263 into existence for undefined attributes.
264 $control = qclass( -config => ..., name => $value || sub { ... }, ... )
266 Define an anonymous package with the desired methods and
267 specifications.
268 See Mock::Quick::Class for more.
270 $control = qclass( -takeover => $package, %overrides )
272 $control = qtakeover( $package, %overrides );
273 Take over an existing class.
274 See Mock::Quick::Class for more.
276 $control = qimplement( $package, -config => ..., name => $value || sub
278 { ... }, ... )
279 $control = qclass( -implement => $package, ... )
280 Implement the given package to specifications, altering %INC so
281 that the real class will not load. Destroying the control object
282 will once again allow the original to load.
283 qclear()
285 Returns a special reference that when used as an argument, will
286 cause Mock::Quick::Object methods to be cleared.
287 qmeth { my $self = shift; ... }
289 Define a method for an Mock::Quick::Object instance.
290 default_export qcontrol => sub {
292 Mock::Quick::Object::Control->new( @_ ) };
293
295 Chad Granum exodist7@gmail.com
296 Ben Hengst notbenh@cpan.org
298
300 Contributors are listed as authors in modules they have touched.
301 Ben Hengst notbenh@cpan.org
303 Glen Hinkle glen@empireenterprises.com
304
306 Copyright (C) 2011 Chad Granum
307 Mock-Quick is free software; Standard perl licence.
309 Mock-Quick is distributed in the hope that it will be useful, but
311 WITHOUT ANY WARRANTY; without even the implied warranty of
312 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the license
313 for more details.
314perl v5.36.0 2023-01-20 Mock::Quick(3)