

Testing for exceptions

The Test::Fatal module makes it very easy to test code that is supposed to throw an exception. It provides an exception function that takes a code block. If the code completes normally, exception { code } returns undefined; if the code throws an exception, exception { code } returns the exception value that was thrown. So for example, if you want to make sure that some erroneous call is detected and throws an exception, you can use this: isnt( exception { do_something( how_many_times => "W" ) }, undef, "how_many_times argument requires a number" ); which will succeed if do_something(…) throws an exception, and fail if it does not. You can also write a stricter test, to look for the particular exception you expect: like( exception { do_something( how_many_times => "W" ) }, qr/how_many_times is not numeric/, "how_many_times argument requires a number" ); which will succeed if do_something(…) throws an exception that contains how_many_times is not numeric , and fail otherwise. Today I almost made the terrible mistake of using the first form instead of the second. The manual suggests that you use the first form, but it's a bad suggestion. The problem is that if you completely screw up the test and write a broken code block that dies, the first test will cheerfully succeed anyway. For example, suppose you make a typo in the test code: isnt( exception { do_something( how_many_tims => "W" ) }, undef, "how_many_times argument requires a number" ); Here the do_something(…) call throws some totally different exception that we are not interested in, something like unknown argument 'how_many_tims' or mandatory 'how_many_times' argument missing , but the exception is swallowed and the test reports success, even though we know nothing at all about the feature we were trying to test. But the test looks like it passed. In my example today, the code looked like this: isnt( exception { my $invoice = gen_invoice(); $invoice->abandon; }, undef, "Can't abandon invoice with no abandoned charges"); }); The abandon call was supposed to fail, for reasons you don't care about. But in fact, the execution never got that far, because there was a totally dumb bug in gen_invoice() (a missing required constructor argument) that caused it to die with a completely different exception. I would never have noticed this error if I hadn't spontaneously decided to make the test stricter: like( exception { my $invoice = gen_invoice(); $invoice->abandon; }, qr/Can't.*with no abandoned charges/, "Can't abandon invoice with no abandoned charges"); }); This test failed, and the failure made clear that gen_invoice() , a piece of otherwise unimportant test apparatus, was completely broken, and that several other tests I had written in the same style appeared to be passing but weren't actually running the code I thought they were. So the rule of thumb is: even though the Test::Fatal manual suggests that you use isnt( exception { … }, undef, …) , do not. I mentioned this to Ricardo Signes, the author of the module, and he released a new version with revised documentation before I managed to get this blog post published.

[Other articles in category /prog/perl] permanent link

