# The Universe of Discourse

Fri, 27 Aug 2010

A dummy generator for mock objects
I am not sure how useful this actually is, but I after having used it once it was not yet obvious that it was a bad idea, so I am writing it up here.

Suppose you are debugging some method, say someMethod, which accepts as one of its arguments complicated, annoying objects $annoying that you either can't or don't want to instantiate. This might be because$annoying is very complicated, with many sub-objects to set up, or perhaps you simply don't know how to build $annoying and don't care to find out. That is okay, because you can get someMethod to run without the full behavior of$annoying. Say for example someMethod calls $annoying->foo_manager->get_foo(...)->get_user_id. You don't understand or care about the details because for debugging someMethod it is enough to suppose that the end result is the user ID 3. You could supply a mock object, or several, that implement the various methods, but that requires some work up front. Instead, use this canned Dummy class. Instead of instantiating a real$annoying (which is difficult) or using a bespoke mock object, use Dummy->new("annoying"):

        package Dummy;
use Data::Dumper;
$Data::Dumper::Terse = 1; our$METHOD;

my @names = qw(bottle corncob euphonium octopus potato slide);
my $NAME = "aaa"; sub new { my ($class, $name) = @_;$name ||= $METHOD || shift(@names) ||$NAME++;
bless { N => $name } =>$class;
}

The call Dummy->new("annoying") will generate an ad-hoc mock object; whenever any method is called on this dummy object, the call will be caught by an AUTOLOAD that will prompt you for the return value you want it to produce:

        sub AUTOLOAD {
my ($self, @args) = @_; my ($p, $m) =$AUTOLOAD =~ /(.*)::(.*)/;
local $METHOD =$m;
print STDERR "<< $_[0]{N}\->$m >>\n";
print STDERR "Arguments: " . Dumper(\@args) . "\n";
my $v; do { print STDERR "Value? "; chomp($v = <STDIN>);
} until eval "$v; 1"; return(eval$v);
}

sub DESTROY { }

1;

The prompt looks like this:

  << annoying->foo_manager >>
Arguments: []
Value?

If the returned value should be a sub-object, no problem: just put in new Dummy and it will make a new Dummy object named foo_manager, and the next prompt will be:

  << foo_manager->get_foo >>
Arguments: ...
...
Value?

Now you can put in new Dummy "(Fred's foo)" or whatever. Eventually it will ask you for a value for (Fred's foo)->id and you can have it return 4.

It's tempting to add caching, so that it won't ask you twice for the results of the same method call. But that would foreclose the option to have the call return different results twice. Better, I think, is for the user to cache the results themselves if they plan to use them again; there is nothing stopping the user from entering a value expression like \$::val = ....

This may turn out to be one of those things that is mildly useful, but not useful enough to actually use; we'll see.