1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
NAME
Test::Log4perl - test log4perl
SYNOPSIS
use Test::More tests => 1;
# setup l4p
use Log::Log4Perl;
# do your normal Log::Log4Perl setup here
use Test::Log4perl;
# get the loggers
my $logger = Log::Log4perl->get_logger("Foo::Bar");
my $tlogger = Test::Log4perl->get_logger("Foo::Bar");
# test l4p
Test::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::Log4perl->end("Test that that logs okay");
# we also have a simplified version:
{
my $foo = Test::Logger->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::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::Log4perl->get_logger("Foo::Bar");
Then, for each test you want to do you need to start up the module.
# start the test
Test::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::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::Log4perl->end("test name");
Methods
get_logger($category)
Returns a new instance of Test::Logger that can be used to log
expected messages in the category passed.
Test::Logger->expect(['dotted.path', 'warn' => qr'this', 'warn' =>
qr'that'], ..)
Class convenience method. Used like this:
{ # start local scope
my $foo = Test::Logger->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 temporarly
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 simpliest way to do this is to do:
use Test::Log4perl;
Test::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 effectivly a no-op if the enviromental variable
"NO_SUPRESS_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)
Selectivly 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 temporarly ignore any logging messages that are made by passing
parameters to the "start" routine
# for this test, just ignore DEBUG, INFO, and WARN
Test::Log4perl->start( ignore_priority => "warn" );
# you can use the levels constants to do the same thing
use Log::Log4perl qw(:levels);
Test::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::Log4perl->start( ignore_priority => "everything" );
# contary to readability, the same thing (try not to write this)
use Log::Log4perl qw(:levels);
Test::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::Log4perl->start( ignore_priority => "nothing" );
# contary to readability, the same thing (try not to write this)
use Log::Log4perl qw(:levels);
Test::Log4perl->start( ignore_priority => $ALL );
You can also perminatly effect what things are ignored with the
"ignore_priority" method call. This persists between tests and isn't
autoically reset after each call to "start".
# ignore DEBUG, INFO and WARN for all future tests
Test::Log4perl->ignore_priority("warn");
# you can use the levels constants to do the same thing
use Log::Log4perl qw(:levels);
Test::Log4perl->ignore_priority($WARN);
# ignore everything (no log messages will be logged)
Test::Log4perl->ignore_priority("everything");
# ignore nothing (messages will be logged reguardless of priority)
Test::Log4perl->ignore_priority("nothing");
Obviously, you may temporarly override whatever perminant
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 /
supressing everything will probably break everything. As will creating
new appenders, etc...
AUTHOR
Mark Fowler <mark@twoshortplanks.com>
COPYRIGHT
Copyright 2005 Fotango Ltd all rights reserved.
Licensed under the same terms as Perl itself.
|
