that's "terminology injection" (aka die "brain overflow" ;-)

Ha ha, I noticed a mind-boggling number of different ways to do this type of stuff in Perl. For example, chromatic refers here to a modernperlbooks article which gives the illustrative example below:

At its core, dependency injection is a formalization of the design principle "Don't hard-code your dependencies." Consider the code:

sub fetch
{
    my ($self, $uri) = @_;
    my $ua           = LWP::UserAgent->new;
    my $resp         = $ua->get( $uri );
    ...
}
[download]

That's not bad code by any means, but it's a little too specific and a little less generic due to the presence of the literal string LWP::UserAgent. That might be fine for your application, but that hard-coding introduces a coupling that can work against other uses of this code. Imagine testing this code, for example. While you could use Test::MockObject to intercept calls to LWP::UserAgent's constructor, that approach manipulates Perl symbol tables to work around a hard coded dependency.

An alternate approach uses a touch of indirection to allow for greater genericity:

use Moose;
has 'ua', is => 'ro', default => sub { LWP::UserAgent->new };

sub fetch
{
    my ($self, $uri) = @_;
    my $ua           = $self->ua;
    my $resp         = $ua->get( $uri );

    ...
}
[download]

Now the choice of user agent is up to the code which constructs this object. If it provides a ua to the constructor, fetch() will use that. Otherwise, the default behavior is to use LWP::UserAgent as before.

Lots of stuff on CPAN too:

• Moose
• Test::Class
• Test::MockObject
• Test::MockObject::Extends
• Test::Class::Moose
• Test::FixtureBuilder
• Test::Fixture::DBI
• DBIx::Class::EasyFixture
• Zydeco
• Mojolicious::Lite
• Bread::Board
• Bread::Board::Manual

As usual, the hard part is knowing which is good and which is crap. Please let us know of other cool CPAN offerings I've overlooked.