use Proc::Background; # Make sure it's loaded at compile-time
package Proc::Background;
no warnings 'redefine';
sub new { do_stubby_stuff(@_) }

package main;
# Go about your testing business
[download]

Wow! The called program is going to load the module, so pre-empt it by loading it myself! I liked this and used it. Thanks!

As for your warning about how this isn't a proper OO override: noted, but in this particular setting I am aiming for total suppression. In fact I went and condensed your suggestion to the following:

# pre-empt the loading
use Proc::Background;
{   no warnings 'redefine';
    *Proc::Background::new = sub {};
}
[download]

having realized that my stub of choice was a no-op.

I don't get how that works. use() isn't require(), that is, won't the test code reload Proc::Background and install its version of Proc::Background::new in the symbol table, overwriting the sub reference you installed in the symbol table for Proc::Background::new?

edit: Never mind. The following are equivalent:

use Proc::Background

#and

BEGIN {

require Proc::Background;
Proc::Background->import;

}
[download]

So the second use/require won't do anything.

Also, couldn't you simply perform a substituion (s///) on launch_rockets.pl and delete the offending lines?

I like this solution. I needed to do something similar today as it happens. I wanted to replace only certain methods, so I put a copy of the CPAN module in a Replacement subdirectory, complete with its parent directory, amended it and:

use library '/home/simon/lib/Replacement';

use Replacement::Some::Module;

...
[download]

One world, one people

I needed to do something similar myself about a month ago, too... The result was LocalOverride, which hooks into the require mechanism (by putting a coderef into @INC, as cdarke suggested above) to accomplish what you've described transparently. With the default configuration, LocalOverride would cause

use Some::Module;
[download]

to more-or-less turn into

use Some::Module;
use Local::Some::Module;
[download]

("More-or-less" because Some::Module::import runs only after both versions are loaded, not once after the base module loads and again after the local modifications load.)

Also note that, with this technique, you don't need to use a complete copy of the base module as a baseline. So long as you load both Some::Module and then Replacement::Some::Module, you only need to include changed subs in Replacement::Some::Module.

  #!/usr/bin/perl
  
  use Your::Module;
  use Proc::Background;
  use Test::Resub qw(resub);

  # disable Proc::Background->new for the scope of this block
  {
    my $fake_new = sub {
      return bless {}, 'Proc::Background'; # or whatever
    };
    my $resub = resub 'Proc::Background::new', $fake_new;

    # continue on your merry way, content knowing that
    # your $fake_new is getting called.
  }
  # scope of $resub object ends, its DESTROYER restores
  # the original Proc::Background::new.
[download]

Test::Resub allows you to capture the arguments that go to your resubbed code. For example, consider this helper function

  package My::Module;

  use IO::Socket::INET;

  ...

  sub open_socket_to {
    my ($class, %args) = @_;
    return IO::Socket::INET->new(
      PeerAddr => $args{machine},
      PeerPort => $args{port},
      Proto => $args{protocol} || 'tcp',
      Type => SOCK_STREAM,
    );
  }
[download]

  use Test;
  ...
  use My::Module;
  use Test::Resub qw(resub);
  use IO::Socket::INET;

  # test open_socket_to
  {
    my $rs = resub 'IO::Socket::INET::new', sub { 'a socket' }, captur
+e => 1;
    my $socket = My::Module->open_socket_to(
      machine => 'example.com',
      port => '-29',
    );

    # return value of ->open_socket_to is whatever IO::Socket::INET::n
+ew gives us
    ok( $socket, 'a socket' );

    # We created the socket correctly - the fact that we provided an
    # illegal PeerPort doesn't need to be handled by this test:
    # IO::Socket::INET should have his own tests for his ->new.
    is_deeply( $rs->named_method_args, [{
      PeerAddr => 'example.com',
      PeerPort => -29,
      Proto => 'tcp',
      Type => SOCK_STREAM,
    }] );
  }
[download]

You can have multiple resubs and wiretaps in place for the same subroutine: they'll stack properly and unroll correctly.