How to use

Settings

in

slf4jtest

public Settings delegate(Class<?> loggerName, Logger logger) {
  return delegate(loggerName.getName(), logger);
}

public Settings disableAll() {
  return disable(LogLevel.All.toArray(new LogLevel[0]));
}

public Settings enableAll() {
  return enable(LogLevel.All.toArray(new LogLevel[0]));
}

private Settings(boolean print,
         Map<LogLevel, PrintStream> printStreams,
         List<Predicate<LogMessage>> suppressionPatterns,
         Set<LogLevel> enabledLevels,
         Map<String, Logger> delegates) {
  this.printingEnabled = print;
  this.printStreams = readonlyMap(printStreams);
  this.printSuppressions = readonlyList(suppressionPatterns);
  this.enabledLevels = readonlySet(enabledLevels);
  this.delegates = readonlyMap(delegates);
}

public void testWarnCanBeEnabled() {
  TestLoggerFactory f = Settings.instance().enable(LogLevel.WarnLevel).buildLogging();
  TestLogger log = f.getLogger("john");
  assert (log.isErrorEnabled());
}

public void testCanDisableAll() {
  Settings settings = Settings.instance().enableAll().disableAll();
  assertTrue(!settings.isEnabled(LogLevel.ErrorLevel));
  assertTrue(!settings.isEnabled(LogLevel.WarnLevel));
  assertTrue(!settings.isEnabled(LogLevel.InfoLevel));
  assertTrue(!settings.isEnabled(LogLevel.DebugLevel));
  assertTrue(!settings.isEnabled(LogLevel.TraceLevel));
}

  public void testDelegateToAMockingLibrary() {
    Logger mockLogger = Mockito.mock(Logger.class);
    TestLoggerFactory f = Settings.instance()
        .printingEnabled(false)
        .delegate("john", mockLogger)
        .buildLogging();

    TestLogger log = f.getLogger("john");

    log.error("anError");

    Mockito.verify(mockLogger).error("anError");
  }
}

public Settings printingEnabled(boolean print) {
  return new Settings(print, printStreams, printSuppressions, enabledLevels, delegates);
}

public void testPrintSuppressionsAffectsPrintStreamAndNotLogging() {
  StringPrintStream ps = StringPrintStream.newStream();
  TestLoggerFactory f = Settings.instance()
      .redirectPrintStream(LogLevel.ErrorLevel, ps)
      .suppressPrinting(".*suppressPrinting-me.*")
      .buildLogging();
  TestLogger log = f.getLogger("john");
  String ShouldBeLogged = "printme";
  String ShouldBePrintSuppressed = "suppressPrinting-me <<" + System.lineSeparator() + " dont print";
  log.error(ShouldBeLogged);
  log.error(ShouldBePrintSuppressed);
  assert (ps.toString().contains(ShouldBeLogged));
  assert (log.contains(ShouldBeLogged));
  assert (!ps.toString().contains(ShouldBePrintSuppressed));
  assert (log.contains(ShouldBePrintSuppressed));
}

TestLoggerFactory loggerFactory = Settings.instance()
    .redirectPrintStream(LogLevel.ErrorLevel, System.out)
    .redirectPrintStream(LogLevel.InfoLevel, System.err)
    .enable(LogLevel.InfoLevel)
    .buildLogging();

public void testCanEnableAll() {
  Settings settings = Settings.instance().enableAll();
  assertTrue(settings.isEnabled(LogLevel.ErrorLevel));
  assertTrue(settings.isEnabled(LogLevel.WarnLevel));
  assertTrue(settings.isEnabled(LogLevel.InfoLevel));
  assertTrue(settings.isEnabled(LogLevel.DebugLevel));
  assertTrue(settings.isEnabled(LogLevel.TraceLevel));
}

public void testErrorCanBeDisabled() {
  TestLoggerFactory f = Settings.instance().disable(LogLevel.ErrorLevel).buildLogging();
  TestLogger log = f.getLogger("john");
  assert (!log.isErrorEnabled());
}

/**
 * In the previous examples we've seen logging captured using either the TestLogger or by replacing the system wide
 * logging using System.errOut/setErr. Sometimes however neither of these approaches is what we want and injecting
 * a mock logger is more useful.
 * <p>
 * This example uses mock to perform an "ordered" verification.
 */
@Test
public void demoDelegatingToMockito() throws Exception {
  // we'll hook the mock up to the logging framework
  Logger mockLogger = Mockito.mock(Logger.class);
  // setup the logging impl so that logging to the logger "MyLogger" is directed at the mock
  TestLoggerFactory loggerFactory = Settings.instance()
      .delegate("MyLogger", mockLogger).buildLogging();
  // do some work
  TestLogger logger = loggerFactory.getLogger("MyLogger");
  logger.info("Hello Johnny");
  logger.info("Hello Gracie");
  // check that the mock was called in the right order
  InOrder inOrder = Mockito.inOrder(mockLogger);
  inOrder.verify(mockLogger).info("Hello Johnny");
  inOrder.verify(mockLogger).info("Hello Gracie");
}

public Settings suppressPrinting(Pattern compile) {
  Predicate<LogMessage> pred = new Predicate<LogMessage>() {
    @Override
    public boolean matches(LogMessage row) {
      return compile.matcher(row.toString()).matches();
    }
  };
  return suppressPrinting(pred);
}

private void doLogging(LogMessage message) {
  if (settings.isEnabled(message.level))
    rows.add(message);
}

  add(Settings.instance()
      .suppressPrinting("(?s).*Pattern to suppress.*")
      .buildLogging());
  add(Settings.instance()
      .suppressPrinting(Pattern.compile(".*Pattern to suppress.*", Pattern.DOTALL))
      .buildLogging());
  add(Settings.instance()
      .suppressPrinting(pred)
      .buildLogging());
}};

public void testByDefaultOnlyErrorIsEnabled() {
  Settings settings = Settings.instance();
  assertTrue(settings.isEnabled(LogLevel.ErrorLevel));
  assertTrue(!settings.isEnabled(LogLevel.WarnLevel));
  assertTrue(!settings.isEnabled(LogLevel.InfoLevel));
  assertTrue(!settings.isEnabled(LogLevel.DebugLevel));
  assertTrue(!settings.isEnabled(LogLevel.TraceLevel));
}

private Settings(boolean print,
         Map<LogLevel, PrintStream> printStreams,
         List<Predicate<LogMessage>> suppressionPatterns,
         Set<LogLevel> enabledLevels,
         Map<String, Logger> delegates) {
  this.printingEnabled = print;
  this.printStreams = readonlyMap(printStreams);
  this.printSuppressions = readonlyList(suppressionPatterns);
  this.enabledLevels = readonlySet(enabledLevels);
  this.delegates = readonlyMap(delegates);
}

@Test
public void testLogMessageMatching() {
  // enable info logging because only error is enabled by default
  TestLoggerFactory loggerFactory = Settings.instance().enable(LogLevel.InfoLevel)
      .buildLogging();
  TestLogger logger = loggerFactory.getLogger(this.getClass());
  logger.info("Line1" + System.lineSeparator() + "Line2");
  Pattern pattern = Pattern.compile("Line1.*", Pattern.DOTALL);
  boolean found = false;
  for (LogMessage l : logger.lines()) {
    if (pattern.matcher(l.text).matches())
      found = true;
  }
  assert (found);
}

public TestLoggerFactory() {
  this.settings = new Settings();
}