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 }