From 371ff8163a3f0c2912c8974e1e57b6cd39f09156 Mon Sep 17 00:00:00 2001
From: gjoranv
Date: Thu, 18 Mar 2021 20:10:52 +0100
Subject: Add test java source files from jdisc_http_service.
---
.../logging/CircularArrayAccessLogKeeperTest.java | 42 +
.../yahoo/container/logging/JSONLogTestCase.java | 295 +++++
.../logging/JsonConnectionLogWriterTest.java | 44 +
.../container/logging/LogFileHandlerTestCase.java | 208 ++++
.../logging/test/LogFormatterTestCase.java | 27 +
.../java/com/yahoo/jdisc/http/CookieTestCase.java | 238 ++++
.../com/yahoo/jdisc/http/HttpHeadersTestCase.java | 17 +
.../com/yahoo/jdisc/http/HttpRequestTestCase.java | 206 ++++
.../com/yahoo/jdisc/http/HttpResponseTestCase.java | 139 +++
.../jdisc/http/filter/DiscFilterRequestTest.java | 357 ++++++
.../jdisc/http/filter/DiscFilterResponseTest.java | 113 ++
.../http/filter/EmptyRequestFilterTestCase.java | 48 +
.../http/filter/EmptyResponseFilterTestCase.java | 45 +
.../jdisc/http/filter/JDiscCookieWrapperTest.java | 29 +
.../jdisc/http/filter/RequestViewImplTest.java | 57 +
.../jdisc/http/filter/ResponseHeaderFilter.java | 25 +
.../filter/SecurityRequestFilterChainTest.java | 145 +++
.../filter/SecurityResponseFilterChainTest.java | 74 ++
.../http/filter/ServletFilterRequestTest.java | 179 +++
.../http/filter/ServletFilterResponseTest.java | 87 ++
.../ConnectorFactoryRegistryModule.java | 54 +
.../jdisc/http/guiceModules/ServletModule.java | 24 +
.../http/server/jetty/AccessLogRequestLogTest.java | 156 +++
.../http/server/jetty/BlockingQueueRequestLog.java | 24 +
.../http/server/jetty/ConnectionThrottlerTest.java | 78 ++
.../http/server/jetty/ConnectorFactoryTest.java | 83 ++
.../jetty/ErrorResponseContentCreatorTest.java | 44 +
.../http/server/jetty/ExceptionWrapperTest.java | 51 +
.../jdisc/http/server/jetty/FilterTestCase.java | 667 +++++++++++
.../http/server/jetty/HttpRequestFactoryTest.java | 204 ++++
.../jetty/HttpResponseStatisticsCollectorTest.java | 221 ++++
.../server/jetty/HttpServerConformanceTest.java | 847 ++++++++++++++
.../jdisc/http/server/jetty/HttpServerTest.java | 1201 ++++++++++++++++++++
.../http/server/jetty/InMemoryConnectionLog.java | 25 +
.../http/server/jetty/InMemoryRequestLog.java | 20 +
.../http/server/jetty/JDiscHttpServletTest.java | 80 ++
.../http/server/jetty/MetricConsumerMock.java | 28 +
.../jdisc/http/server/jetty/SimpleHttpClient.java | 202 ++++
.../jetty/SslHandshakeFailedListenerTest.java | 42 +
.../yahoo/jdisc/http/server/jetty/TestDriver.java | 79 ++
.../yahoo/jdisc/http/server/jetty/TestDrivers.java | 94 ++
.../jetty/servlet/JDiscFilterForServletTest.java | 166 +++
.../jetty/servlet/ServletAccessLoggingTest.java | 64 ++
.../http/server/jetty/servlet/ServletTestBase.java | 132 +++
.../http/ssl/impl/TlsContextBasedProviderTest.java | 71 ++
45 files changed, 7032 insertions(+)
create mode 100644 container-core/src/test/java/com/yahoo/container/logging/CircularArrayAccessLogKeeperTest.java
create mode 100644 container-core/src/test/java/com/yahoo/container/logging/JSONLogTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/container/logging/JsonConnectionLogWriterTest.java
create mode 100644 container-core/src/test/java/com/yahoo/container/logging/LogFileHandlerTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/container/logging/test/LogFormatterTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/CookieTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/HttpHeadersTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/HttpRequestTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/HttpResponseTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/DiscFilterRequestTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/DiscFilterResponseTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/EmptyRequestFilterTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/EmptyResponseFilterTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/JDiscCookieWrapperTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/RequestViewImplTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/ResponseHeaderFilter.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/SecurityRequestFilterChainTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/SecurityResponseFilterChainTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/ServletFilterRequestTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/filter/ServletFilterResponseTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/guiceModules/ConnectorFactoryRegistryModule.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/guiceModules/ServletModule.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/AccessLogRequestLogTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/BlockingQueueRequestLog.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ConnectionThrottlerTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ConnectorFactoryTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ErrorResponseContentCreatorTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ExceptionWrapperTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/FilterTestCase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpRequestFactoryTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollectorTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpServerConformanceTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpServerTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/InMemoryConnectionLog.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/InMemoryRequestLog.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/JDiscHttpServletTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/MetricConsumerMock.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/SimpleHttpClient.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/SslHandshakeFailedListenerTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/TestDriver.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/TestDrivers.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/servlet/JDiscFilterForServletTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/servlet/ServletAccessLoggingTest.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/servlet/ServletTestBase.java
create mode 100644 container-core/src/test/java/com/yahoo/jdisc/http/ssl/impl/TlsContextBasedProviderTest.java
diff --git a/container-core/src/test/java/com/yahoo/container/logging/CircularArrayAccessLogKeeperTest.java b/container-core/src/test/java/com/yahoo/container/logging/CircularArrayAccessLogKeeperTest.java
new file mode 100644
index 00000000000..5d9509eb045
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/container/logging/CircularArrayAccessLogKeeperTest.java
@@ -0,0 +1,42 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.container.logging;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsCollectionContaining.hasItem;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+
+public class CircularArrayAccessLogKeeperTest {
+ private CircularArrayAccessLogKeeper circularArrayAccessLogKeeper = new CircularArrayAccessLogKeeper();
+
+ @Test
+ public void testSizeIsCroppedCorrectly() {
+ for (int i = 0; i < CircularArrayAccessLogKeeper.SIZE - 1; i++) {
+ circularArrayAccessLogKeeper.addUri(String.valueOf(i));
+ }
+ assertThat(circularArrayAccessLogKeeper.getUris().size(), is(CircularArrayAccessLogKeeper.SIZE -1));
+ circularArrayAccessLogKeeper.addUri("foo");
+ assertThat(circularArrayAccessLogKeeper.getUris().size(), is(CircularArrayAccessLogKeeper.SIZE));
+ circularArrayAccessLogKeeper.addUri("bar");
+ assertThat(circularArrayAccessLogKeeper.getUris().size(), is(CircularArrayAccessLogKeeper.SIZE));
+ assertThat(circularArrayAccessLogKeeper.getUris(), hasItems("1", "2", "3", "foo", "bar"));
+ assertThat(circularArrayAccessLogKeeper.getUris(), not(hasItem("0")));
+ }
+
+ @Test
+ public void testEmpty() {
+ assertThat(circularArrayAccessLogKeeper.getUris().size(), is(0));
+ }
+
+ @Test
+ public void testSomeItems() {
+ circularArrayAccessLogKeeper.addUri("a");
+ circularArrayAccessLogKeeper.addUri("b");
+ circularArrayAccessLogKeeper.addUri("b");
+ assertThat(circularArrayAccessLogKeeper.getUris(), contains("a", "b", "b"));
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/container/logging/JSONLogTestCase.java b/container-core/src/test/java/com/yahoo/container/logging/JSONLogTestCase.java
new file mode 100644
index 00000000000..cb3d1d0a12f
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/container/logging/JSONLogTestCase.java
@@ -0,0 +1,295 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.container.logging;
+
+import com.yahoo.yolean.trace.TraceNode;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.time.Duration;
+import java.time.Instant;
+
+import static com.yahoo.test.json.JsonTestHelper.assertJsonEquals;
+
+
+/**
+ * @author frodelu
+ */
+public class JSONLogTestCase {
+
+ private static String ipAddress = "152.200.54.243";
+
+ private RequestLogEntry.Builder newRequestLogEntry(final String query) {
+ return newRequestLogEntry(query, new Coverage(100,100,100,0));
+ }
+ private RequestLogEntry.Builder newRequestLogEntry(final String query, Coverage coverage) {
+ return new RequestLogEntry.Builder()
+ .rawQuery("query=" + query)
+ .rawPath("")
+ .peerAddress(ipAddress)
+ .httpMethod("GET")
+ .httpVersion("HTTP/1.1")
+ .userAgent("Mozilla/4.05 [en] (Win95; I)")
+ .hitCounts(new HitCounts(0, 10, 1234, 0, 10, coverage))
+ .hostString("localhost")
+ .statusCode(200)
+ .timestamp(Instant.ofEpochMilli(920880005023L))
+ .duration(Duration.ofMillis(122))
+ .contentSize(9875)
+ .localPort(0)
+ .peerPort(0);
+ }
+
+ @Test
+ public void test_json_log_entry() {
+ RequestLogEntry entry = newRequestLogEntry("test").build();
+
+ String expectedOutput =
+ "{\"ip\":\"152.200.54.243\"," +
+ "\"peeraddr\":\"152.200.54.243\"," +
+ "\"time\":920880005.023," +
+ "\"duration\":0.122," +
+ "\"responsesize\":9875," +
+ "\"code\":200," +
+ "\"method\":\"GET\"," +
+ "\"uri\":\"?query=test\"," +
+ "\"version\":\"HTTP/1.1\"," +
+ "\"agent\":\"Mozilla/4.05 [en] (Win95; I)\"," +
+ "\"host\":\"localhost\"," +
+ "\"scheme\":null," +
+ "\"localport\":0," +
+ "\"search\":{" +
+ "\"totalhits\":1234," +
+ "\"hits\":0," +
+ "\"coverage\":{\"coverage\":100,\"documents\":100}" +
+ "}" +
+ "}";
+
+ assertJsonEquals(formatEntry(entry), expectedOutput);
+ }
+ @Test
+ public void test_json_of_trace() {
+ TraceNode root = new TraceNode("root", 7);
+ RequestLogEntry entry = newRequestLogEntry("test")
+ .traceNode(root)
+ .build();
+
+ String expectedOutput =
+ "{\"ip\":\"152.200.54.243\"," +
+ "\"peeraddr\":\"152.200.54.243\"," +
+ "\"time\":920880005.023," +
+ "\"duration\":0.122," +
+ "\"responsesize\":9875," +
+ "\"code\":200," +
+ "\"method\":\"GET\"," +
+ "\"uri\":\"?query=test\"," +
+ "\"version\":\"HTTP/1.1\"," +
+ "\"agent\":\"Mozilla/4.05 [en] (Win95; I)\"," +
+ "\"host\":\"localhost\"," +
+ "\"scheme\":null," +
+ "\"localport\":0," +
+ "\"trace\":{\"timestamp\":0,\"message\":\"root\"}," +
+ "\"search\":{" +
+ "\"totalhits\":1234," +
+ "\"hits\":0," +
+ "\"coverage\":{\"coverage\":100,\"documents\":100}" +
+ "}" +
+ "}";
+
+ assertJsonEquals(formatEntry(entry), expectedOutput);
+ }
+ @Test
+ public void test_with_keyvalues() {
+ RequestLogEntry entry = newRequestLogEntry("test")
+ .addExtraAttribute("singlevalue", "value1")
+ .addExtraAttribute("multivalue", "value2")
+ .addExtraAttribute("multivalue", "value3")
+ .build();
+
+ String expectedOutput =
+ "{\"ip\":\"152.200.54.243\"," +
+ "\"peeraddr\":\"152.200.54.243\"," +
+ "\"time\":920880005.023," +
+ "\"duration\":0.122," +
+ "\"responsesize\":9875," +
+ "\"code\":200," +
+ "\"method\":\"GET\"," +
+ "\"uri\":\"?query=test\"," +
+ "\"version\":\"HTTP/1.1\"," +
+ "\"agent\":\"Mozilla/4.05 [en] (Win95; I)\"," +
+ "\"host\":\"localhost\"," +
+ "\"scheme\":null," +
+ "\"localport\":0," +
+ "\"search\":{" +
+ "\"totalhits\":1234," +
+ "\"hits\":0," +
+ "\"coverage\":{\"coverage\":100,\"documents\":100}" +
+ "}," +
+ "\"attributes\":{" +
+ "\"singlevalue\":\"value1\"," +
+ "\"multivalue\":[\"value2\",\"value3\"]}" +
+ "}";
+
+ assertJsonEquals(formatEntry(entry), expectedOutput);
+
+ }
+
+ @Test
+ public void test_with_remoteaddrport() throws Exception {
+ RequestLogEntry entry = newRequestLogEntry("test")
+ .remoteAddress("FE80:0000:0000:0000:0202:B3FF:FE1E:8329")
+ .build();
+
+ String expectedOutput =
+ "{\"ip\":\"152.200.54.243\"," +
+ "\"peeraddr\":\"152.200.54.243\"," +
+ "\"time\":920880005.023," +
+ "\"duration\":0.122," +
+ "\"responsesize\":9875," +
+ "\"code\":200," +
+ "\"method\":\"GET\"," +
+ "\"uri\":\"?query=test\"," +
+ "\"version\":\"HTTP/1.1\"," +
+ "\"agent\":\"Mozilla/4.05 [en] (Win95; I)\"," +
+ "\"host\":\"localhost\"," +
+ "\"scheme\":null," +
+ "\"localport\":0," +
+ "\"remoteaddr\":\"FE80:0000:0000:0000:0202:B3FF:FE1E:8329\"," +
+ "\"search\":{" +
+ "\"totalhits\":1234," +
+ "\"hits\":0," +
+ "\"coverage\":{\"coverage\":100,\"documents\":100}" +
+ "}" +
+ "}";
+
+ assertJsonEquals(formatEntry(entry), expectedOutput);
+
+ // Add remote port and verify
+ entry = newRequestLogEntry("test")
+ .remoteAddress("FE80:0000:0000:0000:0202:B3FF:FE1E:8329")
+ .remotePort(1234)
+ .build();
+
+ expectedOutput =
+ "{\"ip\":\"152.200.54.243\"," +
+ "\"peeraddr\":\"152.200.54.243\"," +
+ "\"time\":920880005.023," +
+ "\"duration\":0.122," +
+ "\"responsesize\":9875," +
+ "\"code\":200," +
+ "\"method\":\"GET\"," +
+ "\"uri\":\"?query=test\"," +
+ "\"version\":\"HTTP/1.1\"," +
+ "\"agent\":\"Mozilla/4.05 [en] (Win95; I)\"," +
+ "\"host\":\"localhost\"," +
+ "\"scheme\":null," +
+ "\"localport\":0," +
+ "\"remoteaddr\":\"FE80:0000:0000:0000:0202:B3FF:FE1E:8329\"," +
+ "\"remoteport\":1234," +
+ "\"search\":{" +
+ "\"totalhits\":1234," +
+ "\"hits\":0," +
+ "\"coverage\":{\"coverage\":100,\"documents\":100}" +
+ "}" +
+ "}";
+
+ assertJsonEquals(formatEntry(entry), expectedOutput);
+ }
+
+ @Test
+ public void test_remote_address_same_as_ip_address() throws Exception {
+ RequestLogEntry entry = newRequestLogEntry("test").build();
+ RequestLogEntry entrywithremote = newRequestLogEntry("test")
+ .remoteAddress(entry.peerAddress().get())
+ .build();
+ JSONFormatter formatter = new JSONFormatter();
+ assertJsonEquals(formatEntry(entry), formatEntry(entrywithremote));
+ }
+
+ @Test
+ public void test_useragent_with_quotes() {
+ RequestLogEntry entry = new RequestLogEntry.Builder()
+ .rawQuery("query=test")
+ .rawPath("")
+ .peerAddress(ipAddress)
+ .httpMethod("GET")
+ .httpVersion("HTTP/1.1")
+ .userAgent("Mozilla/4.05 [en] (Win95; I; \"Best Browser Ever\")")
+ .hitCounts(new HitCounts(0, 10, 1234, 0, 10, new Coverage(100, 200, 200, 0)))
+ .hostString("localhost")
+ .statusCode(200)
+ .timestamp(Instant.ofEpochMilli(920880005023L))
+ .duration(Duration.ofMillis(122))
+ .contentSize(9875)
+ .localPort(0)
+ .peerPort(0)
+ .build();
+
+ String expectedOutput =
+ "{\"ip\":\"152.200.54.243\"," +
+ "\"peeraddr\":\"152.200.54.243\"," +
+ "\"time\":920880005.023," +
+ "\"duration\":0.122," +
+ "\"responsesize\":9875," +
+ "\"code\":200," +
+ "\"method\":\"GET\"," +
+ "\"uri\":\"?query=test\"," +
+ "\"version\":\"HTTP/1.1\"," +
+ "\"agent\":\"Mozilla/4.05 [en] (Win95; I; \\\"Best Browser Ever\\\")\"," +
+ "\"host\":\"localhost\"," +
+ "\"scheme\":null," +
+ "\"localport\":0," +
+ "\"search\":{" +
+ "\"totalhits\":1234," +
+ "\"hits\":0," +
+ "\"coverage\":{\"coverage\":50,\"documents\":100,\"degraded\":{\"non-ideal-state\":true}}" +
+ "}" +
+ "}";
+
+ assertJsonEquals(formatEntry(entry), expectedOutput);
+ }
+
+ private void verifyCoverage(String coverage, RequestLogEntry entry) {
+ assertJsonEquals(formatEntry(entry),
+ "{\"ip\":\"152.200.54.243\"," +
+ "\"peeraddr\":\"152.200.54.243\"," +
+ "\"time\":920880005.023," +
+ "\"duration\":0.122," +
+ "\"responsesize\":9875," +
+ "\"code\":200," +
+ "\"method\":\"GET\"," +
+ "\"uri\":\"?query=test\"," +
+ "\"version\":\"HTTP/1.1\"," +
+ "\"agent\":\"Mozilla/4.05 [en] (Win95; I)\"," +
+ "\"host\":\"localhost\"," +
+ "\"scheme\":null," +
+ "\"localport\":0," +
+ "\"search\":{" +
+ "\"totalhits\":1234," +
+ "\"hits\":0," +
+ coverage +
+ "}" +
+ "}");
+ }
+
+ @Test
+ public void test_with_coverage_degradation() {
+ verifyCoverage("\"coverage\":{\"coverage\":50,\"documents\":100,\"degraded\":{\"non-ideal-state\":true}}",
+ newRequestLogEntry("test", new Coverage(100,200,200,0)).build());
+ verifyCoverage("\"coverage\":{\"coverage\":50,\"documents\":100,\"degraded\":{\"match-phase\":true}}",
+ newRequestLogEntry("test", new Coverage(100,200,200,1)).build());
+ verifyCoverage("\"coverage\":{\"coverage\":50,\"documents\":100,\"degraded\":{\"timeout\":true}}",
+ newRequestLogEntry("test", new Coverage(100,200,200,2)).build());
+ verifyCoverage("\"coverage\":{\"coverage\":50,\"documents\":100,\"degraded\":{\"adaptive-timeout\":true}}",
+ newRequestLogEntry("test", new Coverage(100,200,200,4)).build());
+ }
+
+ private String formatEntry(RequestLogEntry entry) {
+ try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
+ new JSONFormatter().write(entry, outputStream);
+ return outputStream.toString();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/container/logging/JsonConnectionLogWriterTest.java b/container-core/src/test/java/com/yahoo/container/logging/JsonConnectionLogWriterTest.java
new file mode 100644
index 00000000000..15118b23f85
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/container/logging/JsonConnectionLogWriterTest.java
@@ -0,0 +1,44 @@
+package com.yahoo.container.logging;// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+import com.yahoo.test.json.JsonTestHelper;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * @author bjorncs
+ */
+class JsonConnectionLogWriterTest {
+
+ @Test
+ void test_serialization() throws IOException {
+ var id = UUID.randomUUID();
+ var instant = Instant.parse("2021-01-13T12:12:12Z");
+ ConnectionLogEntry entry = ConnectionLogEntry.builder(id, instant)
+ .withPeerPort(1234)
+ .withSslHandshakeFailure(new ConnectionLogEntry.SslHandshakeFailure("UNKNOWN",
+ List.of(
+ new ConnectionLogEntry.SslHandshakeFailure.ExceptionEntry("javax.net.ssl.SSLHandshakeException", "message"),
+ new ConnectionLogEntry.SslHandshakeFailure.ExceptionEntry("java.io.IOException", "cause message"))))
+ .build();
+ String expectedJson = "{" +
+ "\"id\":\""+id.toString()+"\"," +
+ "\"timestamp\":\"2021-01-13T12:12:12Z\"," +
+ "\"peerPort\":1234," +
+ "\"ssl\":{\"handshake-failure\":{\"exception\":[" +
+ "{\"cause\":\"javax.net.ssl.SSLHandshakeException\",\"message\":\"message\"}," +
+ "{\"cause\":\"java.io.IOException\",\"message\":\"cause message\"}" +
+ "],\"type\":\"UNKNOWN\"}}}";
+
+ JsonConnectionLogWriter writer = new JsonConnectionLogWriter();
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ writer.write(entry, out);
+ String actualJson = out.toString(StandardCharsets.UTF_8);
+ JsonTestHelper.assertJsonEquals(actualJson, expectedJson);
+ }
+}
\ No newline at end of file
diff --git a/container-core/src/test/java/com/yahoo/container/logging/LogFileHandlerTestCase.java b/container-core/src/test/java/com/yahoo/container/logging/LogFileHandlerTestCase.java
new file mode 100644
index 00000000000..dad8f5e3f90
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/container/logging/LogFileHandlerTestCase.java
@@ -0,0 +1,208 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.container.logging;
+
+import com.yahoo.compress.ZstdCompressor;
+import com.yahoo.container.logging.LogFileHandler.Compression;
+import com.yahoo.io.IOUtils;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.function.BiFunction;
+import java.util.logging.Formatter;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.zip.GZIPInputStream;
+
+import static com.yahoo.yolean.Exceptions.uncheck;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNotEquals;
+
+/**
+ * @author Bob Travis
+ * @author bjorncs
+ */
+public class LogFileHandlerTestCase {
+
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+ @Test
+ public void testIt() throws IOException {
+ File root = temporaryFolder.newFolder("logfilehandlertest");
+
+ String pattern = root.getAbsolutePath() + "/logfilehandlertest.%Y%m%d%H%M%S";
+ long[] rTimes = {1000, 2000, 10000};
+ LogFileHandler h = new LogFileHandler<>(Compression.NONE, pattern, rTimes, null, 2048, "thread-name", new StringLogWriter());
+ long now = System.currentTimeMillis();
+ long millisPerDay = 60*60*24*1000;
+ long tomorrowDays = (now / millisPerDay) +1;
+ long tomorrowMillis = tomorrowDays * millisPerDay;
+
+ assertThat(tomorrowMillis+1000).isEqualTo(h.logThread.getNextRotationTime(tomorrowMillis));
+ assertThat(tomorrowMillis+10000).isEqualTo(h.logThread.getNextRotationTime(tomorrowMillis+3000));
+ String message = "test";
+ h.publish(message);
+ h.publish( "another test");
+ h.rotateNow();
+ h.publish(message);
+ h.flush();
+ h.shutdown();
+ }
+
+ @Test
+ public void testSimpleLogging() throws IOException {
+ File logFile = temporaryFolder.newFile("testLogFileG1.txt");
+
+ //create logfilehandler
+ LogFileHandler h = new LogFileHandler<>(Compression.NONE, logFile.getAbsolutePath(), "0 5 ...", null, 2048, "thread-name", new StringLogWriter());
+
+ //write log
+ h.publish("testDeleteFileFirst1");
+ h.flush();
+ h.shutdown();
+ }
+
+ @Test
+ public void testDeleteFileDuringLogging() throws IOException {
+ File logFile = temporaryFolder.newFile("testLogFileG2.txt");
+
+ //create logfilehandler
+ LogFileHandler h = new LogFileHandler<>(Compression.NONE, logFile.getAbsolutePath(), "0 5 ...", null, 2048, "thread-name", new StringLogWriter());
+
+ //write log
+ h.publish("testDeleteFileDuringLogging1");
+ h.flush();
+
+ //delete log file
+ logFile.delete();
+
+ //write log again
+ h.publish("testDeleteFileDuringLogging2");
+ h.flush();
+ h.shutdown();
+ }
+
+ @Test(timeout = /*5 minutes*/300_000)
+ public void testSymlink() throws IOException, InterruptedException {
+ File root = temporaryFolder.newFolder("testlogforsymlinkchecking");
+ Formatter formatter = new Formatter() {
+ public String format(LogRecord r) {
+ DateFormat df = new SimpleDateFormat("yyyy.MM.dd:HH:mm:ss.SSS");
+ String timeStamp = df.format(new Date(r.getMillis()));
+ return ("[" + timeStamp + "]" + " " + formatMessage(r));
+ }
+ };
+ LogFileHandler handler = new LogFileHandler<>(
+ Compression.NONE, root.getAbsolutePath() + "/logfilehandlertest.%Y%m%d%H%M%S%s", new long[]{0}, "symlink", 2048, "thread-name", new StringLogWriter());
+
+ String message = formatter.format(new LogRecord(Level.INFO, "test"));
+ handler.publishAndWait(message);
+ String firstFile = handler.getFileName();
+ handler.rotateNow();
+ String secondFileName = handler.getFileName();
+ assertNotEquals(firstFile, secondFileName);
+
+ String longMessage = formatter.format(new LogRecord(Level.INFO, "string which is way longer than the word test"));
+ handler.publish(longMessage);
+ handler.flush();
+ assertThat(Files.size(Paths.get(firstFile))).isEqualTo(31);
+ final long expectedSecondFileLength = 72;
+
+ long symlinkFileLength = Files.size(root.toPath().resolve("symlink"));
+ assertThat(symlinkFileLength).isEqualTo(expectedSecondFileLength);
+ handler.shutdown();
+ }
+
+ @Test(timeout = /*5 minutes*/300_000)
+ public void compresses_previous_log_file() throws InterruptedException, IOException {
+ File root = temporaryFolder.newFolder("compressespreviouslogfile");
+ LogFileHandler firstHandler = new LogFileHandler<>(
+ Compression.ZSTD, root.getAbsolutePath() + "/compressespreviouslogfile.%Y%m%d%H%M%S%s", new long[]{0}, "symlink", 2048, "thread-name", new StringLogWriter());
+ firstHandler.publishAndWait("test");
+ firstHandler.shutdown();
+
+ assertThat(Files.size(Paths.get(firstHandler.getFileName()))).isEqualTo(5);
+ assertThat(root.toPath().resolve("symlink").toRealPath().toString()).isEqualTo(firstHandler.getFileName());
+
+ LogFileHandler secondHandler = new LogFileHandler<>(
+ Compression.ZSTD, root.getAbsolutePath() + "/compressespreviouslogfile.%Y%m%d%H%M%S%s", new long[]{0}, "symlink", 2048, "thread-name", new StringLogWriter());
+ secondHandler.publishAndWait("test");
+ secondHandler.rotateNow();
+
+ assertThat(root.toPath().resolve("symlink").toRealPath().toString()).isEqualTo(secondHandler.getFileName());
+
+ while (Files.exists(root.toPath().resolve(firstHandler.getFileName()))) Thread.sleep(1);
+
+ assertThat(Files.exists(Paths.get(firstHandler.getFileName() + ".zst"))).isTrue();
+ secondHandler.shutdown();
+ }
+
+ @Test(timeout = /*5 minutes*/300_000)
+ public void testcompression_gzip() throws InterruptedException, IOException {
+ testcompression(
+ Compression.GZIP, "gz",
+ (compressedFile, __) -> uncheck(() -> new String(new GZIPInputStream(Files.newInputStream(compressedFile)).readAllBytes())));
+ }
+
+ @Test(timeout = /*5 minutes*/300_000)
+ public void testcompression_zstd() throws InterruptedException, IOException {
+ testcompression(
+ Compression.ZSTD, "zst",
+ (compressedFile, uncompressedSize) -> uncheck(() -> {
+ ZstdCompressor zstdCompressor = new ZstdCompressor();
+ byte[] uncompressedBytes = new byte[uncompressedSize];
+ byte[] compressedBytes = Files.readAllBytes(compressedFile);
+ zstdCompressor.decompress(compressedBytes, 0, compressedBytes.length, uncompressedBytes, 0, uncompressedBytes.length);
+ return new String(uncompressedBytes);
+ }));
+ }
+
+ private void testcompression(Compression compression,
+ String fileExtension,
+ BiFunction decompressor) throws IOException, InterruptedException {
+ File root = temporaryFolder.newFolder("testcompression" + compression.name());
+
+ LogFileHandler h = new LogFileHandler<>(
+ compression, root.getAbsolutePath() + "/logfilehandlertest.%Y%m%d%H%M%S%s", new long[]{0}, null, 2048, "thread-name", new StringLogWriter());
+ int logEntries = 10000;
+ for (int i = 0; i < logEntries; i++) {
+ h.publish("test");
+ }
+ h.flush();
+ String f1 = h.getFileName();
+ assertThat(f1).startsWith(root.getAbsolutePath() + "/logfilehandlertest.");
+ File uncompressed = new File(f1);
+ File compressed = new File(f1 + "." + fileExtension);
+ assertThat(uncompressed).exists();
+ assertThat(compressed).doesNotExist();
+ String content = IOUtils.readFile(uncompressed);
+ assertThat(content).hasLineCount(logEntries);
+ h.rotateNow();
+ while (uncompressed.exists()) {
+ Thread.sleep(1);
+ }
+ assertThat(compressed).exists();
+ String uncompressedContent = decompressor.apply(compressed.toPath(), content.getBytes().length);
+ assertThat(uncompressedContent).isEqualTo(content);
+ h.shutdown();
+ }
+
+ static class StringLogWriter implements LogWriter {
+
+ @Override
+ public void write(String record, OutputStream outputStream) throws IOException {
+ outputStream.write(record.getBytes(StandardCharsets.UTF_8));
+ }
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/container/logging/test/LogFormatterTestCase.java b/container-core/src/test/java/com/yahoo/container/logging/test/LogFormatterTestCase.java
new file mode 100644
index 00000000000..ecacf95d100
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/container/logging/test/LogFormatterTestCase.java
@@ -0,0 +1,27 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.container.logging.test;
+
+import com.yahoo.container.logging.LogFormatter;
+import org.junit.Test;
+
+import java.util.Date;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Bob Travis
+ */
+public class LogFormatterTestCase {
+
+ @Test
+ public void testIt() {
+ java.util.TimeZone.setDefault(java.util.TimeZone.getTimeZone("UTC"));
+ @SuppressWarnings("deprecation")
+ long time = new Date(103,7,25,13,30,35).getTime();
+ String result = LogFormatter.insertDate("test%Y%m%d%H%M%S%x",time);
+ assertEquals("test20030825133035Aug",result);
+ result = LogFormatter.insertDate("test%s%T",time);
+ assertEquals("test000"+time, result);
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/CookieTestCase.java b/container-core/src/test/java/com/yahoo/jdisc/http/CookieTestCase.java
new file mode 100644
index 00000000000..dbdce5c704e
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/CookieTestCase.java
@@ -0,0 +1,238 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http;
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Simon Thoresen Hult
+ * @author bjorncs
+ */
+public class CookieTestCase {
+
+ @Test
+ public void requireThatDefaultValuesAreSane() {
+ Cookie cookie = new Cookie("foo", "bar");
+ assertEquals("foo", cookie.getName());
+ assertEquals("bar", cookie.getValue());
+ assertEquals(null, cookie.getDomain());
+ assertEquals(Integer.MIN_VALUE, cookie.getMaxAge(TimeUnit.SECONDS));
+ assertEquals(null, cookie.getPath());
+ assertEquals(false, cookie.isHttpOnly());
+ assertEquals(false, cookie.isSecure());
+ }
+
+ @Test
+ public void requireThatAccessorsWork() {
+ final Cookie cookie = new Cookie();
+ cookie.setName("foo");
+ assertEquals("foo", cookie.getName());
+ cookie.setName("bar");
+ assertEquals("bar", cookie.getName());
+
+ cookie.setValue("foo");
+ assertEquals("foo", cookie.getValue());
+ cookie.setValue("bar");
+ assertEquals("bar", cookie.getValue());
+
+ cookie.setDomain("foo");
+ assertEquals("foo", cookie.getDomain());
+ cookie.setDomain("bar");
+ assertEquals("bar", cookie.getDomain());
+
+ cookie.setPath("foo");
+ assertEquals("foo", cookie.getPath());
+ cookie.setPath("bar");
+ assertEquals("bar", cookie.getPath());
+
+ cookie.setMaxAge(69, TimeUnit.DAYS);
+ assertEquals(69, cookie.getMaxAge(TimeUnit.DAYS));
+ assertEquals(TimeUnit.DAYS.toHours(69), cookie.getMaxAge(TimeUnit.HOURS));
+
+ cookie.setSecure(true);
+ assertTrue(cookie.isSecure());
+ cookie.setSecure(false);
+ assertFalse(cookie.isSecure());
+
+ cookie.setHttpOnly(true);
+ assertTrue(cookie.isHttpOnly());
+ cookie.setHttpOnly(false);
+ assertFalse(cookie.isHttpOnly());
+ }
+
+ @Test
+ public void requireThatCopyConstructorWorks() {
+ final Cookie lhs = newSetCookie("foo");
+ final Cookie rhs = new Cookie(lhs);
+ assertEquals(rhs.getName(), rhs.getName());
+ assertEquals(rhs.getValue(), rhs.getValue());
+ assertEquals(rhs.getDomain(), rhs.getDomain());
+ assertEquals(rhs.getPath(), rhs.getPath());
+ assertEquals(rhs.getMaxAge(TimeUnit.MILLISECONDS), rhs.getMaxAge(TimeUnit.MILLISECONDS));
+ assertEquals(rhs.isSecure(), rhs.isSecure());
+ assertEquals(rhs.isHttpOnly(), rhs.isHttpOnly());
+ }
+
+ @Test
+ public void requireThatHashCodeIsImplemented() {
+ final Cookie cookie = newCookie("foo");
+ assertFalse(cookie.hashCode() == new Cookie().hashCode());
+ assertEquals(cookie.hashCode(), cookie.hashCode());
+ assertEquals(cookie.hashCode(), new Cookie(cookie).hashCode());
+ }
+
+ @Test
+ public void requireThatEqualsIsImplemented() {
+ final Cookie cookie = newCookie("foo");
+ assertFalse(cookie.equals(new Cookie()));
+ assertEquals(cookie, cookie);
+ assertEquals(cookie, new Cookie(cookie));
+ }
+
+ @Test
+ public void requireThatCookieCanBeEncoded() {
+ assertEncodeCookie(
+ "foo.name=foo.value",
+ List.of(newCookie("foo")));
+ assertEncodeCookie(
+ "foo.name=foo.value;bar.name=bar.value",
+ List.of(newCookie("foo"), newCookie("bar")));
+ }
+
+ @Test
+ public void requireThatSetCookieCanBeEncoded() {
+ assertEncodeSetCookie(
+ List.of("foo.name=foo.value; Path=path; Domain=domain; Secure; HttpOnly",
+ "foo.name=foo.value; Path=path; Domain=domain; Secure; HttpOnly; SameSite=None"),
+ List.of(newSetCookie("foo"),
+ newSetCookie("foo").setSameSite(Cookie.SameSite.NONE)));
+ }
+
+ @Test
+ public void requireThatCookieCanBeDecoded() {
+ final Cookie foo = new Cookie();
+ foo.setName("foo.name");
+ foo.setValue("foo.value");
+ assertDecodeCookie(List.of(newCookie("foo")), "foo.name=foo.value");
+
+ final Cookie bar = new Cookie();
+ bar.setName("bar.name");
+ bar.setValue("bar.value");
+ assertDecodeCookie(List.of(foo, bar),"foo.name=foo.value; bar.name=bar.value");
+ }
+
+ @Test
+ public void requireThatSetCookieCanBeDecoded() {
+ final Cookie foo = new Cookie();
+ foo.setName("foo.name");
+ foo.setValue("foo.value");
+ foo.setPath("path");
+ foo.setDomain("domain");
+ foo.setMaxAge(0, TimeUnit.SECONDS);
+ foo.setSecure(true);
+ foo.setHttpOnly(true);
+ assertDecodeSetCookie(foo, "foo.name=foo.value;Max-Age=0;Path=path;Domain=domain;Secure;HTTPOnly;");
+
+ final Cookie bar = new Cookie();
+ bar.setName("bar.name");
+ bar.setValue("bar.value");
+ bar.setPath("path");
+ bar.setDomain("domain");
+ bar.setMaxAge(0, TimeUnit.SECONDS);
+ assertDecodeSetCookie(bar, "bar.name=bar.value;Max-Age=0;Path=path;Domain=domain;");
+ }
+
+ @Test
+ public void requireThatCookieDecoderWorksForGenericValidCookies() {
+ Cookie.fromCookieHeader("Y=v=1&n=8es5opih9ljtk&l=og0_iedeh0qqvqqr/o&p=m2g2rs6012000000&r=pv&lg=en-US&intl=" +
+ "us&np=1; T=z=h.nzPBhSP4PBVd5JqacVnIbNjU1NAY2TjYzNzVOTjYzNzM0Mj&a=YAE&sk=DAALShmNQ" +
+ "vhoZV&ks=EAABsibvMK6ejwn0uUoS4rC9w--~E&d=c2wBTVRJeU13RXhPVEUwTURJNU9URTBNRFF6TlRJ" +
+ "NU5nLS0BYQFZQUUBZwE1VkNHT0w3VUVDTklJVEdRR1FXT0pOSkhEQQFzY2lkAWNOUnZIbEc3ZHZoVHlWZ" +
+ "0NoXzEwYkxhOVdzcy0Bb2sBWlcwLQF0aXABWUhwTmVDAXp6AWgubnpQQkE3RQ--");
+ }
+
+ @Test
+ public void requireThatCookieDecoderWorksForYInvalidCookies() {
+ Cookie.fromCookieHeader("Y=v=1&n=77nkr5t7o4nqn&l=og0_iedeh0qqvqqr/o&p=m2g2rs6012000000&r=pv&lg=en-US&intl=" +
+ "us&np=1; T=z=05nzPB0NP4PBN/n0gwc1AWGNjU1NAY2TjYzNzVOTjYzNzM0Mj&a=QAE&sk=DAA4R2svo" +
+ "osjIa&ks=EAAj3nBQFkN4ZmuhqFxJdNoaQ--~E&d=c2wBTVRJeU13RXhPVEUwTURJNU9URTBNRFF6TlRJ" +
+ "NU5nLS0BYQFRQUUBZwE1VkNHT0w3VUVDTklJVEdRR1FXT0pOSkhEQQFzY2lkAUpPalRXOEVsUDZrR3RHT" +
+ "VZkX29CWk53clJIQS0BdGlwAVlIcE5lQwF6egEwNW56UEJBN0U-");
+ }
+
+ @Test
+ public void requireThatCookieDecoderWorksForYValidCookies() {
+ Cookie.fromCookieHeader("Y=v=1&n=3767k6te5aj2s&l=1v4u3001uw2ys00q0rw0qrw34q0x5s3u/o&p=030vvit012000000&iz=" +
+ "&r=pu&lg=en-US,it-IT,it&intl=it&np=1; T=z=m38yPBmLk3PBWvehTPBhBHYNU5OBjQ3NE5ONU5P" +
+ "NDY0NzU0M0&a=IAE&sk=DAAAx5URYgbhQ6&ks=EAA4rTgdlAGeMQmdYeM_VehGg--~E&d=c2wBTWprNUF" +
+ "UTXdNems1TWprNE16RXpNREl6TkRneAFhAUlBRQFnAUVJSlNMSzVRM1pWNVNLQVBNRkszQTRaWDZBAXNj" +
+ "aWQBSUlyZW5paXp4NS4zTUZMMDVlSVhuMjZKYUcwLQFvawFaVzAtAWFsAW1hcmlvYXByZWFAeW1haWwuY" +
+ "29tAXp6AW0zOHlQQkE3RQF0aXABaXRZOFRE");
+ }
+
+ @Test
+ public void requireThatCookieDecoderWorksForGenericInvalidCookies() {
+ Cookie.fromCookieHeader("Y=v=1&n=e92s5cq8qbs6h&l=3kdb0f.3@i126be10b.d4j/o&p=m1f2qgmb13000107&r=g5&lg=en-US" +
+ "&intl=us; T=z=TXp3OBTrQ8OBFMcj3GBpFSyNk83TgY2MjMwN04zMDMw&a=YAE&sk=DAAVfaNwLeISrX" +
+ "&ks=EAAOeNNgY8c5hV8YzPYmnrW7w--~E&d=c2wBTVRnd09RRXhOVFEzTURrME56UTMBYQFZQUUBZwFMQ" +
+ "U5NT0Q2UjY2Q0I1STY0R0tKSUdVQVlRRQFvawFaVzAtAXRpcAFMTlRUdkMBenoBVFhwM09CQTdF&af=QU" +
+ "FBQ0FDQURBd0FCMUNCOUFJQUJBQ0FEQU1IME1nTWhNbiZ0cz0xMzIzMjEwMTk1JnBzPVA1d3NYakh0aVk" +
+ "2UDMuUGZ6WkdTT2ctLQ--");
+ }
+
+ @Test
+ public void requireMappingBetweenSameSiteAndJettySameSite() {
+ for (var jdiscSameSite : Cookie.SameSite.values()) {
+ assertEquals(jdiscSameSite, Cookie.SameSite.fromJettySameSite(jdiscSameSite.jettySameSite()));
+ }
+
+ for (var jettySameSite : org.eclipse.jetty.http.HttpCookie.SameSite.values()) {
+ assertEquals(jettySameSite, Cookie.SameSite.fromJettySameSite(jettySameSite).jettySameSite());
+ }
+ }
+
+ private static void assertEncodeCookie(String expectedResult, List cookies) {
+ String actual = Cookie.toCookieHeader(cookies);
+ String expectedResult1 = expectedResult;
+ assertThat(actual, equalTo(expectedResult1));
+ }
+
+ private static void assertEncodeSetCookie(List expectedResult, List cookies) {
+ assertThat(Cookie.toSetCookieHeaders(cookies), containsInAnyOrder(expectedResult.toArray()));
+ }
+
+ private static void assertDecodeCookie(List expected, String toDecode) {
+ assertThat(Cookie.fromCookieHeader(toDecode), containsInAnyOrder(expected.toArray()));
+ }
+
+ private static void assertDecodeSetCookie(final Cookie expected, String toDecode) {
+ assertThat(Cookie.fromSetCookieHeader(toDecode), equalTo(expected));
+ }
+
+ private static Cookie newCookie(final String name) {
+ final Cookie cookie = new Cookie();
+ cookie.setName(name + ".name");
+ cookie.setValue(name + ".value");
+ return cookie;
+ }
+
+ private static Cookie newSetCookie(String name) {
+ final Cookie cookie = new Cookie();
+ cookie.setName(name + ".name");
+ cookie.setValue(name + ".value");
+ cookie.setDomain("domain");
+ cookie.setPath("path");
+ cookie.setSecure(true);
+ cookie.setHttpOnly(true);
+ return cookie;
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/HttpHeadersTestCase.java b/container-core/src/test/java/com/yahoo/jdisc/http/HttpHeadersTestCase.java
new file mode 100644
index 00000000000..d8ce4a6da0c
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/HttpHeadersTestCase.java
@@ -0,0 +1,17 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Simon Thoresen Hult
+ */
+public class HttpHeadersTestCase {
+
+ @Test
+ public void requireThatHeadersDoNotChange() {
+ assertEquals("X-JDisc-Disable-Chunking", HttpHeaders.Names.X_DISABLE_CHUNKING);
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/HttpRequestTestCase.java b/container-core/src/test/java/com/yahoo/jdisc/http/HttpRequestTestCase.java
new file mode 100644
index 00000000000..a3cb31d5ecb
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/HttpRequestTestCase.java
@@ -0,0 +1,206 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http;
+
+import com.yahoo.jdisc.Container;
+import com.yahoo.jdisc.Request;
+import com.yahoo.jdisc.service.CurrentContainer;
+import org.junit.Test;
+
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Simon Thoresen Hult
+ */
+public class HttpRequestTestCase {
+
+ @Test
+ public void requireThatSimpleServerConstructorsUseReasonableDefaults() {
+ URI uri = URI.create("http://localhost/");
+ HttpRequest request = HttpRequest.newServerRequest(mockContainer(), uri);
+ assertTrue(request.isServerRequest());
+ assertEquals(uri, request.getUri());
+ assertEquals(HttpRequest.Method.GET, request.getMethod());
+ assertEquals(HttpRequest.Version.HTTP_1_1, request.getVersion());
+
+ request = HttpRequest.newServerRequest(mockContainer(), uri, HttpRequest.Method.POST);
+ assertTrue(request.isServerRequest());
+ assertEquals(uri, request.getUri());
+ assertEquals(HttpRequest.Method.POST, request.getMethod());
+ assertEquals(HttpRequest.Version.HTTP_1_1, request.getVersion());
+
+ request = HttpRequest.newServerRequest(mockContainer(), uri, HttpRequest.Method.POST, HttpRequest.Version.HTTP_1_0);
+ assertTrue(request.isServerRequest());
+ assertEquals(uri, request.getUri());
+ assertEquals(HttpRequest.Method.POST, request.getMethod());
+ assertEquals(HttpRequest.Version.HTTP_1_0, request.getVersion());
+ }
+
+ @Test
+ public void requireThatSimpleClientConstructorsUseReasonableDefaults() {
+ Request parent = new Request(mockContainer(), URI.create("http://localhost/"));
+
+ URI uri = URI.create("http://remotehost/");
+ HttpRequest request = HttpRequest.newClientRequest(parent, uri);
+ assertFalse(request.isServerRequest());
+ assertEquals(uri, request.getUri());
+ assertEquals(HttpRequest.Method.GET, request.getMethod());
+ assertEquals(HttpRequest.Version.HTTP_1_1, request.getVersion());
+
+ request = HttpRequest.newClientRequest(parent, uri, HttpRequest.Method.POST);
+ assertFalse(request.isServerRequest());
+ assertEquals(uri, request.getUri());
+ assertEquals(HttpRequest.Method.POST, request.getMethod());
+ assertEquals(HttpRequest.Version.HTTP_1_1, request.getVersion());
+
+ request = HttpRequest.newClientRequest(parent, uri, HttpRequest.Method.POST, HttpRequest.Version.HTTP_1_0);
+ assertFalse(request.isServerRequest());
+ assertEquals(uri, request.getUri());
+ assertEquals(HttpRequest.Method.POST, request.getMethod());
+ assertEquals(HttpRequest.Version.HTTP_1_0, request.getVersion());
+ }
+
+ @Test
+ public void requireThatAccessorsWork() {
+ URI uri = URI.create("http://localhost/path?foo=bar&foo=baz&cox=69");
+ InetSocketAddress address = new InetSocketAddress("remotehost", 69);
+ final HttpRequest request = HttpRequest.newServerRequest(mockContainer(), uri, HttpRequest.Method.GET,
+ HttpRequest.Version.HTTP_1_1, address, 1L);
+ assertEquals(uri, request.getUri());
+ request.setUri(uri = URI.create("http://remotehost/"));
+ assertEquals(uri, request.getUri());
+
+ assertEquals(HttpRequest.Method.GET, request.getMethod());
+ request.setMethod(HttpRequest.Method.CONNECT);
+ assertEquals(HttpRequest.Method.CONNECT, request.getMethod());
+
+ assertEquals(HttpRequest.Version.HTTP_1_1, request.getVersion());
+ request.setVersion(HttpRequest.Version.HTTP_1_0);
+ assertEquals(HttpRequest.Version.HTTP_1_0, request.getVersion());
+
+ assertEquals(address, request.getRemoteAddress());
+ request.setRemoteAddress(address = new InetSocketAddress("localhost", 96));
+ assertEquals(address, request.getRemoteAddress());
+
+ final URI proxy = URI.create("http://proxyhost/");
+ request.setProxyServer(proxy);
+ assertEquals(proxy, request.getProxyServer());
+
+ assertNull(request.getConnectionTimeout(TimeUnit.MILLISECONDS));
+ request.setConnectionTimeout(1, TimeUnit.SECONDS);
+ assertEquals(Long.valueOf(1000), request.getConnectionTimeout(TimeUnit.MILLISECONDS));
+
+ assertEquals(Arrays.asList("bar", "baz"), request.parameters().get("foo"));
+ assertEquals(Collections.singletonList("69"), request.parameters().get("cox"));
+ request.parameters().put("cox", Arrays.asList("6", "9"));
+ assertEquals(Arrays.asList("bar", "baz"), request.parameters().get("foo"));
+ assertEquals(Arrays.asList("6", "9"), request.parameters().get("cox"));
+
+ assertEquals(1L, request.getConnectedAt(TimeUnit.MILLISECONDS));
+ }
+
+ @Test
+ public void requireThatHttp10EncodingIsNeverChunked() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_0);
+ assertFalse(request.isChunked());
+ request.headers().add(HttpHeaders.Names.TRANSFER_ENCODING, HttpHeaders.Values.CHUNKED);
+ assertFalse(request.isChunked());
+ }
+
+ @Test
+ public void requireThatHttp11EncodingIsNotChunkedByDefault() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_1);
+ assertFalse(request.isChunked());
+ }
+
+ @Test
+ public void requireThatHttp11EncodingCanBeChunked() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_1);
+ request.headers().add(HttpHeaders.Names.TRANSFER_ENCODING, HttpHeaders.Values.CHUNKED);
+ assertTrue(request.isChunked());
+ }
+
+ @Test
+ public void requireThatHttp10ConnectionIsAlwaysClose() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_0);
+ assertFalse(request.isKeepAlive());
+ request.headers().add(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
+ assertTrue(request.isKeepAlive());
+ }
+
+ @Test
+ public void requireThatHttp11ConnectionIsKeepAliveByDefault() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_1);
+ assertTrue(request.isKeepAlive());
+ }
+
+ @Test
+ public void requireThatHttp11ConnectionCanBeClose() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_1);
+ request.headers().add(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
+ assertFalse(request.isKeepAlive());
+ }
+
+ @Test
+ public void requireThatHttp10NeverHasChunkedResponse() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_0);
+ assertFalse(request.hasChunkedResponse());
+ }
+
+ @Test
+ public void requireThatHttp11HasDefaultChunkedResponse() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_1);
+ assertTrue(request.hasChunkedResponse());
+ }
+
+ @Test
+ public void requireThatHttp11CanDisableChunkedResponse() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_0);
+ request.headers().add(com.yahoo.jdisc.http.HttpHeaders.Names.X_DISABLE_CHUNKING, "true");
+ assertFalse(request.hasChunkedResponse());
+ }
+
+ @Test
+ public void requireThatCookieHeaderCanBeEncoded() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_0);
+ final List cookies = Collections.singletonList(new Cookie("foo", "bar"));
+ request.encodeCookieHeader(cookies);
+ final List headers = request.headers().get(com.yahoo.jdisc.http.HttpHeaders.Names.COOKIE);
+ assertEquals(1, headers.size());
+ assertEquals(Cookie.toCookieHeader(cookies), headers.get(0));
+ }
+
+ @Test
+ public void requireThatCookieHeaderCanBeDecoded() throws Exception {
+ final HttpRequest request = newRequest(HttpRequest.Version.HTTP_1_0);
+ final List cookies = Collections.singletonList(new Cookie("foo", "bar"));
+ request.encodeCookieHeader(cookies);
+ assertEquals(cookies, request.decodeCookieHeader());
+ }
+
+ private static HttpRequest newRequest(final HttpRequest.Version version) throws Exception {
+ return HttpRequest.newServerRequest(
+ mockContainer(),
+ new URI("http://localhost:1234/status.html"),
+ HttpRequest.Method.GET,
+ version);
+ }
+
+ private static CurrentContainer mockContainer() {
+ final CurrentContainer currentContainer = mock(CurrentContainer.class);
+ when(currentContainer.newReference(any(URI.class))).thenReturn(mock(Container.class));
+ return currentContainer;
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/HttpResponseTestCase.java b/container-core/src/test/java/com/yahoo/jdisc/http/HttpResponseTestCase.java
new file mode 100644
index 00000000000..61499200f3c
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/HttpResponseTestCase.java
@@ -0,0 +1,139 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http;
+
+import com.yahoo.jdisc.Container;
+import com.yahoo.jdisc.Request;
+import com.yahoo.jdisc.Response;
+import com.yahoo.jdisc.service.CurrentContainer;
+import org.junit.Test;
+
+import java.net.URI;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Simon Thoresen Hult
+ */
+public class HttpResponseTestCase {
+
+ @Test
+ public void requireThatAccessorsWork() throws Exception {
+ final HttpResponse response = newResponse(6, "foo");
+ assertEquals(6, response.getStatus());
+ assertEquals("foo", response.getMessage());
+ assertNull(response.getError());
+ assertTrue(response.isChunkedEncodingEnabled());
+
+ response.setStatus(9);
+ assertEquals(9, response.getStatus());
+
+ response.setMessage("bar");
+ assertEquals("bar", response.getMessage());
+
+ final Throwable err = new Throwable();
+ response.setError(err);
+ assertSame(err, response.getError());
+
+ response.setChunkedEncodingEnabled(false);
+ assertFalse(response.isChunkedEncodingEnabled());
+ }
+
+ @Test
+ public void requireThatStatusCodesDoNotChange() {
+ assertEquals(HttpResponse.Status.CREATED, 201);
+ assertEquals(HttpResponse.Status.ACCEPTED, 202);
+ assertEquals(HttpResponse.Status.NON_AUTHORITATIVE_INFORMATION, 203);
+ assertEquals(HttpResponse.Status.NO_CONTENT, 204);
+ assertEquals(HttpResponse.Status.RESET_CONTENT, 205);
+ assertEquals(HttpResponse.Status.PARTIAL_CONTENT, 206);
+
+ assertEquals(HttpResponse.Status.MULTIPLE_CHOICES, 300);
+ assertEquals(HttpResponse.Status.SEE_OTHER, 303);
+ assertEquals(HttpResponse.Status.NOT_MODIFIED, 304);
+ assertEquals(HttpResponse.Status.USE_PROXY, 305);
+
+ assertEquals(HttpResponse.Status.PAYMENT_REQUIRED, 402);
+ assertEquals(HttpResponse.Status.PROXY_AUTHENTICATION_REQUIRED, 407);
+ assertEquals(HttpResponse.Status.CONFLICT, 409);
+ assertEquals(HttpResponse.Status.GONE, 410);
+ assertEquals(HttpResponse.Status.LENGTH_REQUIRED, 411);
+ assertEquals(HttpResponse.Status.PRECONDITION_FAILED, 412);
+ assertEquals(HttpResponse.Status.REQUEST_ENTITY_TOO_LARGE, 413);
+ assertEquals(HttpResponse.Status.REQUEST_URI_TOO_LONG, 414);
+ assertEquals(HttpResponse.Status.UNSUPPORTED_MEDIA_TYPE, 415);
+ assertEquals(HttpResponse.Status.REQUEST_RANGE_NOT_SATISFIABLE, 416);
+ assertEquals(HttpResponse.Status.EXPECTATION_FAILED, 417);
+
+ assertEquals(HttpResponse.Status.BAD_GATEWAY, 502);
+ assertEquals(HttpResponse.Status.GATEWAY_TIMEOUT, 504);
+ }
+
+ @Test
+ public void requireThat5xxIsServerError() {
+ for (int i = 0; i < 999; ++i) {
+ assertEquals(i >= 500 && i < 600, HttpResponse.isServerError(new Response(i)));
+ }
+ }
+
+ @Test
+ public void requireThatCookieHeaderCanBeEncoded() throws Exception {
+ final HttpResponse response = newResponse(69, "foo");
+ final List cookies = Collections.singletonList(new Cookie("foo", "bar"));
+ response.encodeSetCookieHeader(cookies);
+ final List headers = response.headers().get(HttpHeaders.Names.SET_COOKIE);
+ assertEquals(1, headers.size());
+ assertEquals(Cookie.toSetCookieHeaders(cookies), headers);
+ }
+
+ @Test
+ public void requireThatMultipleCookieHeadersCanBeEncoded() throws Exception {
+ final HttpResponse response = newResponse(69, "foo");
+ final List cookies = Arrays.asList(new Cookie("foo", "bar"), new Cookie("baz", "cox"));
+ response.encodeSetCookieHeader(cookies);
+ final List headers = response.headers().get(HttpHeaders.Names.SET_COOKIE);
+ assertEquals(2, headers.size());
+ assertEquals(Cookie.toSetCookieHeaders(Arrays.asList(new Cookie("foo", "bar"), new Cookie("baz", "cox"))),
+ headers);
+ }
+
+ @Test
+ public void requireThatCookieHeaderCanBeDecoded() throws Exception {
+ final HttpResponse response = newResponse(69, "foo");
+ final List cookies = Collections.singletonList(new Cookie("foo", "bar"));
+ response.encodeSetCookieHeader(cookies);
+ assertEquals(cookies, response.decodeSetCookieHeader());
+ }
+
+ @Test
+ public void requireThatMultipleCookieHeadersCanBeDecoded() throws Exception {
+ final HttpResponse response = newResponse(69, "foo");
+ final List cookies = Arrays.asList(new Cookie("foo", "bar"), new Cookie("baz", "cox"));
+ response.encodeSetCookieHeader(cookies);
+ assertEquals(cookies, response.decodeSetCookieHeader());
+ }
+
+ private static HttpResponse newResponse(final int status, final String message) throws Exception {
+ final Request request = HttpRequest.newServerRequest(
+ mockContainer(),
+ new URI("http://localhost:1234/status.html"),
+ HttpRequest.Method.GET,
+ HttpRequest.Version.HTTP_1_1);
+ return HttpResponse.newInstance(status, message);
+ }
+
+ private static CurrentContainer mockContainer() {
+ final CurrentContainer currentContainer = mock(CurrentContainer.class);
+ when(currentContainer.newReference(any(URI.class))).thenReturn(mock(Container.class));
+ return currentContainer;
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/DiscFilterRequestTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/DiscFilterRequestTest.java
new file mode 100644
index 00000000000..1c05a3f3db2
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/DiscFilterRequestTest.java
@@ -0,0 +1,357 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.HeaderFields;
+import com.yahoo.jdisc.http.Cookie;
+import com.yahoo.jdisc.http.HttpHeaders;
+import com.yahoo.jdisc.http.HttpRequest;
+import com.yahoo.jdisc.http.HttpRequest.Version;
+import com.yahoo.jdisc.test.TestDriver;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+public class DiscFilterRequestTest {
+
+ private static HttpRequest newRequest(URI uri, HttpRequest.Method method, HttpRequest.Version version) {
+ InetSocketAddress address = new InetSocketAddress("example.yahoo.com", 69);
+ TestDriver driver = TestDriver.newSimpleApplicationInstanceWithoutOsgi();
+ driver.activateContainer(driver.newContainerBuilder());
+ HttpRequest request = HttpRequest.newServerRequest(driver, uri, method, version, address);
+ request.release();
+ assertTrue(driver.close());
+ return request;
+ }
+
+ @Test
+ public void testRequestConstruction(){
+ URI uri = URI.create("http://localhost:8080/test?param1=abc");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ httpReq.headers().add(HttpHeaders.Names.CONTENT_TYPE, "text/html;charset=UTF-8");
+ httpReq.headers().add("X-Custom-Header", "custom_header");
+ List cookies = new ArrayList();
+ cookies.add(new Cookie("XYZ", "value"));
+ cookies.add(new Cookie("ABC", "value"));
+ httpReq.encodeCookieHeader(cookies);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ Assert.assertSame(request.getParentRequest(), httpReq);
+ Assert.assertEquals(request.getHeader("X-Custom-Header"),"custom_header");
+ Assert.assertEquals(request.getHeader(HttpHeaders.Names.CONTENT_TYPE),"text/html;charset=UTF-8");
+
+ List c = request.getCookies();
+ Assert.assertNotNull(c);
+ Assert.assertEquals(c.size(), 2);
+
+ Assert.assertEquals(request.getParameter("param1"),"abc");
+ Assert.assertNull(request.getParameter("param2"));
+ Assert.assertEquals(request.getVersion(),Version.HTTP_1_1);
+ Assert.assertEquals(request.getProtocol(),Version.HTTP_1_1.name());
+ Assert.assertNull(request.getRequestedSessionId());
+ }
+
+ @Test
+ public void testRequestConstruction2() {
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ httpReq.headers().add("some-header", "some-value");
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+
+ request.addHeader("some-header", "some-value");
+ String value = request.getUntreatedHeaders().get("some-header").get(0);
+ Assert.assertEquals(value,"some-value");
+ }
+
+ @Test
+ public void testRequestAttributes() {
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ request.setAttribute("some_attr", "some_value");
+
+ Assert.assertEquals(request.containsAttribute("some_attr"),true);
+
+ Assert.assertEquals(request.getAttribute("some_attr"),"some_value");
+
+ }
+
+ @Test
+ public void testGetAttributeNames() {
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ request.setAttribute("some_attr_1", "some_value1");
+ request.setAttribute("some_attr_2", "some_value2");
+
+ Enumeration e = request.getAttributeNames();
+ List attrList = Collections.list(e);
+ Assert.assertEquals(2, attrList.size());
+ Assert.assertEquals(attrList.contains("some_attr_1"), true);
+ Assert.assertEquals(attrList.contains("some_attr_2"), true);
+
+ }
+
+ @Test
+ public void testRemoveAttribute() {
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ request.setAttribute("some_attr", "some_value");
+
+ Assert.assertEquals(request.containsAttribute("some_attr"),true);
+
+ request.removeAttribute("some_attr");
+
+ Assert.assertEquals(request.containsAttribute("some_attr"),false);
+ }
+
+ @Test
+ public void testGetIntHeader() {
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+
+ Assert.assertEquals(-1, request.getIntHeader("int_header"));
+
+ request.addHeader("int_header", String.valueOf(5));
+
+ Assert.assertEquals(5, request.getIntHeader("int_header"));
+ }
+
+ @Test
+ public void testDateHeader() {
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+
+
+ Assert.assertEquals(-1, request.getDateHeader(HttpHeaders.Names.IF_MODIFIED_SINCE));
+
+ request.addHeader(HttpHeaders.Names.IF_MODIFIED_SINCE, "Sat, 29 Oct 1994 19:43:31 GMT");
+
+ Assert.assertEquals(783459811000L, request.getDateHeader(HttpHeaders.Names.IF_MODIFIED_SINCE));
+ }
+
+ @Test
+ public void testParameterAPIsAsList() {
+ URI uri = URI.create("http://example.yahoo.com:8080/test?param1=abc¶m2=xyz¶m2=pqr");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ Assert.assertEquals(request.getParameter("param1"),"abc");
+
+ List values = request.getParameterValuesAsList("param2");
+ Assert.assertEquals(values.get(0),"xyz");
+ Assert.assertEquals(values.get(1),"pqr");
+
+ List paramNames = request.getParameterNamesAsList();
+ Assert.assertEquals(paramNames.size(), 2);
+
+ }
+
+ @Test
+ public void testParameterAPI(){
+ URI uri = URI.create("http://example.yahoo.com:8080/test?param1=abc¶m2=xyz¶m2=pqr");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ Assert.assertEquals(request.getParameter("param1"),"abc");
+
+ Enumeration values = request.getParameterValues("param2");
+ List valuesList = Collections.list(values);
+ Assert.assertEquals(valuesList.get(0),"xyz");
+ Assert.assertEquals(valuesList.get(1),"pqr");
+
+ Enumeration paramNames = request.getParameterNames();
+ List paramNamesList = Collections.list(paramNames);
+ Assert.assertEquals(paramNamesList.size(), 2);
+ }
+
+ @Test
+ public void testGetHeaderNamesAsList() {
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ httpReq.headers().add(HttpHeaders.Names.CONTENT_TYPE, "multipart/form-data");
+ httpReq.headers().add("header_1", "value1");
+ httpReq.headers().add("header_2", "value2");
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+
+ Assert.assertEquals(request.getHeaderNamesAsList() instanceof List, true);
+ Assert.assertEquals(request.getHeaderNamesAsList().size(), 3);
+ }
+
+ @Test
+ public void testGetHeadersAsList() {
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+
+ Assert.assertEquals(request.getHeaderNamesAsList() instanceof List, true);
+ Assert.assertEquals(request.getHeaderNamesAsList().size(), 0);
+
+ httpReq.headers().add("header_1", "value1");
+ httpReq.headers().add("header_1", "value2");
+
+ Assert.assertEquals(request.getHeadersAsList("header_1").size(), 2);
+ }
+
+ @Test
+ public void testIsMultipart() {
+
+ URI uri = URI.create("http://localhost:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ httpReq.headers().add(HttpHeaders.Names.CONTENT_TYPE, "multipart/form-data");
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+
+ Assert.assertEquals(true,DiscFilterRequest.isMultipart(request));
+
+ httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ httpReq.headers().add(HttpHeaders.Names.CONTENT_TYPE, "text/html;charset=UTF-8");
+ request = new JdiscFilterRequest(httpReq);
+
+ Assert.assertEquals(DiscFilterRequest.isMultipart(request),false);
+
+ Assert.assertEquals(DiscFilterRequest.isMultipart(null),false);
+
+
+ httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ request = new JdiscFilterRequest(httpReq);
+ Assert.assertEquals(DiscFilterRequest.isMultipart(request),false);
+ }
+
+ @Test
+ public void testGetRemotePortLocalPort() {
+
+ URI uri = URI.create("http://example.yahoo.com:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+
+ Assert.assertEquals(69, request.getRemotePort());
+ Assert.assertEquals(8080, request.getLocalPort());
+
+ if (request.getRemoteHost() != null) // if we have network
+ Assert.assertEquals("example.yahoo.com", request.getRemoteHost());
+
+ request.setRemoteAddr("1.1.1.1");
+
+ Assert.assertEquals("1.1.1.1",request.getRemoteAddr());
+ }
+
+ @Test
+ public void testCharacterEncoding() throws Exception {
+ URI uri = URI.create("http://example.yahoo.com:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ request.setHeaders(HttpHeaders.Names.CONTENT_TYPE, "text/html;charset=UTF-8");
+
+ Assert.assertEquals(request.getCharacterEncoding(), "UTF-8");
+
+ httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ request = new JdiscFilterRequest(httpReq);
+ request.setHeaders(HttpHeaders.Names.CONTENT_TYPE, "text/html");
+ request.setCharacterEncoding("UTF-8");
+
+ Assert.assertEquals(request.getCharacterEncoding(),"UTF-8");
+
+ Assert.assertEquals(request.getHeader(HttpHeaders.Names.CONTENT_TYPE),"text/html;charset=UTF-8");
+ }
+
+ @Test
+ public void testSetScheme() throws Exception {
+ URI uri = URI.create("https://example.yahoo.com:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+
+ request.setScheme("http", true);
+ System.out.println(request.getUri().toString());
+ Assert.assertEquals(request.getUri().toString(), "http://example.yahoo.com:8080/test");
+ }
+
+ @Test
+ public void testGetServerPort() throws Exception {
+ URI uri = URI.create("http://example.yahoo.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ Assert.assertEquals(request.getServerPort(), 80);
+
+ request.setUri(URI.create("https://example.yahoo.com/test"));
+ Assert.assertEquals(request.getServerPort(), 443);
+
+ }
+
+ @Test
+ public void testIsSecure() throws Exception {
+ URI uri = URI.create("http://example.yahoo.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ Assert.assertEquals(request.isSecure(), false);
+
+ request.setUri(URI.create("https://example.yahoo.com/test"));
+ Assert.assertEquals(request.isSecure(), true);
+
+ }
+
+ @Test
+ public void requireThatUnresolvableRemoteAddressesAreSupported() {
+ URI uri = URI.create("http://doesnotresolve.zzz:8080/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ Assert.assertNull(request.getLocalAddr());
+ }
+
+ @Test
+ public void testGetUntreatedHeaders() {
+ URI uri = URI.create("http://example.yahoo.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ httpReq.headers().add("key1", "value1");
+ httpReq.headers().add("key2", Arrays.asList("value1","value2"));
+
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ HeaderFields headers = request.getUntreatedHeaders();
+ Assert.assertEquals(headers.keySet().size(), 2);
+ Assert.assertEquals(headers.get("key1").get(0), "value1" );
+ Assert.assertEquals(headers.get("key2").get(0), "value1" );
+ Assert.assertEquals(headers.get("key2").get(1), "value2" );
+ }
+
+ @Test
+ public void testClearCookies() throws Exception {
+ URI uri = URI.create("http://example.yahoo.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ httpReq.headers().put(HttpHeaders.Names.COOKIE, "XYZ=value");
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ request.clearCookies();
+ Assert.assertNull(request.getHeader(HttpHeaders.Names.COOKIE));
+ }
+
+ @Test
+ public void testGetWrapedCookies() throws Exception {
+ URI uri = URI.create("http://example.yahoo.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ httpReq.headers().put(HttpHeaders.Names.COOKIE, "XYZ=value");
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ JDiscCookieWrapper[] wrappers = request.getWrappedCookies();
+ Assert.assertEquals(wrappers.length ,1);
+ Assert.assertEquals(wrappers[0].getName(), "XYZ");
+ Assert.assertEquals(wrappers[0].getValue(), "value");
+ }
+
+ @Test
+ public void testAddCookie() {
+ URI uri = URI.create("http://example.yahoo.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterRequest request = new JdiscFilterRequest(httpReq);
+ request.addCookie(JDiscCookieWrapper.wrap(new Cookie("name", "value")));
+
+ List cookies = request.getCookies();
+ Assert.assertEquals(cookies.size(), 1);
+ Assert.assertEquals(cookies.get(0).getName(), "name");
+ Assert.assertEquals(cookies.get(0).getValue(), "value");
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/DiscFilterResponseTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/DiscFilterResponseTest.java
new file mode 100644
index 00000000000..b349cb8d803
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/DiscFilterResponseTest.java
@@ -0,0 +1,113 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.Request;
+import com.yahoo.jdisc.http.Cookie;
+import com.yahoo.jdisc.http.HttpRequest;
+import com.yahoo.jdisc.http.HttpResponse;
+import com.yahoo.jdisc.test.TestDriver;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+public class DiscFilterResponseTest {
+
+ private static HttpRequest newRequest(URI uri, HttpRequest.Method method, HttpRequest.Version version) {
+ InetSocketAddress address = new InetSocketAddress("localhost", 69);
+ TestDriver driver = TestDriver.newSimpleApplicationInstanceWithoutOsgi();
+ driver.activateContainer(driver.newContainerBuilder());
+ HttpRequest request = HttpRequest.newServerRequest(driver, uri, method, version, address);
+ request.release();
+ assertTrue(driver.close());
+ return request;
+ }
+
+ public static HttpResponse newResponse(Request request, int status) {
+ return HttpResponse.newInstance(status);
+ }
+
+ @Test
+ public void testGetSetStatus() {
+ HttpRequest request = newRequest(URI.create("http://localhost:8080/echo"),
+ HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterResponse response = new JdiscFilterResponse(HttpResponse.newInstance(HttpResponse.Status.OK));
+
+ Assert.assertEquals(response.getStatus(), HttpResponse.Status.OK);
+ response.setStatus(HttpResponse.Status.REQUEST_TIMEOUT);
+ Assert.assertEquals(response.getStatus(), HttpResponse.Status.REQUEST_TIMEOUT);
+ }
+
+ @Test
+ public void testAttributes() {
+ HttpRequest request = newRequest(URI.create("http://localhost:8080/echo"),
+ HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterResponse response = new JdiscFilterResponse(HttpResponse.newInstance(HttpResponse.Status.OK));
+ response.setAttribute("attr_1", "value1");
+ Assert.assertEquals(response.getAttribute("attr_1"), "value1");
+ List list = Collections.list(response.getAttributeNames());
+ Assert.assertEquals(list.get(0), "attr_1");
+ response.removeAttribute("attr_1");
+ Assert.assertNull(response.getAttribute("attr_1"));
+ }
+
+ @Test
+ public void testAddHeader() {
+ HttpRequest request = newRequest(URI.create("http://localhost:8080/echo"),
+ HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ DiscFilterResponse response = new JdiscFilterResponse(HttpResponse.newInstance(HttpResponse.Status.OK));
+ response.addHeader("header1", "value1");
+ Assert.assertEquals(response.getHeader("header1"), "value1");
+ }
+
+ @Test
+ public void testAddCookie() {
+ URI uri = URI.create("http://example.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ HttpResponse httpResp = newResponse(httpReq, 200);
+ DiscFilterResponse response = new JdiscFilterResponse(httpResp);
+ response.addCookie(JDiscCookieWrapper.wrap(new Cookie("name", "value")));
+
+ List cookies = response.getCookies();
+ Assert.assertEquals(cookies.size(),1);
+ Assert.assertEquals(cookies.get(0).getName(),"name");
+ }
+
+ @Test
+ public void testSetCookie() {
+ URI uri = URI.create("http://example.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ HttpResponse httpResp = newResponse(httpReq, 200);
+ DiscFilterResponse response = new JdiscFilterResponse(httpResp);
+ response.setCookie("name", "value");
+ List cookies = response.getCookies();
+ Assert.assertEquals(cookies.size(),1);
+ Assert.assertEquals(cookies.get(0).getName(),"name");
+
+ }
+
+ @Test
+ public void testSetHeader() {
+ URI uri = URI.create("http://example.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ HttpResponse httpResp = newResponse(httpReq, 200);
+ DiscFilterResponse response = new JdiscFilterResponse(httpResp);
+ response.setHeader("name", "value");
+ Assert.assertEquals(response.getHeader("name"), "value");
+ }
+
+ @Test
+ public void testGetParentResponse() {
+ URI uri = URI.create("http://example.com/test");
+ HttpRequest httpReq = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ HttpResponse httpResp = newResponse(httpReq, 200);
+ DiscFilterResponse response = new JdiscFilterResponse(httpResp);
+ Assert.assertSame(response.getParentResponse(), httpResp);
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/EmptyRequestFilterTestCase.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/EmptyRequestFilterTestCase.java
new file mode 100644
index 00000000000..f4418e74169
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/EmptyRequestFilterTestCase.java
@@ -0,0 +1,48 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.Container;
+import com.yahoo.jdisc.handler.ResponseHandler;
+import com.yahoo.jdisc.http.HttpRequest;
+import com.yahoo.jdisc.http.filter.chain.EmptyRequestFilter;
+import com.yahoo.jdisc.service.CurrentContainer;
+import org.junit.Test;
+
+import java.net.URI;
+import java.util.concurrent.TimeUnit;
+
+import static com.yahoo.jdisc.http.HttpRequest.Method;
+import static com.yahoo.jdisc.http.HttpRequest.Version;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Simon Thoresen Hult
+ */
+public class EmptyRequestFilterTestCase {
+
+ @Test
+ public void requireThatEmptyFilterDoesNothing() throws Exception {
+ final HttpRequest lhs = newRequest(Method.GET, "/status.html", Version.HTTP_1_1);
+ final HttpRequest rhs = newRequest(Method.GET, "/status.html", Version.HTTP_1_1);
+
+ EmptyRequestFilter.INSTANCE.filter(rhs, mock(ResponseHandler.class));
+
+ assertEquals(lhs.headers(), rhs.headers());
+ assertEquals(lhs.context(), rhs.context());
+ assertEquals(lhs.getTimeout(TimeUnit.MILLISECONDS), rhs.getTimeout(TimeUnit.MILLISECONDS));
+ assertEquals(lhs.parameters(), rhs.parameters());
+ assertEquals(lhs.getMethod(), rhs.getMethod());
+ assertEquals(lhs.getVersion(), rhs.getVersion());
+ assertEquals(lhs.getRemoteAddress(), rhs.getRemoteAddress());
+ }
+
+ private static HttpRequest newRequest(
+ final Method method, final String uri, final Version version) {
+ final CurrentContainer currentContainer = mock(CurrentContainer.class);
+ when(currentContainer.newReference(any(URI.class))).thenReturn(mock(Container.class));
+ return HttpRequest.newServerRequest(currentContainer, URI.create(uri), method, version);
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/EmptyResponseFilterTestCase.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/EmptyResponseFilterTestCase.java
new file mode 100644
index 00000000000..e6d7259ea41
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/EmptyResponseFilterTestCase.java
@@ -0,0 +1,45 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.Container;
+import com.yahoo.jdisc.Response;
+import com.yahoo.jdisc.http.HttpRequest;
+import com.yahoo.jdisc.http.HttpResponse;
+import com.yahoo.jdisc.http.filter.chain.EmptyResponseFilter;
+import com.yahoo.jdisc.service.CurrentContainer;
+import org.junit.Test;
+
+import java.net.URI;
+
+import static com.yahoo.jdisc.http.HttpRequest.Method;
+import static com.yahoo.jdisc.http.HttpRequest.Version;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Simon Thoresen Hult
+ */
+public class EmptyResponseFilterTestCase {
+
+ @Test
+ public void requireThatEmptyFilterDoesNothing() throws Exception {
+ final HttpRequest request = newRequest(Method.GET, "/status.html", Version.HTTP_1_1);
+ final HttpResponse lhs = HttpResponse.newInstance(Response.Status.OK);
+ final HttpResponse rhs = HttpResponse.newInstance(Response.Status.OK);
+
+ EmptyResponseFilter.INSTANCE.filter(lhs, null);
+
+ assertEquals(lhs.headers(), rhs.headers());
+ assertEquals(lhs.context(), rhs.context());
+ assertEquals(lhs.getError(), rhs.getError());
+ assertEquals(lhs.getMessage(), rhs.getMessage());
+ }
+
+ private static HttpRequest newRequest(final Method method, final String uri, final Version version) {
+ final CurrentContainer currentContainer = mock(CurrentContainer.class);
+ when(currentContainer.newReference(any(URI.class))).thenReturn(mock(Container.class));
+ return HttpRequest.newServerRequest(currentContainer, URI.create(uri), method, version);
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/JDiscCookieWrapperTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/JDiscCookieWrapperTest.java
new file mode 100644
index 00000000000..9948e5bfe7f
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/JDiscCookieWrapperTest.java
@@ -0,0 +1,29 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.http.Cookie;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.TimeUnit;
+
+public class JDiscCookieWrapperTest {
+
+ @Test
+ public void requireThatWrapWorks() {
+ Cookie cookie = new Cookie("name", "value");
+ JDiscCookieWrapper wrapper = JDiscCookieWrapper.wrap(cookie);
+
+ wrapper.setDomain("yahoo.com");
+ wrapper.setMaxAge(10);
+ wrapper.setPath("/path");
+
+ Assert.assertEquals(wrapper.getName(), cookie.getName());
+ Assert.assertEquals(wrapper.getValue(), cookie.getValue());
+ Assert.assertEquals(wrapper.getDomain(), cookie.getDomain());
+ Assert.assertEquals(wrapper.getMaxAge(), cookie.getMaxAge(TimeUnit.SECONDS));
+ Assert.assertEquals(wrapper.getPath(), cookie.getPath());
+ Assert.assertEquals(wrapper.getSecure(), cookie.isSecure());
+
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/RequestViewImplTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/RequestViewImplTest.java
new file mode 100644
index 00000000000..ec0e0a33d35
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/RequestViewImplTest.java
@@ -0,0 +1,57 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.google.common.collect.Lists;
+import com.yahoo.jdisc.HeaderFields;
+import com.yahoo.jdisc.Request;
+import com.yahoo.jdisc.http.filter.SecurityResponseFilterChain.RequestViewImpl;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author gjoranv
+ */
+public class RequestViewImplTest {
+
+ @Test
+ public void header_from_the_parent_request_is_available() throws Exception {
+ final String HEADER = "single-header";
+
+ HeaderFields parentHeaders = new HeaderFields();
+ parentHeaders.add(HEADER, "value");
+
+ RequestView requestView = newRequestView(parentHeaders);
+
+ assertEquals(requestView.getFirstHeader(HEADER).get(), "value");
+ assertEquals(requestView.getHeaders(HEADER).size(), 1);
+ assertEquals(requestView.getHeaders(HEADER).get(0), "value");
+ }
+
+
+ @Test
+ public void multi_value_header_from_the_parent_request_is_available() throws Exception {
+ final String HEADER = "list-header";
+
+ HeaderFields parentHeaders = new HeaderFields();
+ parentHeaders.add(HEADER, Lists.newArrayList("one", "two"));
+
+ RequestView requestView = newRequestView(parentHeaders);
+
+ assertEquals(requestView.getHeaders(HEADER).size(), 2);
+ assertEquals(requestView.getHeaders(HEADER).get(0), "one");
+ assertEquals(requestView.getHeaders(HEADER).get(1), "two");
+
+ assertEquals(requestView.getFirstHeader(HEADER).get(), "one");
+ }
+
+ private static RequestView newRequestView(HeaderFields parentHeaders) {
+ Request request = mock(Request.class);
+ when(request.headers()).thenReturn(parentHeaders);
+
+ return new RequestViewImpl(request);
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/ResponseHeaderFilter.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/ResponseHeaderFilter.java
new file mode 100644
index 00000000000..3855c3a494b
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/ResponseHeaderFilter.java
@@ -0,0 +1,25 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.AbstractResource;
+import com.yahoo.jdisc.Request;
+import com.yahoo.jdisc.Response;
+
+/**
+ * @author Simon Thoresen Hult
+ */
+public class ResponseHeaderFilter extends AbstractResource implements ResponseFilter {
+
+ private final String key;
+ private final String val;
+
+ public ResponseHeaderFilter(String key, String val) {
+ this.key = key;
+ this.val = val;
+ }
+
+ @Override
+ public void filter(Response response, Request request) {
+ response.headers().add(key, val);
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/SecurityRequestFilterChainTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/SecurityRequestFilterChainTest.java
new file mode 100644
index 00000000000..be19313dee2
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/SecurityRequestFilterChainTest.java
@@ -0,0 +1,145 @@
+// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.AbstractResource;
+import com.yahoo.jdisc.Response;
+import com.yahoo.jdisc.handler.CompletionHandler;
+import com.yahoo.jdisc.handler.ContentChannel;
+import com.yahoo.jdisc.handler.ResponseDispatch;
+import com.yahoo.jdisc.handler.ResponseHandler;
+import com.yahoo.jdisc.http.HttpRequest;
+import com.yahoo.jdisc.test.TestDriver;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author bjorncs
+ */
+public class SecurityRequestFilterChainTest {
+
+
+ private static HttpRequest newRequest(URI uri, HttpRequest.Method method, HttpRequest.Version version) {
+ InetSocketAddress address = new InetSocketAddress("java.corp.yahoo.com", 69);
+ TestDriver driver = TestDriver.newSimpleApplicationInstanceWithoutOsgi();
+ driver.activateContainer(driver.newContainerBuilder());
+ HttpRequest request = HttpRequest.newServerRequest(driver, uri, method, version, address);
+ request.release();
+ Assert.assertTrue(driver.close());
+ return request;
+ }
+
+ @Test
+ public void testFilterChainConstruction() {
+ SecurityRequestFilterChain chain = (SecurityRequestFilterChain)SecurityRequestFilterChain.newInstance();
+ assertEquals(chain.getFilters().size(),0);
+
+ List requestFilters = new ArrayList();
+ chain = (SecurityRequestFilterChain)SecurityRequestFilterChain.newInstance();
+
+ chain = (SecurityRequestFilterChain)SecurityRequestFilterChain.newInstance(new RequestHeaderFilter("abc", "xyz"),
+ new RequestHeaderFilter("pqr", "def"));
+
+ assertEquals(chain instanceof SecurityRequestFilterChain, true);
+ }
+
+
+ @Test
+ public void testFilterChainRun() {
+ RequestFilter chain = SecurityRequestFilterChain.newInstance(new RequestHeaderFilter("abc", "xyz"),
+ new RequestHeaderFilter("pqr", "def"));
+
+ assertEquals(chain instanceof SecurityRequestFilterChain, true);
+ ResponseHandler handler = newResponseHandler();
+ HttpRequest request = newRequest(URI.create("http://test/test"), HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ chain.filter(request, handler);
+ Assert.assertTrue(request.headers().contains("abc", "xyz"));
+ Assert.assertTrue(request.headers().contains("pqr", "def"));
+ }
+
+ @Test
+ public void testFilterChainResponds() {
+ RequestFilter chain = SecurityRequestFilterChain.newInstance(
+ new MyFilter(),
+ new RequestHeaderFilter("abc", "xyz"),
+ new RequestHeaderFilter("pqr", "def"));
+
+ assertEquals(chain instanceof SecurityRequestFilterChain, true);
+ ResponseHandler handler = newResponseHandler();
+ HttpRequest request = newRequest(URI.create("http://test/test"), HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ chain.filter(request, handler);
+ Response response = getResponse(handler);
+ Assert.assertNotNull(response);
+ Assert.assertTrue(!request.headers().contains("abc", "xyz"));
+ Assert.assertTrue(!request.headers().contains("pqr", "def"));
+ }
+
+ private class RequestHeaderFilter extends AbstractResource implements SecurityRequestFilter {
+
+ private final String key;
+ private final String val;
+
+ public RequestHeaderFilter(String key, String val) {
+ this.key = key;
+ this.val = val;
+ }
+
+ @Override
+ public void filter(DiscFilterRequest request, ResponseHandler handler) {
+ request.setHeaders(key, val);
+ }
+ }
+
+ private class MyFilter extends AbstractResource implements SecurityRequestFilter {
+
+ @Override
+ public void filter(DiscFilterRequest request, ResponseHandler handler) {
+ ResponseDispatch.newInstance(Response.Status.FORBIDDEN).dispatch(handler);
+ }
+ }
+
+ private static ResponseHandler newResponseHandler() {
+ return new NonWorkingResponseHandler();
+ }
+
+ private static Response getResponse(ResponseHandler handler) {
+ return ((NonWorkingResponseHandler) handler).getResponse();
+ }
+
+ private static class NonWorkingResponseHandler implements ResponseHandler {
+
+ private Response response = null;
+
+ @Override
+ public ContentChannel handleResponse(Response response) {
+ this.response = response;
+ return new NonWorkingContentChannel();
+ }
+
+ public Response getResponse() {
+ return response;
+ }
+ }
+
+ private static class NonWorkingContentChannel implements ContentChannel {
+
+ @Override
+ public void close(CompletionHandler handler) {
+
+ }
+
+ @Override
+ public void write(ByteBuffer buf, CompletionHandler handler) {
+
+ }
+
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/SecurityResponseFilterChainTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/SecurityResponseFilterChainTest.java
new file mode 100644
index 00000000000..25291de5cc1
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/SecurityResponseFilterChainTest.java
@@ -0,0 +1,74 @@
+// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.AbstractResource;
+import com.yahoo.jdisc.Response;
+import com.yahoo.jdisc.http.HttpRequest;
+import com.yahoo.jdisc.http.HttpResponse;
+import com.yahoo.jdisc.test.TestDriver;
+import org.junit.Test;
+
+import java.net.InetSocketAddress;
+import java.net.URI;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author bjorncs
+ */
+public class SecurityResponseFilterChainTest {
+ private static HttpRequest newRequest(URI uri, HttpRequest.Method method, HttpRequest.Version version) {
+ InetSocketAddress address = new InetSocketAddress("java.corp.yahoo.com", 69);
+ TestDriver driver = TestDriver.newSimpleApplicationInstanceWithoutOsgi();
+ driver.activateContainer(driver.newContainerBuilder());
+ HttpRequest request = HttpRequest.newServerRequest(driver, uri, method, version, address);
+ request.release();
+ assertTrue(driver.close());
+ return request;
+ }
+
+ @Test
+ public void testFilterChainConstruction() {
+ SecurityResponseFilterChain chain = (SecurityResponseFilterChain)SecurityResponseFilterChain.newInstance();
+ assertEquals(chain.getFilters().size(),0);
+
+ chain = (SecurityResponseFilterChain)SecurityResponseFilterChain.newInstance(new ResponseHeaderFilter("abc", "xyz"),
+ new ResponseHeaderFilter("pqr", "def"));
+
+ assertEquals(chain instanceof SecurityResponseFilterChain, true);
+ }
+
+ @Test
+ public void testFilterChainRun() {
+ URI uri = URI.create("http://localhost:8080/echo");
+ HttpRequest request = newRequest(uri, HttpRequest.Method.GET, HttpRequest.Version.HTTP_1_1);
+ Response response = HttpResponse.newInstance(Response.Status.OK);
+
+ ResponseFilter chain = SecurityResponseFilterChain.newInstance(new ResponseHeaderFilter("abc", "xyz"),
+ new ResponseHeaderFilter("pqr", "def"));
+ chain.filter(response, null);
+ assertTrue(response.headers().contains("abc", "xyz"));
+ assertTrue(response.headers().contains("pqr", "def"));
+ }
+
+ private class ResponseHeaderFilter extends AbstractResource implements SecurityResponseFilter {
+
+ private final String key;
+ private final String val;
+
+ public ResponseHeaderFilter(String key, String val) {
+ this.key = key;
+ this.val = val;
+ }
+
+ @Override
+ public void filter(DiscFilterResponse response, RequestView request) {
+ response.setHeaders(key, val);
+ }
+
+ }
+
+
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/ServletFilterRequestTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/ServletFilterRequestTest.java
new file mode 100644
index 00000000000..3052902f174
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/ServletFilterRequestTest.java
@@ -0,0 +1,179 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.http.Cookie;
+import com.yahoo.jdisc.http.HttpHeaders;
+import com.yahoo.jdisc.http.servlet.ServletRequest;
+import org.eclipse.jetty.server.HttpConnection;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.springframework.mock.web.MockHttpServletRequest;
+
+import java.net.URI;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static com.yahoo.jdisc.http.HttpRequest.Version;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test the parts of the DiscFilterRequest API that are implemented
+ * by ServletFilterRequest, both directly and indirectly via
+ * {@link com.yahoo.jdisc.http.servlet.ServletRequest}.
+ *
+ * @author gjoranv
+ * @since 5.27
+ */
+public class ServletFilterRequestTest {
+
+ private final String host = "host1";
+ private final int port = 8080;
+ private final String path = "/path1";
+ private final String paramName = "param1";
+ private final String paramValue = "p1";
+ private final String listParamName = "listParam";
+ private final String[] listParamValue = new String[]{"1", "2"};
+ private final String headerName = "header1";
+ private final String headerValue = "h1";
+ private final String attributeName = "attribute1";
+ private final String attributeValue = "a1";
+
+ private URI uri;
+ private DiscFilterRequest filterRequest;
+ private ServletRequest parentRequest;
+
+ @Before
+ public void init() throws Exception {
+ uri = new URI("http", null, host, port, path, paramName + "=" + paramValue, null);
+
+ filterRequest = new ServletFilterRequest(newServletRequest());
+ parentRequest = ((ServletFilterRequest)filterRequest).getServletRequest();
+ }
+
+ private ServletRequest newServletRequest() throws Exception {
+ MockHttpServletRequest parent = new MockHttpServletRequest("GET", uri.toString());
+ parent.setProtocol(Version.HTTP_1_1.toString());
+ parent.setRemoteHost(host);
+ parent.setRemotePort(port);
+ parent.setParameter(paramName, paramValue);
+ parent.setParameter(listParamName, listParamValue);
+ parent.addHeader(headerName, headerValue);
+ parent.setAttribute(attributeName, attributeValue);
+ HttpConnection connection = Mockito.mock(HttpConnection.class);
+ when(connection.getCreatedTimeStamp()).thenReturn(System.currentTimeMillis());
+ parent.setAttribute("org.eclipse.jetty.server.HttpConnection", connection);
+ return new ServletRequest(parent, uri);
+ }
+
+ @Test
+ public void parent_properties_are_propagated_to_disc_filter_request() throws Exception {
+ assertEquals(filterRequest.getVersion(), Version.HTTP_1_1);
+ assertEquals(filterRequest.getMethod(), "GET");
+ assertEquals(filterRequest.getUri(), uri);
+ assertEquals(filterRequest.getRemoteHost(), host);
+ assertEquals(filterRequest.getRemotePort(), port);
+ assertEquals(filterRequest.getRequestURI(), path); // getRequestUri return only the path by design
+
+ assertEquals(filterRequest.getParameter(paramName), paramValue);
+ assertEquals(filterRequest.getParameterMap().get(paramName),
+ Collections.singletonList(paramValue));
+ assertEquals(filterRequest.getParameterValuesAsList(listParamName), Arrays.asList(listParamValue));
+
+ assertEquals(filterRequest.getHeader(headerName), headerValue);
+ assertEquals(filterRequest.getAttribute(attributeName), attributeValue);
+ }
+
+ @Test
+ public void untreatedHeaders_is_populated_from_the_parent_request() {
+ assertEquals(filterRequest.getUntreatedHeaders().getFirst(headerName), headerValue);
+ }
+
+ @Test
+ public void uri_can_be_set() throws Exception {
+ URI newUri = new URI("http", null, host, port + 1, path, paramName + "=" + paramValue, null);
+ filterRequest.setUri(newUri);
+
+ assertEquals(filterRequest.getUri(), newUri);
+ assertEquals(parentRequest.getUri(), newUri);
+ }
+
+ @Test
+ public void attributes_can_be_set() throws Exception {
+ String name = "newAttribute";
+ String value = name + "Value";
+ filterRequest.setAttribute(name, value);
+
+ assertEquals(filterRequest.getAttribute(name), value);
+ assertEquals(parentRequest.getAttribute(name), value);
+ }
+
+ @Test
+ public void attributes_can_be_removed() {
+ filterRequest.removeAttribute(attributeName);
+
+ assertEquals(filterRequest.getAttribute(attributeName), null);
+ assertEquals(parentRequest.getAttribute(attributeName), null);
+ }
+
+ @Test
+ public void headers_can_be_set() throws Exception {
+ String name = "myHeader";
+ String value = name + "Value";
+ filterRequest.setHeaders(name, value);
+
+ assertEquals(filterRequest.getHeader(name), value);
+ assertEquals(parentRequest.getHeader(name), value);
+ }
+
+ @Test
+ public void headers_can_be_removed() throws Exception {
+ filterRequest.removeHeaders(headerName);
+
+ assertEquals(filterRequest.getHeader(headerName), null);
+ assertEquals(parentRequest.getHeader(headerName), null);
+ }
+
+ @Test
+ public void headers_can_be_added() {
+ String value = "h2";
+ filterRequest.addHeader(headerName, value);
+
+ List expected = Arrays.asList(headerValue, value);
+ assertEquals(filterRequest.getHeadersAsList(headerName), expected);
+ assertEquals(Collections.list(parentRequest.getHeaders(headerName)), expected);
+ }
+
+ @Test
+ public void cookies_can_be_added_and_removed() {
+ Cookie cookie = new Cookie("name", "value");
+ filterRequest.addCookie(JDiscCookieWrapper.wrap(cookie));
+
+ assertEquals(filterRequest.getCookies(), Collections.singletonList(cookie));
+ assertEquals(parentRequest.getCookies().length, 1);
+
+ javax.servlet.http.Cookie servletCookie = parentRequest.getCookies()[0];
+ assertEquals(servletCookie.getName(), cookie.getName());
+ assertEquals(servletCookie.getValue(), cookie.getValue());
+
+ filterRequest.clearCookies();
+ assertTrue(filterRequest.getCookies().isEmpty());
+ assertEquals(parentRequest.getCookies().length, 0);
+ }
+
+ @Test
+ public void character_encoding_can_be_set() throws Exception {
+ // ContentType must be non-null before setting character encoding
+ filterRequest.setHeaders(HttpHeaders.Names.CONTENT_TYPE, "");
+
+ String encoding = "myEncoding";
+ filterRequest.setCharacterEncoding(encoding);
+
+ assertTrue(filterRequest.getCharacterEncoding().contains(encoding));
+ assertTrue(parentRequest.getCharacterEncoding().contains(encoding));
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/filter/ServletFilterResponseTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/filter/ServletFilterResponseTest.java
new file mode 100644
index 00000000000..a2bc2badea3
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/filter/ServletFilterResponseTest.java
@@ -0,0 +1,87 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.filter;
+
+import com.yahoo.jdisc.http.Cookie;
+import com.yahoo.jdisc.http.HttpHeaders;
+import com.yahoo.jdisc.http.servlet.ServletResponse;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author gjoranv
+ * @since 5.27
+ */
+public class ServletFilterResponseTest {
+
+ private final String headerName = "header1";
+ private final String headerValue = "h1";
+
+ private DiscFilterResponse filterResponse;
+ private ServletResponse parentResponse;
+
+ @Before
+ public void init() throws Exception {
+ filterResponse = new ServletFilterResponse(newServletResponse());
+ parentResponse = ((ServletFilterResponse)filterResponse).getServletResponse();
+
+ }
+
+ private ServletResponse newServletResponse() throws Exception {
+ MockServletResponse parent = new MockServletResponse();
+ parent.addHeader(headerName, headerValue);
+ return new ServletResponse(parent);
+ }
+
+
+ @Test
+ public void headers_can_be_set() throws Exception {
+ String name = "myHeader";
+ String value = name + "Value";
+ filterResponse.setHeaders(name, value);
+
+ assertEquals(filterResponse.getHeader(name), value);
+ assertEquals(parentResponse.getHeader(name), value);
+ }
+
+ @Test
+ public void headers_can_be_added() throws Exception {
+ String newValue = "h2";
+ filterResponse.addHeader(headerName, newValue);
+
+ // The DiscFilterResponse has no getHeaders()
+ assertEquals(filterResponse.getHeader(headerName), newValue);
+
+ assertEquals(parentResponse.getHeaders(headerName), Arrays.asList(headerValue, newValue));
+ }
+
+ @Test
+ public void headers_can_be_removed() throws Exception {
+ filterResponse.removeHeaders(headerName);
+
+ assertEquals(filterResponse.getHeader(headerName), null);
+ assertEquals(parentResponse.getHeader(headerName), null);
+ }
+
+ @Test
+ public void set_cookie_overwrites_old_values() {
+ Cookie to_be_removed = new Cookie("to-be-removed", "");
+ Cookie to_keep = new Cookie("to-keep", "");
+ filterResponse.setCookie(to_be_removed.getName(), to_be_removed.getValue());
+ filterResponse.setCookie(to_keep.getName(), to_keep.getValue());
+
+ assertEquals(filterResponse.getCookies(), Arrays.asList(to_keep));
+ assertEquals(parentResponse.getHeaders(HttpHeaders.Names.SET_COOKIE), Arrays.asList(to_keep.toString()));
+ }
+
+
+ private static class MockServletResponse extends org.eclipse.jetty.server.Response {
+ private MockServletResponse() {
+ super(null, null);
+ }
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/guiceModules/ConnectorFactoryRegistryModule.java b/container-core/src/test/java/com/yahoo/jdisc/http/guiceModules/ConnectorFactoryRegistryModule.java
new file mode 100644
index 00000000000..cc2a00c08c6
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/guiceModules/ConnectorFactoryRegistryModule.java
@@ -0,0 +1,54 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.guiceModules;
+
+import com.google.inject.Binder;
+import com.google.inject.Module;
+import com.google.inject.Provides;
+import com.yahoo.component.ComponentId;
+import com.yahoo.component.provider.ComponentRegistry;
+import com.yahoo.jdisc.http.ConnectorConfig;
+import com.yahoo.jdisc.http.ConnectorConfig.Builder;
+
+import com.yahoo.jdisc.http.server.jetty.ConnectorFactory;
+import com.yahoo.jdisc.http.ssl.impl.ConfiguredSslContextFactoryProvider;
+
+/**
+ * Guice module for test ConnectorFactories
+ *
+ * @author Tony Vaagenes
+ */
+public class ConnectorFactoryRegistryModule implements Module {
+
+ private final Builder connectorConfigBuilder;
+
+ public ConnectorFactoryRegistryModule(Builder connectorConfigBuilder) {
+ this.connectorConfigBuilder = connectorConfigBuilder;
+ }
+
+ public ConnectorFactoryRegistryModule() {
+ this(new Builder());
+ }
+
+ @Provides
+ public ComponentRegistry connectorFactoryComponentRegistry() {
+ ComponentRegistry registry = new ComponentRegistry<>();
+ registry.register(ComponentId.createAnonymousComponentId("connector-factory"),
+ new StaticKeyDbConnectorFactory(new ConnectorConfig(connectorConfigBuilder)));
+
+ registry.freeze();
+ return registry;
+ }
+
+ @Override
+ public void configure(Binder binder) {
+ }
+
+ private static class StaticKeyDbConnectorFactory extends ConnectorFactory {
+
+ public StaticKeyDbConnectorFactory(ConnectorConfig connectorConfig) {
+ super(connectorConfig, new ConfiguredSslContextFactoryProvider(connectorConfig));
+ }
+
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/guiceModules/ServletModule.java b/container-core/src/test/java/com/yahoo/jdisc/http/guiceModules/ServletModule.java
new file mode 100644
index 00000000000..dd6511d1f88
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/guiceModules/ServletModule.java
@@ -0,0 +1,24 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.guiceModules;
+
+import com.google.inject.Binder;
+import com.google.inject.Module;
+import com.google.inject.Provides;
+import com.yahoo.component.provider.ComponentRegistry;
+
+import org.eclipse.jetty.servlet.ServletHolder;
+
+/**
+ * @author Tony Vaagenes
+ */
+public class ServletModule implements Module {
+ @Override
+ public void configure(Binder binder) {
+ }
+
+ @Provides
+ public ComponentRegistry servletHolderComponentRegistry() {
+ return new ComponentRegistry<>();
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/AccessLogRequestLogTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/AccessLogRequestLogTest.java
new file mode 100644
index 00000000000..6370912af48
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/AccessLogRequestLogTest.java
@@ -0,0 +1,156 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+import com.yahoo.container.logging.AccessLogEntry;
+import com.yahoo.container.logging.RequestLog;
+import com.yahoo.container.logging.RequestLogEntry;
+import com.yahoo.jdisc.http.ConnectorConfig;
+import com.yahoo.jdisc.http.ServerConfig;
+import org.eclipse.jetty.http.MetaData;
+import org.eclipse.jetty.server.HttpChannel;
+import org.eclipse.jetty.server.HttpConnection;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Response;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Oyvind Bakksjo
+ * @author bjorncs
+ */
+public class AccessLogRequestLogTest {
+ @Test
+ public void requireThatQueryWithUnquotedSpecialCharactersIsHandled() {
+ final Request jettyRequest = createRequestMock();
+ when(jettyRequest.getRequestURI()).thenReturn("/search/");
+ when(jettyRequest.getQueryString()).thenReturn("query=year:>2010");
+
+ InMemoryRequestLog requestLog = new InMemoryRequestLog();
+ doAccessLoggingOfRequest(requestLog, jettyRequest);
+ RequestLogEntry entry = requestLog.entries().get(0);
+
+ assertThat(entry.rawPath().get(), is(not(nullValue())));
+ assertTrue(entry.rawQuery().isPresent());
+ }
+
+ @Test
+ public void requireThatDoubleQuotingIsNotPerformed() {
+ final Request jettyRequest = createRequestMock();
+ final String path = "/search/";
+ when(jettyRequest.getRequestURI()).thenReturn(path);
+ final String query = "query=year%252010+%3B&customParameter=something";
+ when(jettyRequest.getQueryString()).thenReturn(query);
+
+ InMemoryRequestLog requestLog = new InMemoryRequestLog();
+ doAccessLoggingOfRequest(requestLog, jettyRequest);
+ RequestLogEntry entry = requestLog.entries().get(0);
+
+ assertThat(entry.rawPath().get(), is(path));
+ assertThat(entry.rawQuery().get(), is(query));
+
+ }
+
+ @Test
+ public void raw_path_and_query_are_set_from_request() {
+ Request jettyRequest = createRequestMock();
+ String rawPath = "//search/";
+ when(jettyRequest.getRequestURI()).thenReturn(rawPath);
+ String rawQuery = "q=%%2";
+ when(jettyRequest.getQueryString()).thenReturn(rawQuery);
+
+ InMemoryRequestLog requestLog = new InMemoryRequestLog();
+ doAccessLoggingOfRequest(requestLog, jettyRequest);
+ RequestLogEntry entry = requestLog.entries().get(0);
+ assertThat(entry.rawPath().get(), is(rawPath));
+ Optional actualRawQuery = entry.rawQuery();
+ assertThat(actualRawQuery.isPresent(), is(true));
+ assertThat(actualRawQuery.get(), is(rawQuery));
+ }
+
+ @Test
+ public void verify_x_forwarded_for_precedence () {
+ Request jettyRequest = createRequestMock();
+ when(jettyRequest.getRequestURI()).thenReturn("//search/");
+ when(jettyRequest.getQueryString()).thenReturn("q=%%2");
+ when(jettyRequest.getHeader("x-forwarded-for")).thenReturn("1.2.3.4");
+ when(jettyRequest.getHeader("y-ra")).thenReturn("2.3.4.5");
+
+ InMemoryRequestLog requestLog = new InMemoryRequestLog();
+ doAccessLoggingOfRequest(requestLog, jettyRequest);
+ RequestLogEntry entry = requestLog.entries().get(0);
+ assertThat(entry.remoteAddress().get(), is("1.2.3.4"));
+ }
+
+ @Test
+ public void verify_x_forwarded_port_precedence () {
+ Request jettyRequest = createRequestMock();
+ when(jettyRequest.getRequestURI()).thenReturn("//search/");
+ when(jettyRequest.getQueryString()).thenReturn("q=%%2");
+ when(jettyRequest.getHeader("X-Forwarded-Port")).thenReturn("80");
+ when(jettyRequest.getHeader("y-rp")).thenReturn("8080");
+
+ InMemoryRequestLog requestLog = new InMemoryRequestLog();
+ doAccessLoggingOfRequest(requestLog, jettyRequest);
+ RequestLogEntry entry = requestLog.entries().get(0);
+ assertThat(entry.remotePort().getAsInt(), is(80));
+ }
+
+ @Test
+ public void defaults_to_peer_port_if_remote_port_header_is_invalid() {
+ final Request jettyRequest = createRequestMock();
+ when(jettyRequest.getRequestURI()).thenReturn("/search/");
+ when(jettyRequest.getHeader("X-Forwarded-Port")).thenReturn("8o8o");
+ when(jettyRequest.getRemotePort()).thenReturn(80);
+
+ InMemoryRequestLog requestLog = new InMemoryRequestLog();
+ doAccessLoggingOfRequest(requestLog, jettyRequest);
+ RequestLogEntry entry = requestLog.entries().get(0);
+ assertFalse(entry.remotePort().isPresent());
+ assertThat(entry.peerPort().getAsInt(), is(80));
+ }
+
+ private void doAccessLoggingOfRequest(RequestLog requestLog, Request jettyRequest) {
+ ServerConfig.AccessLog config = new ServerConfig.AccessLog(
+ new ServerConfig.AccessLog.Builder()
+ .remoteAddressHeaders(List.of("x-forwarded-for", "y-ra"))
+ .remotePortHeaders(List.of("X-Forwarded-Port", "y-rp")));
+ new AccessLogRequestLog(requestLog, config).log(jettyRequest, createResponseMock());
+ }
+
+ private static Request createRequestMock() {
+ JDiscServerConnector serverConnector = mock(JDiscServerConnector.class);
+ int localPort = 1234;
+ when(serverConnector.connectorConfig()).thenReturn(new ConnectorConfig(new ConnectorConfig.Builder().listenPort(localPort)));
+ when(serverConnector.getLocalPort()).thenReturn(localPort);
+ HttpConnection httpConnection = mock(HttpConnection.class);
+ when(httpConnection.getConnector()).thenReturn(serverConnector);
+ Request request = mock(Request.class);
+ when(request.getMethod()).thenReturn("GET");
+ when(request.getRemoteAddr()).thenReturn("localhost");
+ when(request.getRemotePort()).thenReturn(12345);
+ when(request.getProtocol()).thenReturn("HTTP/1.1");
+ when(request.getScheme()).thenReturn("http");
+ when(request.getTimeStamp()).thenReturn(0L);
+ when(request.getAttribute(JDiscHttpServlet.ATTRIBUTE_NAME_ACCESS_LOG_ENTRY)).thenReturn(new AccessLogEntry());
+ when(request.getAttribute("org.eclipse.jetty.server.HttpConnection")).thenReturn(httpConnection);
+ return request;
+ }
+
+ private Response createResponseMock() {
+ Response response = mock(Response.class);
+ when(response.getHttpChannel()).thenReturn(mock(HttpChannel.class));
+ when(response.getCommittedMetaData()).thenReturn(mock(MetaData.Response.class));
+ return response;
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/BlockingQueueRequestLog.java b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/BlockingQueueRequestLog.java
new file mode 100644
index 00000000000..c1a2bea8ac4
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/BlockingQueueRequestLog.java
@@ -0,0 +1,24 @@
+// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+import com.yahoo.container.logging.RequestLog;
+import com.yahoo.container.logging.RequestLogEntry;
+
+import java.time.Duration;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author bjorncs
+ */
+class BlockingQueueRequestLog implements RequestLog {
+
+ private final BlockingQueue entries = new LinkedBlockingDeque<>();
+
+ @Override public void log(RequestLogEntry entry) { entries.offer(entry); }
+
+ RequestLogEntry poll(Duration timeout) throws InterruptedException {
+ return entries.poll(timeout.toMillis(), TimeUnit.MILLISECONDS);
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ConnectionThrottlerTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ConnectionThrottlerTest.java
new file mode 100644
index 00000000000..65eb7e1c145
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ConnectionThrottlerTest.java
@@ -0,0 +1,78 @@
+// Copyright 2019 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+import com.yahoo.jdisc.http.ConnectorConfig;
+import org.eclipse.jetty.server.AbstractConnector;
+import org.eclipse.jetty.util.component.AbstractLifeCycle;
+import org.eclipse.jetty.util.statistic.RateStatistic;
+import org.eclipse.jetty.util.thread.Scheduler;
+import org.junit.Test;
+
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.internal.verification.VerificationModeFactory.times;
+
+/**
+ * @author bjorncs
+ */
+public class ConnectionThrottlerTest {
+
+ @Test
+ public void throttles_when_any_resource_check_exceeds_configured_threshold() {
+ Runtime runtime = mock(Runtime.class);
+ when(runtime.maxMemory()).thenReturn(100l);
+ RateStatistic rateStatistic = new RateStatistic(1, TimeUnit.HOURS);
+ MockScheduler scheduler = new MockScheduler();
+ ConnectorConfig.Throttling config = new ConnectorConfig.Throttling(new ConnectorConfig.Throttling.Builder()
+ .maxHeapUtilization(0.8)
+ .maxAcceptRate(1));
+
+ AbstractConnector connector = mock(AbstractConnector.class);
+
+ ConnectionThrottler throttler = new ConnectionThrottler(runtime, rateStatistic, scheduler, connector, config);
+
+ // Heap utilization above configured threshold, but connection rate below threshold.
+ when(runtime.freeMemory()).thenReturn(10l);
+ when(connector.isAccepting()).thenReturn(true);
+ throttler.onAccepting(null);
+ assertNotNull(scheduler.task);
+ verify(connector).setAccepting(false);
+
+ // Heap utilization below threshold, but connection rate above threshold.
+ when(runtime.freeMemory()).thenReturn(80l);
+ rateStatistic.record();
+ rateStatistic.record(); // above accept rate limit (2 > 1)
+ scheduler.task.run(); // run unthrottleIfBelowThresholds()
+ verify(connector, times(1)).setAccepting(anyBoolean()); // verify setAccepting has not been called any mores times
+
+ // Both heap utilization and accept rate below threshold
+ when(runtime.freeMemory()).thenReturn(80l);
+ when(connector.isAccepting()).thenReturn(false);
+ rateStatistic.reset();
+ scheduler.task.run(); // run unthrottleIfBelowThresholds()
+ verify(connector).setAccepting(true);
+
+ // Both heap utilization and accept rate below threshold
+ when(connector.isAccepting()).thenReturn(true);
+ when(runtime.freeMemory()).thenReturn(80l);
+ rateStatistic.record();
+ throttler.onAccepting(null);
+ verify(connector, times(2)).setAccepting(anyBoolean()); // verify setAccepting has not been called any mores times
+ }
+
+ private static class MockScheduler extends AbstractLifeCycle implements Scheduler {
+ Runnable task;
+
+ @Override
+ public Task schedule(Runnable task, long delay, TimeUnit units) {
+ this.task = task;
+ return () -> false;
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ConnectorFactoryTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ConnectorFactoryTest.java
new file mode 100644
index 00000000000..df794c7ecb8
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ConnectorFactoryTest.java
@@ -0,0 +1,83 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+import com.yahoo.jdisc.Metric;
+import com.yahoo.jdisc.http.ConnectorConfig;
+import com.yahoo.jdisc.http.ServerConfig;
+import com.yahoo.jdisc.http.ssl.impl.ConfiguredSslContextFactoryProvider;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.handler.AbstractHandler;
+import org.junit.Test;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.Map;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+
+/**
+ * @author Einar M R Rosenvinge
+ */
+public class ConnectorFactoryTest {
+
+ @Test
+ public void requireThatServerCanBindChannel() throws Exception {
+ Server server = new Server();
+ try {
+ ConnectorConfig config = new ConnectorConfig(new ConnectorConfig.Builder());
+ ConnectorFactory factory = createConnectorFactory(config);
+ JettyConnectionLogger connectionLogger = new JettyConnectionLogger(
+ new ServerConfig.ConnectionLog.Builder().enabled(false).build(),
+ new VoidConnectionLog());
+ JDiscServerConnector connector =
+ (JDiscServerConnector)factory.createConnector(new DummyMetric(), server, connectionLogger);
+ server.addConnector(connector);
+ server.setHandler(new HelloWorldHandler());
+ server.start();
+
+ SimpleHttpClient client = new SimpleHttpClient(null, connector.getLocalPort(), false);
+ SimpleHttpClient.RequestExecutor ex = client.newGet("/blaasdfnb");
+ SimpleHttpClient.ResponseValidator val = ex.execute();
+ val.expectContent(equalTo("Hello world"));
+ } finally {
+ try {
+ server.stop();
+ } catch (Exception e) {
+ //ignore
+ }
+ }
+ }
+
+ private static ConnectorFactory createConnectorFactory(ConnectorConfig config) {
+ return new ConnectorFactory(config, new ConfiguredSslContextFactoryProvider(config));
+ }
+
+ private static class HelloWorldHandler extends AbstractHandler {
+ @Override
+ public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException {
+ response.getWriter().write("Hello world");
+ response.getWriter().flush();
+ response.getWriter().close();
+ baseRequest.setHandled(true);
+ }
+ }
+
+ private static class DummyMetric implements Metric {
+ @Override
+ public void set(String key, Number val, Context ctx) { }
+
+ @Override
+ public void add(String key, Number val, Context ctx) { }
+
+ @Override
+ public Context createContext(Map properties) {
+ return new DummyContext();
+ }
+ }
+
+ private static class DummyContext implements Metric.Context {
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ErrorResponseContentCreatorTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ErrorResponseContentCreatorTest.java
new file mode 100644
index 00000000000..d66f22801f7
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ErrorResponseContentCreatorTest.java
@@ -0,0 +1,44 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+
+import org.junit.Test;
+
+import javax.servlet.http.HttpServletResponse;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+
+
+/**
+ * @author bjorncs
+ */
+public class ErrorResponseContentCreatorTest {
+
+ @Test
+ public void response_content_matches_expected_string() {
+ String expectedHtml =
+ "\n" +
+ "\n" +
+ "\n" +
+ "Error 200\n" +
+ "\n" +
+ "\n" +
+ "HTTP ERROR: 200
\n" +
+ "Problem accessing http://foo.bar. Reason:\n" +
+ "
My custom error message
\n" +
+ "
\n" +
+ "\n" +
+ "\n";
+
+ ErrorResponseContentCreator c = new ErrorResponseContentCreator();
+ byte[] rawContent = c.createErrorContent(
+ "http://foo.bar",
+ HttpServletResponse.SC_OK,
+ Optional.of("My custom error message"));
+ String actualHtml = new String(rawContent, StandardCharsets.ISO_8859_1);
+ assertEquals(expectedHtml, actualHtml);
+ }
+
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ExceptionWrapperTest.java b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ExceptionWrapperTest.java
new file mode 100644
index 00000000000..de8df283afe
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/ExceptionWrapperTest.java
@@ -0,0 +1,51 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * Check basic error message formatting. Do note these tests are sensitive to
+ * the line numbering in this file. (And that's a feature, not a bug.)
+ *
+ * @author Steinar Knutsen
+ */
+public class ExceptionWrapperTest {
+
+ @Test
+ public final void requireNoMessageIsOK() {
+ final Throwable t = new Throwable();
+ final ExceptionWrapper e = new ExceptionWrapper(t);
+ final String expected = "Throwable() at com.yahoo.jdisc.http.server.jetty.ExceptionWrapperTest(ExceptionWrapperTest.java:19)";
+
+ assertThat(e.getMessage(), equalTo(expected));
+ }
+
+ @Test
+ public final void requireAllWrappedLevelsShowUp() {
+ final Throwable t0 = new Throwable("t0");
+ final Throwable t1 = new Throwable("t1", t0);
+ final Throwable t2 = new Throwable("t2", t1);
+ final ExceptionWrapper e = new ExceptionWrapper(t2);
+ final String expected = "Throwable(\"t2\") at com.yahoo.jdisc.http.server.jetty.ExceptionWrapperTest(ExceptionWrapperTest.java:30):"
+ + " Throwable(\"t1\") at com.yahoo.jdisc.http.server.jetty.ExceptionWrapperTest(ExceptionWrapperTest.java:29):"
+ + " Throwable(\"t0\") at com.yahoo.jdisc.http.server.jetty.ExceptionWrapperTest(ExceptionWrapperTest.java:28)";
+
+ assertThat(e.getMessage(), equalTo(expected));
+ }
+
+ @Test
+ public final void requireMixOfMessageAndNoMessageWorks() {
+ final Throwable t0 = new Throwable("t0");
+ final Throwable t1 = new Throwable(t0);
+ final Throwable t2 = new Throwable("t2", t1);
+ final ExceptionWrapper e = new ExceptionWrapper(t2);
+ final String expected = "Throwable(\"t2\") at com.yahoo.jdisc.http.server.jetty.ExceptionWrapperTest(ExceptionWrapperTest.java:43):"
+ + " Throwable(\"java.lang.Throwable: t0\") at com.yahoo.jdisc.http.server.jetty.ExceptionWrapperTest(ExceptionWrapperTest.java:42):"
+ + " Throwable(\"t0\") at com.yahoo.jdisc.http.server.jetty.ExceptionWrapperTest(ExceptionWrapperTest.java:41)";
+
+ assertThat(e.getMessage(), equalTo(expected));
+ }
+}
diff --git a/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/FilterTestCase.java b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/FilterTestCase.java
new file mode 100644
index 00000000000..a67656dd5ca
--- /dev/null
+++ b/container-core/src/test/java/com/yahoo/jdisc/http/server/jetty/FilterTestCase.java
@@ -0,0 +1,667 @@
+// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.util.Modules;
+import com.yahoo.container.logging.ConnectionLog;
+import com.yahoo.container.logging.RequestLog;
+import com.yahoo.jdisc.AbstractResource;
+import com.yahoo.jdisc.Request;
+import com.yahoo.jdisc.ResourceReference;
+import com.yahoo.jdisc.Response;
+import com.yahoo.jdisc.handler.AbstractRequestHandler;
+import com.yahoo.jdisc.handler.CompletionHandler;
+import com.yahoo.jdisc.handler.ContentChannel;
+import com.yahoo.jdisc.handler.ResponseDispatch;
+import com.yahoo.jdisc.handler.ResponseHandler;
+import com.yahoo.jdisc.http.ConnectorConfig;
+import com.yahoo.jdisc.http.HttpRequest;
+import com.yahoo.jdisc.http.HttpResponse;
+import com.yahoo.jdisc.http.ServerConfig;
+import com.yahoo.jdisc.http.ServletPathsConfig;
+import com.yahoo.jdisc.http.filter.RequestFilter;
+import com.yahoo.jdisc.http.filter.ResponseFilter;
+import com.yahoo.jdisc.http.filter.ResponseHeaderFilter;
+import com.yahoo.jdisc.http.filter.chain.RequestFilterChain;
+import com.yahoo.jdisc.http.filter.chain.ResponseFilterChain;
+import com.yahoo.jdisc.http.guiceModules.ConnectorFactoryRegistryModule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Oyvind Bakksjo
+ * @author bjorncs
+ */
+public class FilterTestCase {
+ @Test
+ public void requireThatRequestFilterIsNotRunOnUnboundPath() throws Exception {
+ RequestFilterMockBase filter = mock(RequestFilterMockBase.class);
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", filter)
+ .addRequestFilterBinding("my-request-filter", "http://*/filtered/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(filter, never()).filter(any(HttpRequest.class), any(ResponseHandler.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatRequestFilterIsRunOnBoundPath() throws Exception {
+ final RequestFilter filter = mock(RequestFilterMockBase.class);
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", filter)
+ .addRequestFilterBinding("my-request-filter", "http://*/filtered/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/filtered/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(filter, times(1)).filter(any(HttpRequest.class), any(ResponseHandler.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatRequestFilterChangesAreSeenByRequestHandler() throws Exception {
+ final RequestFilter filter = new HeaderRequestFilter("foo", "bar");
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", filter)
+ .addRequestFilterBinding("my-request-filter", "http://*/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ assertThat(requestHandler.getHeaderMap().get("foo").get(0), is("bar"));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatRequestFilterCanRespond() throws Exception {
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", new RespondForbiddenFilter())
+ .addRequestFilterBinding("my-request-filter", "http://*/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html").expectStatusCode(is(Response.Status.FORBIDDEN));
+
+ assertThat(requestHandler.hasBeenInvokedYet(), is(false));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatFilterCanHaveNullCompletionHandler() throws Exception {
+ final int responseStatus = Response.Status.OK;
+ final String responseMessage = "Excellent";
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", new NullCompletionHandlerFilter(responseStatus, responseMessage))
+ .addRequestFilterBinding("my-request-filter", "http://*/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html")
+ .expectStatusCode(is(responseStatus))
+ .expectContent(is(responseMessage));
+
+ assertThat(requestHandler.hasBeenInvokedYet(), is(false));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatRequestFilterExecutionIsExceptionSafe() throws Exception {
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", new ThrowingRequestFilter())
+ .addRequestFilterBinding("my-request-filter", "http://*/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html").expectStatusCode(is(Response.Status.INTERNAL_SERVER_ERROR));
+
+ assertThat(requestHandler.hasBeenInvokedYet(), is(false));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatResponseFilterIsNotRunOnUnboundPath() throws Exception {
+ final ResponseFilter filter = mock(ResponseFilterMockBase.class);
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addResponseFilter("my-response-filter", filter)
+ .addResponseFilterBinding("my-response-filter", "http://*/filtered/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(filter, never()).filter(any(Response.class), any(Request.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatResponseFilterIsRunOnBoundPath() throws Exception {
+ final ResponseFilter filter = mock(ResponseFilterMockBase.class);
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addResponseFilter("my-response-filter", filter)
+ .addResponseFilterBinding("my-response-filter", "http://*/filtered/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/filtered/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(filter, times(1)).filter(any(Response.class), any(Request.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatResponseFilterChangesAreWrittenToResponse() throws Exception {
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addResponseFilter("my-response-filter", new HeaderResponseFilter("foo", "bar"))
+ .addResponseFilterBinding("my-response-filter", "http://*/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html")
+ .expectHeader("foo", is("bar"));
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatResponseFilterExecutionIsExceptionSafe() throws Exception {
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addResponseFilter("my-response-filter", new ThrowingResponseFilter())
+ .addResponseFilterBinding("my-response-filter", "http://*/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html").expectStatusCode(is(Response.Status.INTERNAL_SERVER_ERROR));
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatRequestFilterAndResponseFilterCanBindToSamePath() throws Exception {
+ final RequestFilter requestFilter = mock(RequestFilterMockBase.class);
+ final ResponseFilter responseFilter = mock(ResponseFilterMockBase.class);
+ final String uriPattern = "http://*/*";
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", requestFilter)
+ .addRequestFilterBinding("my-request-filter", uriPattern)
+ .addResponseFilter("my-response-filter", responseFilter)
+ .addResponseFilterBinding("my-response-filter", uriPattern)
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(requestFilter, times(1)).filter(any(HttpRequest.class), any(ResponseHandler.class));
+ verify(responseFilter, times(1)).filter(any(Response.class), any(Request.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatResponseFromRequestFilterGoesThroughResponseFilter() throws Exception {
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", new RespondForbiddenFilter())
+ .addRequestFilterBinding("my-request-filter", "http://*/*")
+ .addResponseFilter("my-response-filter", new HeaderResponseFilter("foo", "bar"))
+ .addResponseFilterBinding("my-response-filter", "http://*/*")
+ .build();
+ final MyRequestHandler requestHandler = new MyRequestHandler();
+ final TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html")
+ .expectStatusCode(is(Response.Status.FORBIDDEN))
+ .expectHeader("foo", is("bar"));
+
+ assertThat(requestHandler.hasBeenInvokedYet(), is(false));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatRequestFilterChainRetainsFilters() {
+ final RequestFilter requestFilter1 = mock(RequestFilter.class);
+ final RequestFilter requestFilter2 = mock(RequestFilter.class);
+
+ verify(requestFilter1, never()).refer();
+ verify(requestFilter2, never()).refer();
+ final ResourceReference reference1 = mock(ResourceReference.class);
+ final ResourceReference reference2 = mock(ResourceReference.class);
+ when(requestFilter1.refer()).thenReturn(reference1);
+ when(requestFilter2.refer()).thenReturn(reference2);
+ final RequestFilter chain = RequestFilterChain.newInstance(requestFilter1, requestFilter2);
+ verify(requestFilter1, times(1)).refer();
+ verify(requestFilter2, times(1)).refer();
+
+ verify(reference1, never()).close();
+ verify(reference2, never()).close();
+ chain.release();
+ verify(reference1, times(1)).close();
+ verify(reference2, times(1)).close();
+ }
+
+ @Test
+ public void requireThatRequestFilterChainIsRun() throws Exception {
+ final RequestFilter requestFilter1 = mock(RequestFilter.class);
+ final RequestFilter requestFilter2 = mock(RequestFilter.class);
+ final RequestFilter requestFilterChain = RequestFilterChain.newInstance(requestFilter1, requestFilter2);
+ final HttpRequest request = null;
+ final ResponseHandler responseHandler = null;
+ requestFilterChain.filter(request, responseHandler);
+ verify(requestFilter1).filter(isNull(), any(ResponseHandler.class));
+ verify(requestFilter2).filter(isNull(), any(ResponseHandler.class));
+ }
+
+ @Test
+ public void requireThatRequestFilterChainCallsFilterWithOriginalRequest() throws Exception {
+ final RequestFilter requestFilter = mock(RequestFilter.class);
+ final RequestFilter requestFilterChain = RequestFilterChain.newInstance(requestFilter);
+ final HttpRequest request = mock(HttpRequest.class);
+ final ResponseHandler responseHandler = null;
+ requestFilterChain.filter(request, responseHandler);
+
+ // Check that the filter is called with the same request argument as the chain was,
+ // in a manner that allows the request object to be wrapped.
+ final ArgumentCaptor requestCaptor = ArgumentCaptor.forClass(HttpRequest.class);
+ verify(requestFilter).filter(requestCaptor.capture(), isNull());
+ verify(request, never()).getUri();
+ requestCaptor.getValue().getUri();
+ verify(request, times(1)).getUri();
+ }
+
+ @Test
+ public void requireThatRequestFilterChainCallsFilterWithOriginalResponseHandler() throws Exception {
+ final RequestFilter requestFilter = mock(RequestFilter.class);
+ final RequestFilter requestFilterChain = RequestFilterChain.newInstance(requestFilter);
+ final HttpRequest request = null;
+ final ResponseHandler responseHandler = mock(ResponseHandler.class);
+ requestFilterChain.filter(request, responseHandler);
+
+ // Check that the filter is called with the same response handler argument as the chain was,
+ // in a manner that allows the handler object to be wrapped.
+ final ArgumentCaptor responseHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class);
+ verify(requestFilter).filter(isNull(), responseHandlerCaptor.capture());
+ verify(responseHandler, never()).handleResponse(any(Response.class));
+ responseHandlerCaptor.getValue().handleResponse(mock(Response.class));
+ verify(responseHandler, times(1)).handleResponse(any(Response.class));
+ }
+
+ @Test
+ public void requireThatRequestFilterCanTerminateChain() throws Exception {
+ final RequestFilter requestFilter1 = new RespondForbiddenFilter();
+ final RequestFilter requestFilter2 = mock(RequestFilter.class);
+ final RequestFilter requestFilterChain = RequestFilterChain.newInstance(requestFilter1, requestFilter2);
+ final HttpRequest request = null;
+ final ResponseHandler responseHandler = mock(ResponseHandler.class);
+ when(responseHandler.handleResponse(any(Response.class))).thenReturn(mock(ContentChannel.class));
+
+ requestFilterChain.filter(request, responseHandler);
+
+ verify(requestFilter2, never()).filter(any(HttpRequest.class), any(ResponseHandler.class));
+
+ final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(Response.class);
+ verify(responseHandler).handleResponse(responseCaptor.capture());
+ assertThat(responseCaptor.getValue().getStatus(), is(Response.Status.FORBIDDEN));
+ }
+
+ @Test
+ public void requireThatResponseFilterChainRetainsFilters() {
+ final ResponseFilter responseFilter1 = mock(ResponseFilter.class);
+ final ResponseFilter responseFilter2 = mock(ResponseFilter.class);
+
+ verify(responseFilter1, never()).refer();
+ verify(responseFilter2, never()).refer();
+ final ResourceReference reference1 = mock(ResourceReference.class);
+ final ResourceReference reference2 = mock(ResourceReference.class);
+ when(responseFilter1.refer()).thenReturn(reference1);
+ when(responseFilter2.refer()).thenReturn(reference2);
+ final ResponseFilter chain = ResponseFilterChain.newInstance(responseFilter1, responseFilter2);
+ verify(responseFilter1, times(1)).refer();
+ verify(responseFilter2, times(1)).refer();
+
+ verify(reference1, never()).close();
+ verify(reference2, never()).close();
+ chain.release();
+ verify(reference1, times(1)).close();
+ verify(reference2, times(1)).close();
+ }
+
+ @Test
+ public void requireThatResponseFilterChainIsRun() {
+ final ResponseFilter responseFilter1 = new ResponseHeaderFilter("foo", "bar");
+ final ResponseFilter responseFilter2 = mock(ResponseFilter.class);
+ final int statusCode = Response.Status.BAD_GATEWAY;
+ final Response response = new Response(statusCode);
+ final Request request = null;
+
+ ResponseFilterChain.newInstance(responseFilter1, responseFilter2).filter(response, request);
+
+ final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(Response.class);
+ verify(responseFilter2).filter(responseCaptor.capture(), isNull());
+ assertThat(responseCaptor.getValue().getStatus(), is(statusCode));
+ assertThat(responseCaptor.getValue().headers().getFirst("foo"), is("bar"));
+
+ assertThat(response.getStatus(), is(statusCode));
+ assertThat(response.headers().getFirst("foo"), is("bar"));
+ }
+
+ @Test
+ public void requireThatDefaultRequestFilterChainIsRunIfNoOtherFilterChainMatches() throws IOException, InterruptedException {
+ RequestFilter filterWithBinding = mock(RequestFilter.class);
+ RequestFilter defaultFilter = mock(RequestFilter.class);
+ String defaultFilterId = "default-request-filter";
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", filterWithBinding)
+ .addRequestFilterBinding("my-request-filter", "http://*/filtered/*")
+ .addRequestFilter(defaultFilterId, defaultFilter)
+ .setRequestFilterDefaultForPort(defaultFilterId, 0)
+ .build();
+ MyRequestHandler requestHandler = new MyRequestHandler();
+ TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(defaultFilter, times(1)).filter(any(HttpRequest.class), any(ResponseHandler.class));
+ verify(filterWithBinding, never()).filter(any(HttpRequest.class), any(ResponseHandler.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatDefaultResponseFilterChainIsRunIfNoOtherFilterChainMatches() throws IOException, InterruptedException {
+ ResponseFilter filterWithBinding = mock(ResponseFilter.class);
+ ResponseFilter defaultFilter = mock(ResponseFilter.class);
+ String defaultFilterId = "default-response-filter";
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addResponseFilter("my-response-filter", filterWithBinding)
+ .addResponseFilterBinding("my-response-filter", "http://*/filtered/*")
+ .addResponseFilter(defaultFilterId, defaultFilter)
+ .setResponseFilterDefaultForPort(defaultFilterId, 0)
+ .build();
+ MyRequestHandler requestHandler = new MyRequestHandler();
+ TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(defaultFilter, times(1)).filter(any(Response.class), any(Request.class));
+ verify(filterWithBinding, never()).filter(any(Response.class), any(Request.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatRequestFilterWithBindingMatchHasPrecedenceOverDefaultFilter() throws IOException, InterruptedException {
+ RequestFilterMockBase filterWithBinding = mock(RequestFilterMockBase.class);
+ RequestFilterMockBase defaultFilter = mock(RequestFilterMockBase.class);
+ String defaultFilterId = "default-request-filter";
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", filterWithBinding)
+ .addRequestFilterBinding("my-request-filter", "http://*/filtered/*")
+ .addRequestFilter(defaultFilterId, defaultFilter)
+ .setRequestFilterDefaultForPort(defaultFilterId, 0)
+ .build();
+ MyRequestHandler requestHandler = new MyRequestHandler();
+ TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/filtered/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(defaultFilter, never()).filter(any(HttpRequest.class), any(ResponseHandler.class));
+ verify(filterWithBinding).filter(any(HttpRequest.class), any(ResponseHandler.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatResponseFilterWithBindingMatchHasPrecedenceOverDefaultFilter() throws IOException, InterruptedException {
+ ResponseFilter filterWithBinding = mock(ResponseFilter.class);
+ ResponseFilter defaultFilter = mock(ResponseFilter.class);
+ String defaultFilterId = "default-response-filter";
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addResponseFilter("my-response-filter", filterWithBinding)
+ .addResponseFilterBinding("my-response-filter", "http://*/filtered/*")
+ .addResponseFilter(defaultFilterId, defaultFilter)
+ .setResponseFilterDefaultForPort(defaultFilterId, 0)
+ .build();
+ MyRequestHandler requestHandler = new MyRequestHandler();
+ TestDriver testDriver = newDriver(requestHandler, filterBindings);
+
+ testDriver.client().get("/filtered/status.html");
+
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(defaultFilter, never()).filter(any(Response.class), any(Request.class));
+ verify(filterWithBinding, times(1)).filter(any(Response.class), any(Request.class));
+
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatMetricAreReported() throws IOException, InterruptedException {
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", mock(RequestFilter.class))
+ .addRequestFilterBinding("my-request-filter", "http://*/*")
+ .build();
+ MetricConsumerMock metricConsumerMock = new MetricConsumerMock();
+ MyRequestHandler requestHandler = new MyRequestHandler();
+ TestDriver testDriver = newDriver(requestHandler, filterBindings, metricConsumerMock, false);
+
+ testDriver.client().get("/status.html");
+ assertThat(requestHandler.awaitInvocation(), is(true));
+ verify(metricConsumerMock.mockitoMock())
+ .add(MetricDefinitions.FILTERING_REQUEST_HANDLED, 1L, MetricConsumerMock.STATIC_CONTEXT);
+ verify(metricConsumerMock.mockitoMock(), never())
+ .add(MetricDefinitions.FILTERING_REQUEST_UNHANDLED, 1L, MetricConsumerMock.STATIC_CONTEXT);
+ verify(metricConsumerMock.mockitoMock(), never())
+ .add(MetricDefinitions.FILTERING_RESPONSE_HANDLED, 1L, MetricConsumerMock.STATIC_CONTEXT);
+ verify(metricConsumerMock.mockitoMock())
+ .add(MetricDefinitions.FILTERING_RESPONSE_UNHANDLED, 1L, MetricConsumerMock.STATIC_CONTEXT);
+ assertThat(testDriver.close(), is(true));
+ }
+
+ @Test
+ public void requireThatStrictFilteringRejectsRequestsNotMatchingFilterChains() throws IOException {
+ RequestFilter filter = mock(RequestFilter.class);
+ FilterBindings filterBindings = new FilterBindings.Builder()
+ .addRequestFilter("my-request-filter", filter)
+ .addRequestFilterBinding("my-request-filter", "http://*/filtered/*")
+ .build();
+ MyRequestHandler requestHandler = new MyRequestHandler();
+ TestDriver testDriver = newDriver(requestHandler, filterBindings, new MetricConsumerMock(), true);
+
+ testDriver.client().get("/unfiltered/")
+ .expectStatusCode(is(Response.Status.FORBIDDEN))
+ .expectContent(containsString("Request did not match any request filter chain"));
+ verify(filter, never()).filter(any(), any());
+ assertThat(testDriver.close(), is(true));
+ }
+
+ private static TestDriver newDriver(MyRequestHandler requestHandler, FilterBindings filterBindings) {
+ return newDriver(requestHandler, filterBindings, new MetricConsumerMock(), false);
+ }
+
+ private static TestDriver newDriver(
+ MyRequestHandler requestHandler,
+ FilterBindings filterBindings,
+ MetricConsumerMock metricConsumer,
+ boolean strictFiltering) {
+ return TestDriver.newInstance(
+ JettyHttpServer.class,
+ requestHandler,
+ newFilterModule(filterBindings, metricConsumer, strictFiltering));
+ }
+
+ private static com.google.inject.Module newFilterModule(
+ FilterBindings filterBindings, MetricConsumerMock metricConsumer, boolean strictFiltering) {
+ return Modules.combine(
+ new AbstractModule() {
+ @Override
+ protected void configure() {
+
+ bind(FilterBindings.class).toInstance(filterBindings);
+ bind(ServerConfig.class).toInstance(new ServerConfig(new ServerConfig.Builder().strictFiltering(strictFiltering)));
+ bind(ConnectorConfig.class).toInstance(new ConnectorConfig(new ConnectorConfig.Builder()));
+ bind(ServletPathsConfig.class).toInstance(new ServletPathsConfig(new ServletPathsConfig.Builder()));
+ bind(ConnectionLog.class).toInstance(new VoidConnectionLog());
+ bind(RequestLog.class).toInstance(new VoidRequestLog());
+ }
+ },
+ new ConnectorFactoryRegistryModule(),
+ metricConsumer.asGuiceModule());
+ }
+
+ private static abstract class RequestFilterMockBase extends AbstractResource implements RequestFilter {}
+ private static abstract class ResponseFilterMockBase extends AbstractResource implements ResponseFilter {}
+
+ private static class MyRequestHandler extends AbstractRequestHandler {
+ private final CountDownLatch invocationLatch = new CountDownLatch(1);
+ private final AtomicReference