NAME

       Test::Log::Log4perl - test log4perl

SYNOPSIS

         # setup l4p
         use Log::Log4Perl;
         # do your normal Log::Log4Perl setup here
         use Test::Log::Log4perl;

         # get the loggers
         my $logger  = Log::Log4perl->get_logger("Foo::Bar");
         my $tlogger = Test::Log::Log4perl->get_logger("Foo::Bar");

         # test l4p
         Test::Log::Log4perl->start();

         # declare we're going to log something
         $tlogger->error("This is a test");

         # log that something
         $logger->error("This is a test");

         # test that those things matched
         Test::Log::Log4perl->end("Test that that logs okay");

         # we also have a simplified version:
         {
           my $foo = Test::Log::Log4perl->expect(['foo.bar.quux', warn => qr/hello/ ]);
           # ... do something that should log 'hello'
         }
         # $foo goes out of scope; this triggers the test.

DESCRIPTION

       This module can be used to test that you're logging the right thing with Log::Log4perl.  It checks that
       we get what, and only what, we expect logged by your code.

       The basic process is very simple.  Within your test script you get one or more loggers from
       Test::Log::Log4perl with the "get_logger" method just like you would with Log::Log4perl.  You're going to
       use these loggers to declare what you think the code you're going to test should be logging.

         # declare a bunch of test loggers
         my $tlogger = Test::Log::Log4perl->get_logger("Foo::Bar");

       Then, for each test you want to do you need to start up the module.

         # start the test
         Test::Log::Log4perl->start();

       This diverts all subsequent attempts Log::Log4perl makes to log stuff and records them internally rather
       than passing them though to the Log4perl appenders as normal.

       You then need to declare with the loggers we created earlier what we hope Log4perl will be asked to log.
       This is the same syntax as Test::Log::Log4perl uses, except if you want you can use regular expressions:

         $tlogger->debug("fish");
         $tlogger->warn(qr/bar/);

       You then need to run your code that you're testing.

         # call some code that hopefully will call the log4perl methods
         # 'debug' with "fish" and 'warn' with something that contains 'bar'
         some_code();

       We finally need to tell Test::Log4Perl that we're done and it should do the comparisons.

         # start the test
         Test::Log::Log4perl->end("test name");

   Methods
       get_logger($category)
           Returns  a  new  instance  of  Test::Log::Log4perl  that  can be used to log expected messages in the
           category passed.

       Test::Log::Log4perl->expect(%start_args, ['dotted.path', 'warn' => qr(this), 'warn' => qr(that)], ..)
           Class convenience method. Used like this:

             { # start local scope
               my $foo = Test::Log::Log4perl->expect(['foo.bar.quux', warn => qr/hello/ ]);
               # ... do something that should log 'hello'
             } # $foo goes out of scope; this triggers the test.

       start
           Class method.  Start logging.  When you call this method it temporarily redirects  all  logging  from
           the standard logging locations to the internal logging routine until end is called.  Takes parameters
           to change the behavior of this (and only this) test.  See below.

       debug(@what)
       info(@what)
       warn(@what)
       error(@what)
       fatal(@what)
           Instance methods.  String of things that you're expecting to log, at the level you're expecting them,
           in what class.

       end()
       end($name)
           Ends  the  test  and compares what we've got with what we expected.  Switches logging back from being
           captured to going to wherever it was originally directed in the config.

   Ignoring All Logging Messages
       Sometimes you're going to be testing something that generates a load of spurious log  messages  that  you
       simply  want to ignore without testing their contents, but you don't want to have to reconfigure your log
       file.  The simplest way to do this is to do:

         use Test::Log::Log4perl;
         Test::Log::Log4perl->suppress_logging;

       All logging functions stop working.  Do not alter the Logging  classes  (for  example,  by  changing  the
       config file and use Log4perl's "init_and_watch" functionality) after this call has been made.

       This function will be effectively a no-op if the environmental variable "NO_SUPPRESS_LOGGING" is set to a
       true  value  (so  if  your code is behaving weirdly you can turn all the logging back on from the command
       line without changing any of the code)

   Selectively Ignoring Logging Messages By Priority
       It's a bad idea to completely ignore all messages.  What you probably want to do is ignore  some  of  the
       trivial  messages that you don't care about, and just test that there aren't any unexpected messages of a
       set priority.

       You can temporarily ignore any logging messages that are  made  by  passing  parameters  to  the  "start"
       routine

         # for this test, just ignore DEBUG, INFO, and WARN
         Test::Log::Log4perl->start( ignore_priority => "warn" );

         # you can use the levels constants to do the same thing
         use Log::Log4perl qw(:levels);
         Test::Log::Log4perl->start( ignore_priority => $WARN );

       You  might want to ignore all logging events at all (this can be used as quick way to not test the actual
       log messages, but just ignore the output.

         # for this test, ignore everything
         Test::Log::Log4perl->start( ignore_priority => "everything" );

         # contary to readability, the same thing (try not to write this)
         use Log::Log4perl qw(:levels);
         Test::Log::Log4perl->start( ignore_priority => $OFF );

       Or you might want to not ignore anything (which is the default, unless  you've  played  with  the  method
       calls mentioned below:)

         # for this test, ignore nothing
         Test::Log::Log4perl->start( ignore_priority => "nothing" );

         # contary to readability, the same thing (try not to write this)
         use Log::Log4perl qw(:levels);
         Test::Log::Log4perl->start( ignore_priority => $ALL );

       You  can  also  permanently  effect what things are ignored with the "ignore_priority" method call.  This
       persists between tests and isn't automatically reset after each call to "start".

         # ignore DEBUG, INFO and WARN for all future tests
         Test::Log::Log4perl->ignore_priority("warn");

         # you can use the levels constants to do the same thing
         use Log::Log4perl qw(:levels);
         Test::Log::Log4perl->ignore_priority($WARN);

         # ignore everything (no log messages will be logged)
         Test::Log::Log4perl->ignore_priority("everything");

         # ignore nothing (messages will be logged reguardless of priority)
         Test::Log::Log4perl->ignore_priority("nothing");

       Obviously, you may temporarily override whatever permanent.

BUGS

       Logging methods don't return the number of appenders they've written to (or  rather,  they  do,  as  it's
       always zero.)

       Changing  the  config  file  (if  you're watching it) while this is testing / suppressing everything will
       probably break everything.  As will creating new appenders, etc...

AUTHOR

         Chia-liang Kao <clkao@clkao.org>
         Mark Fowler <mark@twoshortplanks.com>

COPYRIGHT

         Copyright 2010 Chia-liang Kao all rights reserved.
         Copyright 2005 Fotango Ltd all rights reserved.

         Licensed under the same terms as Perl itself.

perl v5.36.0                                       2022-12-08                           Test::Log::Log4perl(3pm)