/**
* Copyright (c) 2009-2011 VMware, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.springsource.insight.plugin.apache.http.hc4;
import java.io.IOException;
import java.io.Writer;
import java.net.URI;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicReference;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpMessage;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.RequestLine;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.utils.URIUtils;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
import org.mortbay.jetty.Handler;
import org.mortbay.jetty.HttpConnection;
import org.mortbay.jetty.Request;
import org.mortbay.jetty.Server;
import com.springsource.insight.collection.ObscuredValueSetMarker;
import com.springsource.insight.collection.http.HttpObfuscator;
import com.springsource.insight.collection.test.OperationCollectionAspectTestSupport;
import com.springsource.insight.intercept.operation.Operation;
import com.springsource.insight.intercept.operation.OperationFields;
import com.springsource.insight.intercept.operation.OperationList;
import com.springsource.insight.intercept.operation.OperationMap;
import com.springsource.insight.intercept.operation.OperationUtils;
import com.springsource.insight.util.ArrayUtil;
import com.springsource.insight.util.MapUtil;
import com.springsource.insight.util.StringFormatterUtils;
import com.springsource.insight.util.StringUtil;
/**
* Tests {@link HttpClientExecutionCollectionAspect} using embedded
* Jetty server
*/
public class HttpClientExecutionCollectionAspectTest extends OperationCollectionAspectTestSupport {
private static final int TEST_PORT = 7365;
private static final String TEST_URI = "http://localhost:" + TEST_PORT + "/";
private static Server SERVER;
private HttpObfuscator originalObfuscator;
private final ObscuredValueSetMarker marker = new ObscuredValueSetMarker();
public HttpClientExecutionCollectionAspectTest() {
super();
}
@BeforeClass
public static void startEmbeddedServer() throws Exception {
SERVER = new Server(TEST_PORT);
SERVER.setHandler(new TestHandler());
System.out.println("Starting embedded server on port " + TEST_PORT);
SERVER.start();
System.out.println("Started embedded server on port " + TEST_PORT);
}
@AfterClass
public static void stopEmbeddedServer() throws Exception {
if (SERVER != null) {
System.out.println("Stopping embedded server");
SERVER.stop();
System.out.println("Server stopped");
}
}
@Before
@Override
public void setUp() {
super.setUp();
HttpClientExecutionCollectionAspect aspectInstance = getAspect();
originalObfuscator = aspectInstance.getHttpHeadersObfuscator();
marker.clear();
aspectInstance.setHttpHeadersObfuscator(new HttpObfuscator(marker));
}
@After
@Override
public void restore() {
HttpClientExecutionCollectionAspect aspectInstance = getAspect();
aspectInstance.setHttpHeadersObfuscator(originalObfuscator);
marker.clear();
super.restore();
}
@Test
public void testHttpUriRequest() throws IOException {
runHttpUriRequestTest("testHttpUriRequest", null);
}
@Test
public void testHttpUriRequestWithContext() throws IOException {
runHttpUriRequestTest("testHttpUriRequestWithContext", new BasicHttpContext());
}
@Test
public void testHttpHostUriRequest() throws Exception {
runHttpHostRequestTest("testHttpHostUriRequest", null);
}
@Test
public void testHttpHostUriRequestWithContext() throws Exception {
runHttpHostRequestTest("testHttpHostUriRequestWithContext", new BasicHttpContext());
}
@Test
public void testResponseHandler() throws IOException {
runResponseHandlerTest("testResponseHandler", null);
}
@Test
public void testResponseHandlerWithContext() throws IOException {
runResponseHandlerTest("testResponseHandlerWithContext", new BasicHttpContext());
}
@Test
public void testHostResponseHandler() throws Exception {
runHostResponseHandlerTest("testHostResponseHandler", null);
}
@Test
public void testHostResponseHandlerWithContext() throws Exception {
runHostResponseHandlerTest("testHostResponseHandlerWithContext", new BasicHttpContext());
}
@Test
public void testDefaultObfuscatedHeaders() throws Exception {
runHeadersObfuscationTest("testDefaultObfuscatedHeaders", HttpObfuscator.DEFAULT_OBFUSCATED_HEADERS_LIST, true);
}
@Test
public void testNonDefaultObfuscatedHeaders() throws Exception {
runHeadersObfuscationTest("testNonDefaultObfuscatedHeaders", Arrays.asList("X-Hdr1", "X-Hdr2", "X-Hdr3"), false);
}
/**
* This test is designed to ensure that when {@link HttpClient}'s
* <code>execute</code> methods are called with a <code>null</code>
* {@link HttpUriRequest} argument the aspect fails with {@link NullPointerException}
* instead of {@link IllegalStateException} as it should have
*/
@Test
public void testMissingRequestArgument() throws IOException, ClientProtocolException {
HttpClient httpClient = new DefaultHttpClient();
for (MissingRequestTestRunner runner : MissingRequestTestRunner.values()) {
String excValue = null;
try {
HttpResponse rsp = runner.execute(httpClient);
fail("Unexpected sucess of " + runner + ": " + rsp);
} catch (IllegalArgumentException e) {
// expected - thrown by HttpClient when null request supplied
excValue = StringFormatterUtils.formatStackTrace(e);
}
Operation op = assertExecutionResult(HttpClientDefinitions.PLACEHOLDER_URI_VALUE,
HttpPlaceholderRequest.PLACEHOLDER,
null, true);
assertEquals("Mismatched exception value for " + runner,
excValue,
op.get(OperationFields.EXCEPTION, String.class));
Mockito.reset(spiedOperationCollector); // prepare for next iteration
}
}
static enum MissingRequestTestRunner {
REQONLY {
@Override
public HttpResponse execute(HttpClient httpClient) throws IOException, ClientProtocolException {
return httpClient.execute(null);
}
},
REQANDCONTEXT {
@Override
public HttpResponse execute(HttpClient httpClient) throws IOException, ClientProtocolException {
return httpClient.execute(null, Mockito.mock(HttpContext.class));
}
},
HOSTANDREQ {
@Override
public HttpResponse execute(HttpClient httpClient) throws IOException, ClientProtocolException {
return httpClient.execute(new HttpHost("localhost", TEST_PORT, "http"), null);
}
},
HOSTREQCONTEXT {
@Override
public HttpResponse execute(HttpClient httpClient) throws IOException, ClientProtocolException {
return httpClient.execute(new HttpHost("localhost", TEST_PORT, "http"), null, Mockito.mock(HttpContext.class));
}
};
public abstract HttpResponse execute(HttpClient httpClient) throws IOException, ClientProtocolException;
}
private Map<String, String> runHeadersObfuscationTest(String testName, Collection<String> headerSet, boolean defaultHeaders) throws IOException {
HttpClient httpClient = new DefaultHttpClient();
String uri = createTestUri(testName);
HttpGet request = new HttpGet(uri);
for (String name : headerSet) {
if ("WWW-Authenticate".equalsIgnoreCase(name)) {
continue; // this is a response header
}
request.setHeader(name, name);
}
HttpClientExecutionCollectionAspect aspectInstance = getAspect();
HttpObfuscator obfuscator = aspectInstance.getHttpHeadersObfuscator();
if (!defaultHeaders) {
for (String name : HttpObfuscator.DEFAULT_OBFUSCATED_HEADERS_LIST) {
if ("WWW-Authenticate".equalsIgnoreCase(name)) {
continue; // this is a response header
}
request.setHeader(name, name);
}
obfuscator.incrementalUpdate(HttpObfuscator.OBFUSCATED_HEADERS_SETTING, StringUtil.implode(headerSet, ","));
}
HttpResponse response = httpClient.execute(request);
Operation op = assertExecutionResult(uri, request, response, false);
OperationMap reqDetails = op.get("request", OperationMap.class);
OperationList reqHeaders = reqDetails.get("headers", OperationList.class);
Map<String, String> requestHeaders = toHeadersMap(reqHeaders);
OperationMap rspDetails = op.get("response", OperationMap.class);
OperationList rspHeaders = rspDetails.get("headers", OperationList.class);
Map<String, String> responseHeaders = toHeadersMap(rspHeaders);
Map<String, String> hdrsMap = new TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER);
if (MapUtil.size(requestHeaders) > 0) {
hdrsMap.putAll(requestHeaders);
}
if (MapUtil.size(responseHeaders) > 0) {
hdrsMap.putAll(responseHeaders);
}
Collection<?> obscuredValues = (ObscuredValueSetMarker) obfuscator.getSensitiveValueMarker();
for (String name : headerSet) {
String value = hdrsMap.get(name);
assertNotNull("Missing header=" + name, value);
assertTrue("Unobscured value of " + name, obscuredValues.contains(value));
}
if (!defaultHeaders) {
for (String name : HttpObfuscator.DEFAULT_OBFUSCATED_HEADERS_LIST) {
assertFalse("Un-necessarily obscured value of " + name, obscuredValues.contains(name));
}
}
return hdrsMap;
}
private void runResponseHandlerTest(String testName, HttpContext context) throws IOException {
runResponseHandlerTest(testName, null, context);
}
private void runHostResponseHandlerTest(String testName, HttpContext context) throws Exception {
runResponseHandlerTest(testName, URIUtils.extractHost(new URI(createTestUri(testName))), context);
}
private void runResponseHandlerTest(String testName, HttpHost host, HttpContext context) throws IOException {
HttpClient httpClient = new DefaultHttpClient();
String uri = createTestUri(testName);
HttpGet request = new HttpGet(uri);
// must be final or the anonymous class cannot reference it...
final AtomicReference<HttpResponse> rspRef = new AtomicReference<HttpResponse>(null);
ResponseHandler<HttpResponse> handler = new ResponseHandler<HttpResponse>() {
public HttpResponse handleResponse(HttpResponse response)
throws ClientProtocolException, IOException {
HttpResponse prevValue = rspRef.getAndSet(response);
assertNull("Duplicate response handling", prevValue);
return response;
}
};
HttpResponse response;
if (host == null) {
response = (context == null)
? httpClient.execute(request, handler)
: httpClient.execute(request, handler, context)
;
} else {
response = (context == null)
? httpClient.execute(host, request, handler)
: httpClient.execute(host, request, handler, context)
;
}
assertSame("Mismatched reference and return value", response, rspRef.get());
handleResponse(testName, uri, request, response, true);
}
private void runHttpUriRequestTest(String testName, HttpContext context) throws IOException {
runHttpRequestTest(testName, null, context);
}
private void runHttpHostRequestTest(String testName, HttpContext context) throws Exception {
runHttpRequestTest(testName, URIUtils.extractHost(new URI(createTestUri(testName))), context);
}
private void runHttpRequestTest(String testName, HttpHost host, HttpContext context) throws IOException {
HttpClient httpClient = new DefaultHttpClient();
String uri = createTestUri(testName);
HttpGet request = new HttpGet(uri);
HttpResponse response;
if (host == null) {
response = (context == null)
? httpClient.execute(request)
: httpClient.execute(request, context)
;
} else {
response = (context == null)
? httpClient.execute(host, request)
: httpClient.execute(host, request, context)
;
}
handleResponse(testName, uri, request, response, true);
}
private Operation handleResponse(String testName,
String uri,
HttpRequest request,
HttpResponse response,
boolean checkHeaders) throws IOException {
HttpEntity entity = response.getEntity();
try {
return assertExecutionResult(uri, request, response, checkHeaders);
} finally {
EntityUtils.consume(entity);
}
}
private Operation assertExecutionResult(String uri,
HttpRequest request,
HttpResponse response,
boolean checkHeaders) {
Operation op = getLastEntered();
assertNotNull("No operation extracted", op);
assertEquals("Mismatched operation type for " + uri, HttpClientDefinitions.TYPE, op.getType());
assertRequestDetails(uri, op.get("request", OperationMap.class), request, checkHeaders);
assertResponseDetails(uri, op.get("response", OperationMap.class), response, checkHeaders);
return op;
}
private OperationMap assertRequestDetails(String uri, OperationMap details, HttpRequest request, boolean checkHeaders) {
assertNotNull("No request details for " + uri, details);
RequestLine reqLine = request.getRequestLine();
assertEquals("Mismatched method", reqLine.getMethod(), details.get("method"));
assertEquals("Mismatched URI", reqLine.getUri(), details.get(OperationFields.URI));
assertEquals("Mismatched protocol",
HttpClientExecutionCollectionAspect.createVersionValue(reqLine.getProtocolVersion()),
details.get("protocol"));
if (checkHeaders) {
assertHeadersContents(uri, "request", details, request);
}
return details;
}
private OperationMap assertResponseDetails(String uri, OperationMap details, HttpResponse response, boolean checkHeaders) {
if (response == null) {
return details;
}
StatusLine statusLine = response.getStatusLine();
assertEquals("Mismatched status code", statusLine.getStatusCode(), details.getInt("statusCode", (-1)));
assertEquals("Mismatched reason phrase", statusLine.getReasonPhrase(), details.get("reasonPhrase", String.class));
if (checkHeaders) {
assertHeadersContents(uri, "response", details, response);
}
return details;
}
private void assertHeadersContents(String uri, String type, OperationMap details, HttpMessage message) {
OperationList headers = details.get("headers", OperationList.class);
assertNotNull("No " + type + " headers for " + uri, headers);
Header[] hdrArray = message.getAllHeaders();
int numHdrs = (hdrArray == null) ? 0 : hdrArray.length;
assertEquals("Mismatched " + type + " number of headers", numHdrs, headers.size());
if (numHdrs <= 0) {
return;
}
Map<String, String> opHdrs = toHeadersMap(headers);
Map<String, String> msgHdrs = toHeadersMap(hdrArray);
assertEquals("Mismatched " + type + " headers map size", msgHdrs.size(), opHdrs.size());
for (Map.Entry<String, String> hdrValue : msgHdrs.entrySet()) {
String name = hdrValue.getKey();
assertEquals("Mismatched " + type + " value for " + name + " header",
hdrValue.getValue(), opHdrs.get(name));
}
}
private Map<String, String> toHeadersMap(Header... headers) {
if (ArrayUtil.length(headers) <= 0) {
return Collections.emptyMap();
}
Map<String, String> hdrsMap = new TreeMap<String, String>();
for (Header hdrValue : headers) {
String name = hdrValue.getName();
String value = hdrValue.getValue();
hdrsMap.put(name, value);
}
return hdrsMap;
}
private Map<String, String> toHeadersMap(OperationList headers) {
if ((headers == null) || (headers.size() <= 0)) {
return Collections.emptyMap();
}
Map<String, String> hdrsMap = new TreeMap<String, String>();
for (int index = 0; index < headers.size(); index++) {
OperationMap hdrValue = headers.get(index, OperationMap.class);
String name = hdrValue.get(OperationUtils.NAME_KEY, String.class);
String value = hdrValue.get(OperationUtils.VALUE_KEY, String.class);
hdrsMap.put(name, value);
}
return hdrsMap;
}
@Override
public HttpClientExecutionCollectionAspect getAspect() {
return HttpClientExecutionCollectionAspect.aspectOf();
}
private static final class TestHandler implements Handler {
private Server server;
private boolean started;
protected TestHandler() {
super();
}
public void addLifeCycleListener(Listener listener) {
// ignored
}
public void removeLifeCycleListener(Listener listener) {
// ignored
}
public void stop() throws Exception {
if (!started) {
throw new IllegalStateException("Not started");
}
started = false;
}
public void start() throws Exception {
if (started) {
throw new IllegalStateException("Double start");
}
started = true;
}
public boolean isStopping() {
return true;
}
public boolean isStopped() {
return !started;
}
public boolean isStarting() {
return true;
}
public boolean isStarted() {
return started;
}
public boolean isRunning() {
return started;
}
public boolean isFailed() {
return false;
}
public Server getServer() {
return this.server;
}
public void setServer(Server s) {
this.server = s;
}
public void handle(String target, HttpServletRequest request,
HttpServletResponse response, int dispatch)
throws IOException, ServletException {
int namePos = target.lastIndexOf('/');
String testName = target.substring(namePos + 1);
response.setStatus(HttpServletResponse.SC_OK);
response.setContentType("text/xml;charset=utf-8");
response.addHeader("X-Test-Name", testName);
response.addHeader("WWW-Authenticate", "allowed");
Writer writer = response.getWriter();
try {
writer.append(createResponseContent(testName));
} finally {
writer.close();
}
Request baseRequest = (request instanceof Request)
? (Request) request
: HttpConnection.getCurrentConnection().getRequest();
baseRequest.setHandled(true);
}
public void destroy() {
if (this.server != null)
this.server = null;
}
}
static String createResponseContent(String testName) {
return "<test name=\"" + testName + "\" />";
}
static String createTestUri(String testName) {
return TEST_URI + testName;
}
}