One of the problems with the test suite is that it frequently outputs a lot of data that's not part of the test output. Warnings get spit out, log messages are written to STDOUT and STDERR, etc. When a test suite takes over an hour to run, no one's going to sit there and read all of those, so I'm capturing them and testing their output. For one class, here's what I've done (setup and teardown methods are called at the beginning and end of each test in the class):

my $LOG_ERROR;                                                        
+                                 
my $_log_error_sub_cache;
sub setup
{
    my $class = shift;
    $class->SUPER::setup_test;
    $_log_error_sub_cache = *RTK::Digitrak::LogRun::_log_error{CODE};
    no warnings 'redefine';
    *Foo::Bar_log_error = sub($) { $LOG_ERROR = shift };
}                                                                     
+                            

sub teardown
{
    my $class = shift;
    $class->SUPER::teardown_test;
    no warnings 'redefine';
    *Foo::Bar:_log_error = $_log_error_sub_cache;
}
[download]

In my individual tests, I can now test that the $LOG_ERROR has the error message that I expect. I have to restore the original sub in the teardown or else the next test class that's run will have the altered behavior and this is bad because it will hide the data that I need to test.

What I would like to do is something like this:

use Foo::Test::LogMessages;
my $log = Foo::Test::LogMessages->new;

sub TEST_WHICH_HAS_LOG_OUTPUT
{
  # do something
  $log->capture_log_only_for_this_scope;
  is($log->message, qw/some message/, '... and we should have an error
+');
}

sub TEST_WHICH_DOES_NOT_HAVE_LOG_OUTPUT
{
  # do something
}
[download]

The idea here is that I only want the side effect of suppressing the log message in particular subs. I could put a $log->end_capture_log or something similar at the end of the test sub but if a programmer forgets to do that, we could have plenty of log messages get suppressed and not even realize it. If somehow the log capturing routine could recognize the scope that it's in and disable itself when it's done, that would be handy. This would sort of be like local *Foo::Bar = sub { ... };, but without wanting to deal with all of the explicit typing or the typos inherent in dealing with full package names.