NAME

       Mock::Quick - Quickly mock objects and classes, even temporarily replace them, side-effect
       free.

DESCRIPTION

       Mock-Quick is here to solve the current problems with Mocking libraries.

       There are a couple Mocking libraries available on CPAN. The primary problems with these
       libraries include verbose syntax, and most importantly side-effects.  Some Mocking
       libraries expect you to mock a specific class, and will unload it then redefine it. This
       is particularly a problem if you only want to override a class on a lexical level.

       Mock-Object provides a declarative mocking interface that results in a very concise, but
       clear syntax. There are separate facilities for mocking object instances, and classes. You
       can quickly create an instance of an object with custom attributes and methods. You can
       also quickly create an anonymous class, optionally inheriting from another, with whatever
       methods you desire.

       Mock-Object also provides a tool that provides an OO interface to overriding methods in
       existing classes. This tool also allows for the restoration of the original class methods.
       Best of all this is a localized tool, when your control object falls out of scope the
       original class is restored.

SYNOPSIS

   MOCKING OBJECTS
           use Mock::Quick;

           my $obj = qobj(
               foo => 'bar',            # define attribute
               do_it => qmeth { ... },  # define method
               ...
           );

           is( $obj->foo, 'bar' );
           $obj->foo( 'baz' );
           is( $obj->foo, 'baz' );

           $obj->do_it();

           # define the new attribute automatically
           $obj->bar( 'xxx' );

           # define a new method on the fly
           $obj->baz( qmeth { ... });

           # remove an attribute or method
           $obj->baz( qclear() );

   STRICTER MOCK
           use Mock::Quick;

           my $obj = qstrict(
               foo => 'bar',            # define attribute
               do_it => qmeth { ... },  # define method
               ...
           );

           is( $obj->foo, 'bar' );
           $obj->foo( 'baz' );
           is( $obj->foo, 'baz' );

           $obj->do_it();

           # remove an attribute or method
           $obj->baz( qclear() );

       You can no longer auto-vivify accessors and methods in strict mode:

           # Cannot define the new attribute automatically
           dies_ok { $obj->bar( 'xxx' ) };

           # Cannot define a new method on the fly
           dies_ok { $obj->baz( qmeth { ... }) };

       In order to add methods/accessors you need to create a control object.

   CONTROL OBJECTS
       Control objects are objects that let you interface a mocked object. They let you add
       attributes and methods, or even clear them. This is unnecessary unless you use strict
       mocking, or choose not to import qmeth() and qclear().

       Take Control
               my $control = qcontrol( $obj );

       Add Attributes
               $control->set_attributes(
                   foo => 'bar',
                   ...
               );

       Add Methods
               $control->set_methods(
                   do_it => sub { ... }, # No need to use qmeth()
                   ...
               );

       Clear Attributes/Methods
               $control->clear( qw/foo do_it .../ );

       Toggle strict
               $control->strict( $BOOL );

       Create With Control
               my $obj = qobj ...;
               my $obj = qstrict ...;
               my ( $obj,  $control  ) = qobjc ...;
               my ( $sobj, $scontrol ) = qstrictc ...;

   MOCKING CLASSES
       Note: the control object returned here is of type Mock::Quick::Class, whereas control
       objects for qobj style objects are of Mock::Quick::Object::Control.

       IMPLEMENT A CLASS

       This will implement a class at the namespace provided via the -implement argument. The
       class must not already be loaded. Once complete the real class will be prevented from
       loading until you call undefine() on the control object.

           use Mock::Quick;

           my $control = qclass(
               -implement => 'My::Package',

               # Insert a generic new() method (blessed hash)
               -with_new => 1,

               # Inheritance
               -subclass => 'Some::Class',
               # Can also do
               -subclass => [ 'Class::A', 'Class::B' ],

               # generic get/set attribute methods.
               -attributes => [ qw/a b c d/ ],

               # Method that simply returns a value.
               simple => 'value',

               # Custom method.
               method => sub { ... },
           );

           my $obj = $control->package->new;
           # OR
           my $obj = My::Package->new;

           # Override a method
           $control->override( foo => sub { ... });

           # Restore it to the original
           $control->restore( 'foo' );

           # Remove the namespace we created, which would allow the real thing to load
           # in a require or use statement.
           $control->undefine();

       You can also use the qimplement() method instead of qclass:

           use Mock::Quick;

           my $control = qimplement 'Some::Package' => ( %args );

       ANONYMOUS MOCKED CLASS

       This is if you just need to generate a class where the package name does not matter. This
       is done when the -takeover and -implement arguments are both omitted.

           use Mock::Quick;

           my $control = qclass(
               # Insert a generic new() method (blessed hash)
               -with_new => 1,

               # Inheritance
               -subclass => 'Some::Class',
               # Can also do
               -subclass => [ 'Class::A', 'Class::B' ],

               # generic get/set attribute methods.
               -attributes => [ qw/a b c d/ ],

               # Method that simply returns a value.
               simple => 'value',

               # Custom method.
               method => sub { ... },
           );

           my $obj = $control->package->new;

           # Override a method
           $control->override( foo => sub { ... });

           # Restore it to the original
           $control->restore( 'foo' );

           # Remove the anonymous namespace we created.
           $control->undefine();

       TAKING OVER EXISTING/LOADED CLASSES

           use Mock::Quick;

           my $control = qtakeover 'Some::Package' => ( %overrides );

           # Override a method
           $control->override( foo => sub { ... });

           # Restore it to the original
           $control->restore( 'foo' );

           # Destroy the control object and completely restore the original class
           # Some::Package.
           $control = undef;

       You can also do this through qclass():

           use Mock::Quick;

           my $control = qclass(
               -takeover => 'Some::Package',
               %overrides
           );

METRICS

       All control objects have a 'metrics' method. The metrics method returns a hash where keys
       are method names, and values are the number of times the method has been called. When a
       method is altered or removed the key is deleted.

       Metrics only apply to mocked methods. When you takeover an already loaded class metrics
       will only track overridden methods.

EXPORTS

       Mock-Quick uses Exporter::Declare. This allows for exports to be prefixed or renamed.  See
       "RENAMING IMPORTED ITEMS" in Exporter::Declare for more information.

       $obj = qobj( attribute => value, ... )
       ( $obj, $control ) = qobjc( attribute => value, ... )
           Create an object. Every possible attribute works fine as a get/set accessor.  You can
           define other methods using qmeth {...} and assigning that to an attribute. You can
           clear a method using qclear() as an argument.

           See Mock::Quick::Object for more.

       $obj = qstrict( attribute => value, ... )
       ( $obj, $control ) = qstrictc( attribute => value, ... )
           Create a stricter object, get/set accessors will not autovivify into existence for
           undefined attributes.

       $control = qclass( -config => ..., name => $value || sub { ... }, ... )
           Define an anonymous package with the desired methods and specifications.

           See Mock::Quick::Class for more.

       $control = qclass( -takeover => $package, %overrides )
       $control = qtakeover( $package, %overrides );
           Take over an existing class.

           See Mock::Quick::Class for more.

       $control = qimplement( $package, -config => ..., name => $value || sub { ... }, ... )
       $control = qclass( -implement => $package, ... )
           Implement the given package to specifications, altering %INC so that the real class
           will not load. Destroying the control object will once again allow the original to
           load.

       qclear()
           Returns a special reference that when used as an argument, will cause
           Mock::Quick::Object methods to be cleared.

       qmeth { my $self = shift; ... }
           Define a method for an Mock::Quick::Object instance.

           default_export qcontrol   => sub { Mock::Quick::Object::Control->new( @_ ) };

AUTHORS

       Chad Granum exodist7@gmail.com

       Ben Hengst notbenh@cpan.org

CONTRIBUTORS

       Contributors are listed as authors in modules they have touched.

       Ben Hengst notbenh@cpan.org
       Glen Hinkle glen@empireenterprises.com

COPYRIGHT

       Copyright (C) 2011 Chad Granum

       Mock-Quick is free software; Standard perl licence.

       Mock-Quick is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
       without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
       See the license for more details.