Add test java source files from jdisc_http_service.

11 files changed, 1159 insertions, 0 deletions

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<Cookie> cookies = new ArrayList<Cookie>();
+		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<Cookie> 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<String> e = request.getAttributeNames();
+		List<String> 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&param2=xyz&param2=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<String> values = request.getParameterValuesAsList("param2");
+        Assert.assertEquals(values.get(0),"xyz");
+        Assert.assertEquals(values.get(1),"pqr");
+
+        List<String> paramNames = request.getParameterNamesAsList();
+        Assert.assertEquals(paramNames.size(), 2);
+
+	}
+
+	@Test
+	public void testParameterAPI(){
+	    URI uri = URI.create("http://example.yahoo.com:8080/test?param1=abc&param2=xyz&param2=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<String> values = request.getParameterValues("param2");
+        List<String> valuesList = Collections.list(values);
+        Assert.assertEquals(valuesList.get(0),"xyz");
+        Assert.assertEquals(valuesList.get(1),"pqr");
+
+        Enumeration<String> paramNames = request.getParameterNames();
+        List<String> 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<Cookie> 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<String> 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<Cookie> 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<Cookie> 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<SecurityRequestFilter> requestFilters = new ArrayList<SecurityRequestFilter>();
+        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<String> 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);
+        }
+    }
+
+}