View Javadoc
1   package uk.org.lidalia.slf4jtest;
2   
3   import java.util.Arrays;
4   import java.util.HashMap;
5   import java.util.List;
6   import java.util.Map;
7   
8   import org.hamcrest.Matcher;
9   import org.junit.After;
10  import org.junit.Rule;
11  import org.junit.Test;
12  import org.junit.runner.RunWith;
13  import org.slf4j.Marker;
14  
15  import com.google.common.base.Optional;
16  import com.google.common.collect.ImmutableMap;
17  import junitparams.JUnitParamsRunner;
18  import junitparams.Parameters;
19  
20  import uk.org.lidalia.slf4jext.Level;
21  import uk.org.lidalia.test.StaticTimeRule;
22  import uk.org.lidalia.test.SystemOutputRule;
23  
24  import static com.google.common.base.Optional.absent;
25  import static com.google.common.base.Optional.of;
26  import static java.lang.System.lineSeparator;
27  import static java.util.Arrays.asList;
28  import static org.hamcrest.Matchers.not;
29  import static org.hamcrest.Matchers.startsWith;
30  import static org.hamcrest.core.Is.is;
31  import static org.junit.Assert.assertThat;
32  import static org.mockito.Mockito.mock;
33  import static uk.org.lidalia.slf4jext.Level.DEBUG;
34  import static uk.org.lidalia.slf4jext.Level.ERROR;
35  import static uk.org.lidalia.slf4jext.Level.INFO;
36  import static uk.org.lidalia.slf4jext.Level.TRACE;
37  import static uk.org.lidalia.slf4jext.Level.WARN;
38  import static uk.org.lidalia.slf4jtest.LoggingEvent.debug;
39  import static uk.org.lidalia.slf4jtest.LoggingEvent.error;
40  import static uk.org.lidalia.slf4jtest.LoggingEvent.info;
41  import static uk.org.lidalia.slf4jtest.LoggingEvent.trace;
42  import static uk.org.lidalia.slf4jtest.LoggingEvent.warn;
43  import static uk.org.lidalia.test.StaticTimeRule.alwaysStartOfEpoch;
44  
45  @RunWith(JUnitParamsRunner.class)
46  public class LoggingEventTests {
47  
48      private static final ImmutableMap<String, String> emptyMap = ImmutableMap.of();
49  
50      @Rule public SystemOutputRule systemOutputRule = new SystemOutputRule();
51      @Rule public StaticTimeRule alwaysStartOfEpoch = alwaysStartOfEpoch();
52  
53      Level level = Level.TRACE;
54      Map<String, String> mdc = new HashMap<>();
55      {
56          mdc.put("key", "value");
57      }
58  
59      Marker marker = mock(Marker.class);
60      Throwable throwable = new Throwable();
61      String message = "message";
62      Object arg1 = "arg1";
63      Object arg2 = "arg2";
64      List<Object> args = asList(arg1, arg2);
65  
66      @Test
67      public void constructorMessageArgs() {
68          LoggingEvent event = new LoggingEvent(level, message, arg1, arg2);
69          assertThat(event.getLevel(), is(level));
70          assertThat(event.getMdc(), is(emptyMap));
71          assertThat(event.getMarker(), isAbsent());
72          assertThat(event.getThrowable(), isAbsent());
73          assertThat(event.getMessage(), is(message));
74          assertThat(event.getArguments(), is(args));
75      }
76  
77      @Test
78      public void constructorThrowableMessageArgs() {
79          LoggingEvent event = new LoggingEvent(level, throwable, message, arg1, arg2);
80          assertThat(event.getLevel(), is(level));
81          assertThat(event.getMdc(), is(emptyMap));
82          assertThat(event.getMarker(), isAbsent());
83          assertThat(event.getThrowable(), is(of(throwable)));
84          assertThat(event.getMessage(), is(message));
85          assertThat(event.getArguments(), is(args));
86      }
87  
88      @Test
89      public void constructorMarkerMessageArgs() {
90          LoggingEvent event = new LoggingEvent(level, marker, message, arg1, arg2);
91          assertThat(event.getLevel(), is(level));
92          assertThat(event.getMdc(), is(emptyMap));
93          assertThat(event.getMarker(), is(of(marker)));
94          assertThat(event.getThrowable(), isAbsent());
95          assertThat(event.getMessage(), is(message));
96          assertThat(event.getArguments(), is(args));
97      }
98  
99      @Test
100     public void constructorMarkerThrowableMessageArgs() {
101         LoggingEvent event = new LoggingEvent(level, marker, throwable, message, arg1, arg2);
102         assertThat(event.getLevel(), is(level));
103         assertThat(event.getMdc(), is(emptyMap));
104         assertThat(event.getMarker(), is(of(marker)));
105         assertThat(event.getThrowable(), is(of(throwable)));
106         assertThat(event.getMessage(), is(message));
107         assertThat(event.getArguments(), is(args));
108     }
109 
110     @Test
111     public void constructorMdcMessageArgs() {
112         LoggingEvent event = new LoggingEvent(level, mdc, message, arg1, arg2);
113         assertThat(event.getLevel(), is(level));
114         assertThat(event.getMdc(), is(mdc));
115         assertThat(event.getMarker(), isAbsent());
116         assertThat(event.getThrowable(), isAbsent());
117         assertThat(event.getMessage(), is(message));
118         assertThat(event.getArguments(), is(args));
119     }
120 
121     @Test
122     public void constructorMdcThrowableMessageArgs() {
123         LoggingEvent event = new LoggingEvent(level, mdc, throwable, message, arg1, arg2);
124         assertThat(event.getLevel(), is(level));
125         assertThat(event.getMdc(), is(mdc));
126         assertThat(event.getMarker(), isAbsent());
127         assertThat(event.getThrowable(), is(of(throwable)));
128         assertThat(event.getMessage(), is(message));
129         assertThat(event.getArguments(), is(args));
130     }
131 
132     @Test
133     public void constructorMdcMarkerMessageArgs() {
134         LoggingEvent event = new LoggingEvent(level, mdc, marker, message, arg1, arg2);
135         assertThat(event.getLevel(), is(level));
136         assertThat(event.getMdc(), is(mdc));
137         assertThat(event.getMarker(), is(of(marker)));
138         assertThat(event.getThrowable(), isAbsent());
139         assertThat(event.getMessage(), is(message));
140         assertThat(event.getArguments(), is(args));
141     }
142 
143     @Test
144     public void constructorMdcMarkerThrowableMessageArgs() {
145         LoggingEvent event = new LoggingEvent(level, mdc, marker, throwable, message, arg1, arg2);
146         assertThat(event.getLevel(), is(level));
147         assertThat(event.getMdc(), is(mdc));
148         assertThat(event.getMarker(), is(of(marker)));
149         assertThat(event.getThrowable(), is(of(throwable)));
150         assertThat(event.getMessage(), is(message));
151         assertThat(event.getArguments(), is(args));
152     }
153 
154     @Test
155     public void traceMessageArgs() {
156         LoggingEvent event = trace(message, arg1, arg2);
157         LoggingEvent expected = new LoggingEvent(TRACE, message, arg1, arg2);
158         assertThat(event, is(expected));
159     }
160 
161     @Test
162     public void traceThrowableMessageArgs() {
163         LoggingEvent event = trace(throwable, message, arg1, arg2);
164         LoggingEvent expected = new LoggingEvent(TRACE, throwable, message, arg1, arg2);
165         assertThat(event, is(expected));
166     }
167 
168     @Test
169     public void traceMarkerMessageArgs() {
170         LoggingEvent event = trace(marker, message, arg1, arg2);
171         LoggingEvent expected = new LoggingEvent(TRACE, marker, message, arg1, arg2);
172         assertThat(event, is(expected));
173     }
174 
175     @Test
176     public void traceMarkerThrowableMessageArgs() {
177         LoggingEvent event = trace(marker, throwable, message, arg1, arg2);
178         LoggingEvent expected = new LoggingEvent(TRACE, marker, throwable, message, arg1, arg2);
179         assertThat(event, is(expected));
180     }
181 
182     @Test
183     public void traceMdcMessageArgs() {
184         LoggingEvent event = trace(mdc, message, arg1, arg2);
185         LoggingEvent expected = new LoggingEvent(TRACE, mdc, message, arg1, arg2);
186         assertThat(event, is(expected));
187     }
188 
189     @Test
190     public void traceMdcThrowableMessageArgs() {
191         LoggingEvent event = trace(mdc, throwable, message, arg1, arg2);
192         LoggingEvent expected = new LoggingEvent(TRACE, mdc, throwable, message, arg1, arg2);
193         assertThat(event, is(expected));
194     }
195 
196     @Test
197     public void traceMdcMarkerMessageArgs() {
198         LoggingEvent event = trace(mdc, marker, message, arg1, arg2);
199         LoggingEvent expected = new LoggingEvent(TRACE, mdc, marker, message, arg1, arg2);
200         assertThat(event, is(expected));
201     }
202 
203     @Test
204     public void traceMdcMarkerThrowableMessageArgs() {
205         LoggingEvent event = trace(mdc, marker, throwable, message, arg1, arg2);
206         LoggingEvent expected = new LoggingEvent(TRACE, mdc, marker, throwable, message, arg1, arg2);
207         assertThat(event, is(expected));
208     }
209 
210     @Test
211     public void debugMessageArgs() {
212         LoggingEvent event = debug(message, arg1, arg2);
213         LoggingEvent expected = new LoggingEvent(DEBUG, message, arg1, arg2);
214         assertThat(event, is(expected));
215     }
216 
217     @Test
218     public void debugThrowableMessageArgs() {
219         LoggingEvent event = debug(throwable, message, arg1, arg2);
220         LoggingEvent expected = new LoggingEvent(DEBUG, throwable, message, arg1, arg2);
221         assertThat(event, is(expected));
222     }
223 
224     @Test
225     public void debugMarkerMessageArgs() {
226         LoggingEvent event = debug(marker, message, arg1, arg2);
227         LoggingEvent expected = new LoggingEvent(DEBUG, marker, message, arg1, arg2);
228         assertThat(event, is(expected));
229     }
230 
231     @Test
232     public void debugMarkerThrowableMessageArgs() {
233         LoggingEvent event = debug(marker, throwable, message, arg1, arg2);
234         LoggingEvent expected = new LoggingEvent(DEBUG, marker, throwable, message, arg1, arg2);
235         assertThat(event, is(expected));
236     }
237 
238     @Test
239     public void debugMdcMessageArgs() {
240         LoggingEvent event = debug(mdc, message, arg1, arg2);
241         LoggingEvent expected = new LoggingEvent(DEBUG, mdc, message, arg1, arg2);
242         assertThat(event, is(expected));
243     }
244 
245     @Test
246     public void debugMdcThrowableMessageArgs() {
247         LoggingEvent event = debug(mdc, throwable, message, arg1, arg2);
248         LoggingEvent expected = new LoggingEvent(DEBUG, mdc, throwable, message, arg1, arg2);
249         assertThat(event, is(expected));
250     }
251 
252     @Test
253     public void debugMdcMarkerMessageArgs() {
254         LoggingEvent event = debug(mdc, marker, message, arg1, arg2);
255         LoggingEvent expected = new LoggingEvent(DEBUG, mdc, marker, message, arg1, arg2);
256         assertThat(event, is(expected));
257     }
258 
259     @Test
260     public void debugMdcMarkerThrowableMessageArgs() {
261         LoggingEvent event = debug(mdc, marker, throwable, message, arg1, arg2);
262         LoggingEvent expected = new LoggingEvent(DEBUG, mdc, marker, throwable, message, arg1, arg2);
263         assertThat(event, is(expected));
264     }
265 
266     @Test
267     public void infoMessageArgs() {
268         LoggingEvent event = info(message, arg1, arg2);
269         LoggingEvent expected = new LoggingEvent(INFO, message, arg1, arg2);
270         assertThat(event, is(expected));
271     }
272 
273     @Test
274     public void infoThrowableMessageArgs() {
275         LoggingEvent event = info(throwable, message, arg1, arg2);
276         LoggingEvent expected = new LoggingEvent(INFO, throwable, message, arg1, arg2);
277         assertThat(event, is(expected));
278     }
279 
280     @Test
281     public void infoMarkerMessageArgs() {
282         LoggingEvent event = info(marker, message, arg1, arg2);
283         LoggingEvent expected = new LoggingEvent(INFO, marker, message, arg1, arg2);
284         assertThat(event, is(expected));
285     }
286 
287     @Test
288     public void infoMarkerThrowableMessageArgs() {
289         LoggingEvent event = info(marker, throwable, message, arg1, arg2);
290         LoggingEvent expected = new LoggingEvent(INFO, marker, throwable, message, arg1, arg2);
291         assertThat(event, is(expected));
292     }
293 
294     @Test
295     public void infoMdcMessageArgs() {
296         LoggingEvent event = info(mdc, message, arg1, arg2);
297         LoggingEvent expected = new LoggingEvent(INFO, mdc, message, arg1, arg2);
298         assertThat(event, is(expected));
299     }
300 
301     @Test
302     public void infoMdcThrowableMessageArgs() {
303         LoggingEvent event = info(mdc, throwable, message, arg1, arg2);
304         LoggingEvent expected = new LoggingEvent(INFO, mdc, throwable, message, arg1, arg2);
305         assertThat(event, is(expected));
306     }
307 
308     @Test
309     public void infoMdcMarkerMessageArgs() {
310         LoggingEvent event = info(mdc, marker, message, arg1, arg2);
311         LoggingEvent expected = new LoggingEvent(INFO, mdc, marker, message, arg1, arg2);
312         assertThat(event, is(expected));
313     }
314 
315     @Test
316     public void infoMdcMarkerThrowableMessageArgs() {
317         LoggingEvent event = info(mdc, marker, throwable, message, arg1, arg2);
318         LoggingEvent expected = new LoggingEvent(INFO, mdc, marker, throwable, message, arg1, arg2);
319         assertThat(event, is(expected));
320     }
321 
322     @Test
323     public void warnMessageArgs() {
324         LoggingEvent event = warn(message, arg1, arg2);
325         LoggingEvent expected = new LoggingEvent(WARN, message, arg1, arg2);
326         assertThat(event, is(expected));
327     }
328 
329     @Test
330     public void warnThrowableMessageArgs() {
331         LoggingEvent event = warn(throwable, message, arg1, arg2);
332         LoggingEvent expected = new LoggingEvent(WARN, throwable, message, arg1, arg2);
333         assertThat(event, is(expected));
334     }
335 
336     @Test
337     public void warnMarkerMessageArgs() {
338         LoggingEvent event = warn(marker, message, arg1, arg2);
339         LoggingEvent expected = new LoggingEvent(WARN, marker, message, arg1, arg2);
340         assertThat(event, is(expected));
341     }
342 
343     @Test
344     public void warnMarkerThrowableMessageArgs() {
345         LoggingEvent event = warn(marker, throwable, message, arg1, arg2);
346         LoggingEvent expected = new LoggingEvent(WARN, marker, throwable, message, arg1, arg2);
347         assertThat(event, is(expected));
348     }
349 
350     @Test
351     public void warnMdcMessageArgs() {
352         LoggingEvent event = warn(mdc, message, arg1, arg2);
353         LoggingEvent expected = new LoggingEvent(WARN, mdc, message, arg1, arg2);
354         assertThat(event, is(expected));
355     }
356 
357     @Test
358     public void warnMdcThrowableMessageArgs() {
359         LoggingEvent event = warn(mdc, throwable, message, arg1, arg2);
360         LoggingEvent expected = new LoggingEvent(WARN, mdc, throwable, message, arg1, arg2);
361         assertThat(event, is(expected));
362     }
363 
364     @Test
365     public void warnMdcMarkerMessageArgs() {
366         LoggingEvent event = warn(mdc, marker, message, arg1, arg2);
367         LoggingEvent expected = new LoggingEvent(WARN, mdc, marker, message, arg1, arg2);
368         assertThat(event, is(expected));
369     }
370 
371     @Test
372     public void warnMdcMarkerThrowableMessageArgs() {
373         LoggingEvent event = warn(mdc, marker, throwable, message, arg1, arg2);
374         LoggingEvent expected = new LoggingEvent(WARN, mdc, marker, throwable, message, arg1, arg2);
375         assertThat(event, is(expected));
376     }
377 
378     @Test
379     public void errorMessageArgs() {
380         LoggingEvent event = error(message, arg1, arg2);
381         LoggingEvent expected = new LoggingEvent(ERROR, message, arg1, arg2);
382         assertThat(event, is(expected));
383     }
384 
385     @Test
386     public void errorThrowableMessageArgs() {
387         LoggingEvent event = error(throwable, message, arg1, arg2);
388         LoggingEvent expected = new LoggingEvent(ERROR, throwable, message, arg1, arg2);
389         assertThat(event, is(expected));
390     }
391 
392     @Test
393     public void errorMarkerMessageArgs() {
394         LoggingEvent event = error(marker, message, arg1, arg2);
395         LoggingEvent expected = new LoggingEvent(ERROR, marker, message, arg1, arg2);
396         assertThat(event, is(expected));
397     }
398 
399     @Test
400     public void errorMarkerThrowableMessageArgs() {
401         LoggingEvent event = error(marker, throwable, message, arg1, arg2);
402         LoggingEvent expected = new LoggingEvent(ERROR, marker, throwable, message, arg1, arg2);
403         assertThat(event, is(expected));
404     }
405 
406     @Test
407     public void errorMdcMessageArgs() {
408         LoggingEvent event = error(mdc, message, arg1, arg2);
409         LoggingEvent expected = new LoggingEvent(ERROR, mdc, message, arg1, arg2);
410         assertThat(event, is(expected));
411     }
412 
413     @Test
414     public void errorMdcThrowableMessageArgs() {
415         LoggingEvent event = error(mdc, throwable, message, arg1, arg2);
416         LoggingEvent expected = new LoggingEvent(ERROR, mdc, throwable, message, arg1, arg2);
417         assertThat(event, is(expected));
418     }
419 
420     @Test
421     public void errorMdcMarkerMessageArgs() {
422         LoggingEvent event = error(mdc, marker, message, arg1, arg2);
423         LoggingEvent expected = new LoggingEvent(ERROR, mdc, marker, message, arg1, arg2);
424         assertThat(event, is(expected));
425     }
426 
427     @Test
428     public void errorMdcMarkerThrowableMessageArgs() {
429         LoggingEvent event = error(mdc, marker, throwable, message, arg1, arg2);
430         LoggingEvent expected = new LoggingEvent(ERROR, mdc, marker, throwable, message, arg1, arg2);
431         assertThat(event, is(expected));
432     }
433 
434     @Test
435     public void mdcIsSnapshotInTime() {
436         Map<String, String> mdc = new HashMap<>();
437         mdc.put("key", "value1");
438         Map<String, String> mdcAtStart = new HashMap<>(mdc);
439         LoggingEvent event = new LoggingEvent(level, mdc, message);
440         mdc.put("key", "value2");
441         assertThat(event.getMdc(), is(mdcAtStart));
442     }
443 
444     @Test(expected = UnsupportedOperationException.class)
445     public void mdcNotModifiable() throws Throwable {
446         Map<String, String> mdc = new HashMap<>();
447         mdc.put("key", "value1");
448         final LoggingEvent event = new LoggingEvent(level, mdc, message);
449         event.getMdc().put("anything", "whatever");
450     }
451 
452     @Test
453     public void argsIsSnapshotInTime() {
454         Object[] args = new Object[]{arg1, arg2};
455         Object[] argsAtStart = Arrays.copyOf(args, args.length);
456         LoggingEvent event = new LoggingEvent(level, message, args);
457         args[0] = "differentArg";
458         assertThat(event.getArguments(), is(asList(argsAtStart)));
459     }
460 
461     @Test(expected = UnsupportedOperationException.class)
462     public void argsNotModifiable() throws Throwable {
463         final LoggingEvent event = new LoggingEvent(level, message, arg1);
464         event.getArguments().add(arg2);
465     }
466 
467     @Test
468     public void timestamp() {
469         LoggingEvent event = info("Message");
470         assertThat(event.getTimestamp(), is(alwaysStartOfEpoch.getInstant()));
471     }
472 
473     @Test(expected = IllegalStateException.class)
474     public void creatingLoggerNotPresent() {
475         info("message").getCreatingLogger();
476     }
477 
478     @Test
479     public void creatingLoggerPresent() {
480         final TestLogger logger = TestLoggerFactory.getInstance().getLogger("logger");
481         logger.info("message");
482         final LoggingEvent event = logger.getLoggingEvents().get(0);
483         assertThat(event.getCreatingLogger(), is(logger));
484     }
485 
486     @Test
487     public void printToStandardOutNoThrowable() {
488         LoggingEvent event = new LoggingEvent(INFO, "message with {}", "argument");
489         event.print();
490 
491         assertThat(systemOutputRule.getSystemOut(),
492                 is("1970-01-01T00:00:00.000Z ["+Thread.currentThread().getName()+"] INFO - message with argument"+lineSeparator()));
493     }
494 
495     @Test
496     public void printToStandardOutWithThrowable() {
497         LoggingEvent event = new LoggingEvent(INFO, new Exception(), "message");
498         event.print();
499 
500         assertThat(systemOutputRule.getSystemOut(),
501                 startsWith("1970-01-01T00:00:00.000Z ["+Thread.currentThread().getName()+"] INFO - message"+lineSeparator()
502                         + "java.lang.Exception"+lineSeparator()
503                         + "\tat"
504                 ));
505     }
506 
507     @Test
508     @Parameters({"TRACE", "DEBUG", "INFO"})
509     public void printInfoAndBelow(Level level) {
510         LoggingEvent event = new LoggingEvent(level, "message with {}", "argument");
511         event.print();
512         assertThat(systemOutputRule.getSystemOut(), is(not("")));
513         assertThat(systemOutputRule.getSystemErr(), is(""));
514     }
515 
516     @Test
517     @Parameters({"WARN", "ERROR"})
518     public void printWarnAndAbove(Level level) {
519         LoggingEvent event = new LoggingEvent(level, "message with {}", "argument");
520         event.print();
521         assertThat(systemOutputRule.getSystemErr(), is(not("")));
522         assertThat(systemOutputRule.getSystemOut(), is(""));
523     }
524 
525     @Test
526     public void nullArgument() {
527         LoggingEvent event = new LoggingEvent(level, "message with null arg", null, null);
528         assertThat(event, is(new LoggingEvent(level, "message with null arg", absent(), absent())));
529     }
530 
531     @After
532     public void reset() {
533         TestLoggerFactory.reset();
534     }
535 
536     @SuppressWarnings("unchecked")
537     private Matcher<Optional<?>> isAbsent() {
538         final Matcher optionalMatcher = is(Optional.absent());
539         return (Matcher<Optional<?>>) optionalMatcher;
540     }
541 }