I'm really not understanding something. I've run into a module for which I had a lot of difficulty writing the first few tests. This usually happens when the module under scrutiny does something a little weird, so I'm used to it by now.
But this one is a lot weird.
The code for the module I'm looking at is structured exactly like this:
package foo;
use strict;
use warnings;
sub firstSub {
my $string_orig = shift;
my $string = secondSub $string_orig;
return ( foo => $string, bar => $string_orig );
}
sub secondSub {
my $string = shift;
my $ret = join '', reverse split //, $string;
return $ret;
}
1;
What's strange is that when I use the module and try to call "firstSub", I get a Can't locate method object secondSub via package VALUE_PASSED at line blah, of course substituting VALUE_PASSED for whatever value I actually pass :) But the module - as is - works on the development server, and has worked on the production server for years with this exact structure and syntax.
So for this example, this code (reduced to the smallest example that still exhibits the behavior, but essentially the same structure) tries to call the modules' subroutine via:
use foo;
my %q = foo::firstSub( 'MTFNPY' );
print "$_: $q{$_}" for keys %q;
And the output I get is:
Can't locate object method "secondSub" via package "MTFNPY" (perhaps you forgot to load "MTFNPY"?) at foo.pm line 13.
A little boggling. I tried a few things, including this ugliness:
{
no warnings 'once';
*MTFNPY::secondSub = \&foo::secondSub;
}
... but of course that will only work as long as I'm passing the value of "MTFNPY".
Running the code through B::Deparse confirms that line is interpreted as my $string = $string_orig->secondSub.
I see I've got a couple of options:
- Fix the code minimally - re-order the subroutines inside the module so the second subroutine is defined first, so it will be correctly interpreted as a function call.
- Fix the code a little less minimally - add parens around the argument to
secondSub.
- Fix* my tests and don't touch the original code until my tests are complete so I am 100% certain I don't break anything else. (I'm fairly sure either of these changes won't, but "fairly" isn't 100%).
* By which I mean 'just make it work'
So, I add this near the top of my test file:
BEGIN {
package foo;
use subs 'secondSub';
}
use_ok( 'foo' );
... which basically tells the interpreter that package foo will be defining a subroutine called secondSub, which is to say predeclaring them - before the foo module has a chance to load, by taking place inside a BEGIN block.
And lo, testing successful.
But what I still don't understand is how exactly the code in the original module works at all! I'm testing on the same box where the code lives - where the code runs day in and day out without bringing the test server down to a screeching halt. I know - I added trace debugging statements all around, thinking that perhaps the code has always been silently failing and the failure was just dealt with. But no, the code was making it through that step and doing exactly what my predecessor(s) expected it to do. It's just doing it wrong.
