Update: Mock::Sub. I haven't documented well the difference between OO and imported functions, so see EXAMPLES for the caveat for now. /Update

I've been writing a lot of unit tests in Python lately, and really took to liking the MagicMock module. This morning, I thought I'd take a crack to see if I could emulate much of its functionality, before I write a full-blown module for it. So far, it implements called(), call_count(), side_effect and return_value:

The Module itself (./Test/MockSub.pm):

package Test::MockSub;

sub mock {
    my $self = bless {}, shift;
    my $sub = shift;
    %{ $self } = @_;

    if (defined $self->{return_value} && defined $self->{side_effect})
+{
        die "use only one of return_value or side_effect";
    }

    my $called;

    {
        no strict 'refs';

        *$sub = sub {
            $self->{call_count} = ++$called; 
            return $self->{return_value} if defined $self->{return_val
+ue};
            $self->{side_effect}->() if $self->{side_effect};
        };
    }

    return $self;
}
sub called {
    return shift->call_count ? 1 : 0;
}
sub call_count {
    return shift->{call_count};
}
sub reset {
    my $self = shift;
    delete $self->{$_} for keys %{ $self };
}
1;
[download]

The outer module I'm calling the inner module with mocked subs from (./MyPackage.pm):

package MyPackage;

use lib '.';
use One;

sub test {
    my $obj = One->new;
    $obj->foo;
}
1;
[download]

The inner module I'm mocking (./One.pm):

package One;

sub new {
    return bless {}, shift;
}

sub foo {
    print "in One::foo\n";
}
1;
[download]

... and finally the script I'm testing it all from:

use warnings;
use strict;
use feature 'say';

use lib '.';
use Test::MockSub;
use MyPackage;

{# called() && call_counnt()

    my $foo = Test::MockSub->mock('One::foo');
    MyPackage::test;
    MyPackage::test;

    my $count = $foo->call_count;
    say "testing call_count(): $count";

    my $called = $foo->called;
    say "testing called(): $called";
}
{# return_value

    my $foo = Test::MockSub->mock('One::foo', return_value => 'True');
    my $ret = MyPackage::test;
    say "testing return_value: $ret";
}
{# side_effect

    my $cref = sub {die "thowing error";};
    my $foo = Test::MockSub->mock('One::foo', side_effect => $cref);

    eval{MyPackage::test;};

    print "testing side_effect: ";
    say $@ ? 'success' : 'failed';
}
{# side_effect && return_value dies()

    my $foo;
    
    my $cref = sub {};

    eval{
        $foo = Test::MockSub->mock('One::foo', side_effect => $cref, r
+eturn_value => 1);};

    print "testing side_effect & return_value dies(): "; 
    say $@ ? 'success' : 'failed';
}
{# reset()

    my $foo = Test::MockSub->mock('One::foo', return_value => 1);
    my $ret1 = MyPackage::test;
    
    $foo->reset;

    my $ret2 = MyPackage::test;

    print "testing reset():";
    say defined $ret1 && ! defined $ret2 ? 'success' : 'failed';
}
[download]

There's Test::MockModule and Test::MockObject, but I like the built-in methods, and how I've done it allows for mocking functions, class methods and object methods all at the same time (at least I think).

Thoughts, criticism and feedback welcome as always.