Tests for building appenders

Author: Alex Wenckus

pom.xml

@@ -39,8 +39,8 @@
 
     <java.version>1.8</java.version>
 
+    <awaitility.version>2.0.0</awaitility.version>
     <dropwizard.version>1.0.2</dropwizard.version>
-    <immutables.version>2.3.9</immutables.version>
     <logstash-logback-encoder.version>4.8</logstash-logback-encoder.version>
   </properties>
 
@@ -95,5 +95,17 @@
       <artifactId>logstash-logback-encoder</artifactId>
       <version>${logstash-logback-encoder.version}</version>
     </dependency>
+
+    <dependency>
+      <groupId>io.dropwizard</groupId>
+      <artifactId>dropwizard-testing</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.awaitility</groupId>
+      <artifactId>awaitility</artifactId>
+      <version>${awaitility.version}</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 </project>

src/main/java/io/dropwizard/bundles/jsonlog/JsonRequestLogFactory.java

@@ -20,15 +20,15 @@
 import net.logstash.logback.encoder.LogstashAccessEncoder;
 import net.logstash.logback.fieldnames.LogstashAccessFieldNames;
 import org.eclipse.jetty.server.RequestLog;
-import org.hibernate.validator.constraints.NotEmpty;
+import org.hibernate.validator.constraints.NotBlank;
 import org.slf4j.LoggerFactory;
 
 /**
  * Creates a Logback access request logger which will log access requests as JSON messages.
  */
 @SuppressWarnings("WeakerAccess")
 @JsonTypeName("json-logback-access")
-public abstract class JsonRequestLogFactory
+public class JsonRequestLogFactory
     extends AbstractAppenderFactory<IAccessEvent>
     implements RequestLogFactory<RequestLog> {
 
@@ -111,7 +111,7 @@ public static class Fields {
     private String statusCode = "response";
     private String hostname = null;
     private String requestedUrl = null;
-    @NotEmpty
+    @NotBlank
     private String message = "message";
 
     @JsonProperty

src/test/java/io/dropwizard/bundles/jsonlog/JsonConsoleAppenderFactoryTest.java

@@ -0,0 +1,28 @@
+package io.dropwizard.bundles.jsonlog;
+
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.Appender;
+import io.dropwizard.logging.LoggingUtil;
+import io.dropwizard.logging.async.AsyncLoggingEventAppenderFactory;
+import io.dropwizard.logging.filter.ThresholdLevelFilterFactory;
+import io.dropwizard.logging.layout.DropwizardLayoutFactory;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+
+/**
+ *
+ */
+public class JsonConsoleAppenderFactoryTest {
+
+  @Test
+  public void build() throws Exception {
+    final JsonConsoleAppenderFactory factory = new JsonConsoleAppenderFactory();
+
+    final Appender<ILoggingEvent> appender = factory.build(LoggingUtil.getLoggerContext(), "app",
+        new DropwizardLayoutFactory(), new ThresholdLevelFilterFactory(),
+        new AsyncLoggingEventAppenderFactory());
+    assertNotNull(appender);
+  }
+
+}

src/test/java/io/dropwizard/bundles/jsonlog/JsonRequestLogFactoryTest.java

@@ -0,0 +1,73 @@
+package io.dropwizard.bundles.jsonlog;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableList;
+import io.dropwizard.bundles.jsonlog.test.ConsoleInterceptor;
+import io.dropwizard.jackson.Jackson;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import org.eclipse.jetty.http.HttpFields;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.RequestLog;
+import org.eclipse.jetty.server.Response;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.awaitility.Awaitility.await;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ *
+ */
+public class JsonRequestLogFactoryTest {
+
+  private static final ObjectMapper OBJECT_MAPPER = Jackson.newObjectMapper();
+
+  @Rule
+  public ConsoleInterceptor interceptor = new ConsoleInterceptor();
+
+  @Test
+  public void build() throws Exception {
+    final JsonRequestLogFactory logFactory = new JsonRequestLogFactory();
+
+    final RequestLog requestLog = logFactory.build("test");
+    assertNotNull(requestLog);
+
+    final String expectedVerb = "GET";
+    final String requestUri = "/test";
+    final String expectedProtocol = "HTTP/1.1";
+    final int expectedStatus = 419;
+
+    final Request request = mock(Request.class);
+    when(request.getRequestURI()).thenReturn(requestUri);
+    when(request.getMethod()).thenReturn(expectedVerb);
+    when(request.getProtocol()).thenReturn(expectedProtocol);
+    when(request.getAttributeNames()).thenReturn(Collections.enumeration(ImmutableList.of()));
+    final Response response = mock(Response.class);
+    when(response.getHttpFields()).thenReturn(new HttpFields());
+    when(response.getStatus()).thenReturn(expectedStatus);
+
+    requestLog.log(request, response);
+
+    await().atMost(5, TimeUnit.SECONDS).until(interceptor.contains(s -> s.contains(requestUri)));
+
+    final Optional<String> opt = interceptor.getLogs().stream()
+        .filter(s -> s.contains(requestUri)).findFirst();
+
+    assertTrue(opt.isPresent());
+    final Map<String, String> accessMap = OBJECT_MAPPER.readValue(opt.get(),
+        new TypeReference<Map<String, String>>() {});
+
+    assertEquals(expectedVerb, accessMap.get("verb"));
+    assertEquals(requestUri, accessMap.get("request"));
+    assertEquals(expectedProtocol, accessMap.get("protocol"));
+    assertEquals(expectedStatus, Integer.parseInt(accessMap.get("response")));
+  }
+}

src/test/java/io/dropwizard/bundles/jsonlog/test/ConsoleInterceptor.java

@@ -0,0 +1,45 @@
+package io.dropwizard.bundles.jsonlog.test;
+
+import java.io.IOException;
+import java.io.PrintStream;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.Predicate;
+import org.junit.rules.ExternalResource;
+
+public class ConsoleInterceptor extends ExternalResource {
+  private List<String> logs = new CopyOnWriteArrayList<>();
+
+  @Override
+  protected void before() throws Throwable {
+    System.setOut(new PrintStream(System.out) {
+      @Override
+      public void write(byte[] b) throws IOException {
+        logs.add(new String(b));
+        super.write(b);
+      }
+
+      @Override
+      public void write(byte[] buf, int off, int len) {
+        logs.add(new String(buf, off, len));
+
+        super.write(buf, off, len);
+      }
+    });
+  }
+
+  public Callable<Boolean> contains(Predicate<String> test) {
+    return () -> logs.stream().anyMatch(test);
+  }
+
+  public List<String> getLogs() {
+    return Collections.unmodifiableList(logs);
+  }
+
+  @Override
+  protected void after() {
+    System.setOut(null);
+  }
+}