/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.cxf.transport.http;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PushbackInputStream;
import java.net.HttpURLConnection;
import java.net.Proxy;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.apache.cxf.Bus;
import org.apache.cxf.bus.extension.ExtensionManagerBus;
import org.apache.cxf.configuration.jsse.TLSClientParameters;
import org.apache.cxf.configuration.security.AuthorizationPolicy;
import org.apache.cxf.helpers.CastUtils;
import org.apache.cxf.io.AbstractThresholdOutputStream;
import org.apache.cxf.message.Exchange;
import org.apache.cxf.message.Message;
import org.apache.cxf.message.MessageContentsList;
import org.apache.cxf.message.MessageImpl;
import org.apache.cxf.service.model.EndpointInfo;
import org.apache.cxf.transport.MessageObserver;
import org.apache.cxf.transport.https.HttpsURLConnectionFactory;
import org.apache.cxf.ws.addressing.EndpointReferenceType;
import org.easymock.EasyMock;
import org.easymock.IMocksControl;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
/**
*/
public class HTTPConduitURLEasyMockTest extends Assert {
private static String oldHttpProxyHost;
private enum ResponseStyle { NONE, BACK_CHANNEL, BACK_CHANNEL_ERROR, DECOUPLED, ONEWAY_NONE };
private enum ResponseDelimiter { LENGTH, CHUNKED, EOF };
private static final String NOWHERE = "http://nada.nothing.nowhere.null/";
private static final String PAYLOAD = "message payload";
private IMocksControl control;
private EndpointInfo endpointInfo;
private HttpsURLConnectionFactory connectionFactory;
private HttpURLConnection connection;
private Proxy proxy;
private Message inMessage;
private MessageObserver observer;
private OutputStream os;
private InputStream is;
@BeforeClass
public static void disableHttpProxy() throws Exception {
oldHttpProxyHost = System.getProperty("http.proxyHost");
if (oldHttpProxyHost != null) {
// disable http proxy so that the connection mocking works (see setUpConduit)
System.clearProperty("http.proxyHost");
}
}
@AfterClass
public static void revertHttpProxy() throws Exception {
if (oldHttpProxyHost != null) {
System.setProperty("http.proxyHost", oldHttpProxyHost);
}
}
/**
* This is an extension to the HTTPConduit that replaces
* the dynamic assignment of the HttpURLConnectionFactory,
* and we just use the EasyMocked version for this test.
*/
private class HTTPTestConduit extends URLConnectionHTTPConduit {
HTTPTestConduit(
Bus associatedBus,
EndpointInfo endpoint,
EndpointReferenceType epr,
HttpsURLConnectionFactory testFactory
) throws IOException {
super(associatedBus, endpoint, epr);
connectionFactory = testFactory;
}
}
/**
* @throws java.lang.Exception
*/
@Before
public void setUp() throws Exception {
}
/**
* @throws java.lang.Exception
*/
@After
public void tearDown() throws Exception {
// avoid intermittent spurious failures on EasyMock detecting finalize
// calls by mocking up only class data members (no local variables)
// and explicitly making available for GC post-verify
connectionFactory = null;
connection = null;
proxy = null;
inMessage = null;
observer = null;
os = null;
is = null;
}
@Test
public void testSend() throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, false);
Message message = createMessage();
conduit.prepare(message);
verifySentMessage(conduit, message, "POST");
finalVerify();
}
@Test
public void testSendWithHeaders() throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, false);
Message message = createMessage();
setUpHeaders(message);
conduit.prepare(message);
verifySentMessage(conduit, message, true, "POST", false);
finalVerify();
}
private Message createMessage() {
Message message = new MessageImpl();
message.put("Content-Type", "text/xml;charset=utf8");
message.setContent(List.class, new MessageContentsList("<body/>"));
return message;
}
public void testSendWithHeadersCheckErrorStream() throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, false);
Message message = new MessageImpl();
message.put("Content-Type", "text/xml;charset=utf8");
setUpHeaders(message);
conduit.prepare(message);
verifySentMessage(conduit, message, true, "POST", true);
finalVerify();
}
@Test
public void testSendHttpConnection() throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, false);
Message message = createMessage();
conduit.prepare(message);
verifySentMessage(conduit, message, "POST");
finalVerify();
}
@Test
public void testSendHttpConnectionAutoRedirect() throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, true);
Message message = createMessage();
conduit.prepare(message);
verifySentMessage(conduit, message, "POST");
finalVerify();
}
@Test
public void testSendHttpGetConnectionAutoRedirect() throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, true, "GET");
Message message = new MessageImpl();
message.put(Message.HTTP_REQUEST_METHOD, "GET");
conduit.prepare(message);
verifySentMessage(conduit, message, "GET");
conduit.close(message);
finalVerify();
}
@Test
public void testSendHttpGetConnection() throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, false, "GET");
Message message = new MessageImpl();
message.put(Message.HTTP_REQUEST_METHOD, "GET");
conduit.prepare(message);
verifySentMessage(conduit, message, "GET");
conduit.close(message);
finalVerify();
}
@Test
public void testSendOnewayChunkedEmptyPartialResponseProcessResponse()
throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, false);
Message message = createMessage();
conduit.prepare(message);
message.put(Message.PROCESS_ONEWAY_RESPONSE, Boolean.TRUE);
verifySentMessage(conduit,
message,
ResponseStyle.NONE,
ResponseDelimiter.CHUNKED,
true, // empty response
"POST");
finalVerify();
}
@Test
public void testSendOnewayDoNotProcessResponse()
throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, false);
Message message = createMessage();
conduit.prepare(message);
verifySentMessage(conduit,
message,
ResponseStyle.ONEWAY_NONE,
ResponseDelimiter.CHUNKED,
true, // empty response
"POST");
finalVerify();
}
@Test
public void testSendTwowayDecoupledEmptyPartialResponse()
throws Exception {
control = EasyMock.createNiceControl();
HTTPConduit conduit = setUpConduit(true, false);
Message message = createMessage();
conduit.prepare(message);
verifySentMessage(conduit,
message,
ResponseStyle.DECOUPLED,
ResponseDelimiter.EOF,
true, // empty response
"POST");
finalVerify();
}
private void setUpHeaders(Message message) {
Map<String, List<String>> headers = new TreeMap<String, List<String>>(String.CASE_INSENSITIVE_ORDER);
List<String> contentTypes = new ArrayList<String>();
contentTypes.add("text/xml;charset=utf8");
headers.put("content-type", contentTypes);
List<String> acceptTypes = new ArrayList<String>();
acceptTypes.add("text/xml;charset=utf8");
acceptTypes.add("text/plain");
headers.put("Accept", acceptTypes);
message.put(Message.PROTOCOL_HEADERS, headers);
AuthorizationPolicy authPolicy = new AuthorizationPolicy();
authPolicy.setUserName("BJ");
authPolicy.setPassword("value");
message.put(AuthorizationPolicy.class, authPolicy);
}
private void setUpExchange(Message message, boolean oneway) {
Exchange exchange = control.createMock(Exchange.class);
message.setExchange(exchange);
exchange.isOneWay();
EasyMock.expectLastCall().andReturn(oneway).anyTimes();
exchange.isSynchronous();
EasyMock.expectLastCall().andReturn(true).anyTimes();
exchange.isEmpty();
EasyMock.expectLastCall().andReturn(true).anyTimes();
}
private HTTPConduit setUpConduit(boolean send, boolean autoRedirect) throws Exception {
return setUpConduit(send, autoRedirect, "POST");
}
private HTTPConduit setUpConduit(
boolean send,
boolean autoRedirect,
String method
) throws Exception {
endpointInfo = new EndpointInfo();
endpointInfo.setAddress(NOWHERE + "bar/foo");
connectionFactory =
control.createMock(HttpsURLConnectionFactory.class);
if (send) {
//proxy = control.createMock(Proxy.class);
proxy = null;
connection =
control.createMock(HttpURLConnection.class);
connection.getURL();
EasyMock.expectLastCall().andReturn(new URL(NOWHERE + "bar/foo")).anyTimes();
connectionFactory.createConnection((TLSClientParameters)EasyMock.isNull(),
EasyMock.eq(proxy),
EasyMock.eq(new URL(NOWHERE + "bar/foo")));
EasyMock.expectLastCall().andReturn(connection);
connection.setDoOutput(true);
EasyMock.expectLastCall();
connection.setRequestMethod(method);
EasyMock.expectLastCall();
if (!autoRedirect && "POST".equals(method)) {
connection.setChunkedStreamingMode(-1);
EasyMock.expectLastCall();
}
connection.getRequestMethod();
EasyMock.expectLastCall().andReturn(method).anyTimes();
connection.setInstanceFollowRedirects(false);
EasyMock.expectLastCall().times(1);
connection.setConnectTimeout(303030);
EasyMock.expectLastCall();
connection.setReadTimeout(404040);
EasyMock.expectLastCall();
connection.setUseCaches(false);
EasyMock.expectLastCall();
}
ExtensionManagerBus bus = new ExtensionManagerBus();
control.replay();
HTTPConduit conduit = new HTTPTestConduit(bus,
endpointInfo,
null,
connectionFactory);
conduit.finalizeConfig();
if (send) {
conduit.getClient().setConnectionTimeout(303030);
conduit.getClient().setReceiveTimeout(404040);
conduit.getClient().setAutoRedirect(autoRedirect);
if (!autoRedirect) {
conduit.getClient().setAllowChunking(true);
conduit.getClient().setChunkingThreshold(0);
}
}
observer = new MessageObserver() {
public void onMessage(Message m) {
inMessage = m;
}
};
conduit.setMessageObserver(observer);
return conduit;
}
private void verifySentMessage(HTTPConduit conduit, Message message, String method)
throws IOException {
verifySentMessage(conduit, message, false, method, false);
}
private void verifySentMessage(HTTPConduit conduit,
Message message,
boolean expectHeaders,
String method,
boolean errorExpected)
throws IOException {
verifySentMessage(conduit,
message,
expectHeaders,
errorExpected ? ResponseStyle.BACK_CHANNEL_ERROR : ResponseStyle.BACK_CHANNEL,
method);
}
private void verifySentMessage(HTTPConduit conduit,
Message message,
boolean expectHeaders,
ResponseStyle style,
String method)
throws IOException {
verifySentMessage(conduit,
message,
expectHeaders,
style,
ResponseDelimiter.LENGTH,
false,
method);
}
private void verifySentMessage(HTTPConduit conduit,
Message message,
ResponseStyle style,
ResponseDelimiter delimiter,
boolean emptyResponse,
String method)
throws IOException {
verifySentMessage(conduit,
message,
false,
style,
delimiter,
emptyResponse,
method);
}
private void verifySentMessage(HTTPConduit conduit,
Message message,
boolean expectHeaders,
ResponseStyle style,
ResponseDelimiter delimiter,
boolean emptyResponse,
String method)
throws IOException {
control.verify();
control.reset();
OutputStream wrappedOS = verifyRequestHeaders(message, expectHeaders, method);
if (!"GET".equals(method)) {
os.write(PAYLOAD.getBytes(), 0, PAYLOAD.length());
EasyMock.expectLastCall();
os.flush();
EasyMock.expectLastCall();
os.flush();
EasyMock.expectLastCall();
os.close();
EasyMock.expectLastCall();
}
setUpExchange(message, style == ResponseStyle.NONE || style == ResponseStyle.ONEWAY_NONE);
connection.getRequestMethod();
EasyMock.expectLastCall().andReturn(method).anyTimes();
verifyHandleResponse(style, delimiter, emptyResponse, conduit);
control.replay();
wrappedOS.flush();
wrappedOS.flush();
wrappedOS.close();
if ((style == ResponseStyle.NONE && !emptyResponse)
|| style == ResponseStyle.BACK_CHANNEL
|| style == ResponseStyle.BACK_CHANNEL_ERROR) {
assertNotNull("expected in message", inMessage);
Map<?, ?> headerMap = (Map<?, ?>) inMessage.get(Message.PROTOCOL_HEADERS);
assertEquals("unexpected response headers", headerMap.size(), 0);
Integer expectedResponseCode = getResponseCode(style);
assertEquals("unexpected response code",
expectedResponseCode,
inMessage.get(Message.RESPONSE_CODE));
if (!emptyResponse) {
assertTrue("unexpected content formats",
inMessage.getContentFormats().contains(InputStream.class));
InputStream content = inMessage.getContent(InputStream.class);
if (!(content instanceof PushbackInputStream)) {
assertSame("unexpected content", is, content);
}
}
}
finalVerify();
}
private OutputStream verifyRequestHeaders(Message message, boolean expectHeaders, String method)
throws IOException {
Map<String, List<String>> headers =
CastUtils.cast((Map<?, ?>)message.get(Message.PROTOCOL_HEADERS));
assertNotNull("expected request headers set", headers);
assertTrue("expected output stream format",
message.getContentFormats().contains(OutputStream.class));
connection.getRequestMethod();
EasyMock.expectLastCall().andReturn(method).anyTimes();
if (!"GET".equals(method)) {
os = EasyMock.createMock(OutputStream.class);
connection.getOutputStream();
EasyMock.expectLastCall().andReturn(os);
}
message.put(HTTPConduit.KEY_HTTP_CONNECTION, connection);
if (expectHeaders) {
connection.setRequestProperty(EasyMock.eq("Authorization"),
EasyMock.eq("Basic Qko6dmFsdWU="));
EasyMock.expectLastCall();
connection.setRequestProperty(EasyMock.eq("Content-Type"),
EasyMock.eq("text/xml;charset=utf8"));
EasyMock.expectLastCall();
connection.setRequestProperty(EasyMock.eq("Accept"),
EasyMock.eq("text/xml;charset=utf8,text/plain"));
EasyMock.expectLastCall();
}
connection.getRequestProperties();
EasyMock.expectLastCall().andReturn(new HashMap<String, List<String>>()).anyTimes();
control.replay();
AbstractThresholdOutputStream wrappedOS
= (AbstractThresholdOutputStream) message.getContent(OutputStream.class);
assertNotNull("expected output stream", wrappedOS);
wrappedOS.write(PAYLOAD.getBytes());
wrappedOS.unBuffer();
control.verify();
control.reset();
return wrappedOS;
}
private void verifyHandleResponse(ResponseStyle style,
ResponseDelimiter delimiter,
boolean emptyResponse,
HTTPConduit conduit) throws IOException {
connection.getHeaderFields();
EasyMock.expectLastCall().andReturn(Collections.EMPTY_MAP).anyTimes();
int responseCode = getResponseCode(style);
if (conduit.getClient().isAutoRedirect()) {
connection.getResponseCode();
EasyMock.expectLastCall().andReturn(301).once().andReturn(responseCode).anyTimes();
connection.getURL();
EasyMock.expectLastCall().andReturn(new URL(NOWHERE + "bar/foo/redirect")).anyTimes();
} else {
connection.getResponseCode();
EasyMock.expectLastCall().andReturn(responseCode).anyTimes();
}
switch (style) {
case NONE:
case DECOUPLED:
is = control.createMock(InputStream.class);
connection.getInputStream();
EasyMock.expectLastCall().andReturn(is).anyTimes();
connection.getContentLength();
if (delimiter == ResponseDelimiter.CHUNKED
|| delimiter == ResponseDelimiter.EOF) {
EasyMock.expectLastCall().andReturn(-1).anyTimes();
if (delimiter == ResponseDelimiter.CHUNKED) {
connection.getHeaderField("Transfer-Encoding");
EasyMock.expectLastCall().andReturn("chunked");
} else if (delimiter == ResponseDelimiter.EOF) {
connection.getHeaderField("Connection");
EasyMock.expectLastCall().andReturn("close");
}
is.read();
if (emptyResponse) {
EasyMock.expectLastCall().andReturn(-1).anyTimes();
} else {
EasyMock.expectLastCall().andReturn((int)'<');
}
} else {
EasyMock.expectLastCall().andReturn(123).anyTimes();
}
if (emptyResponse) {
is.close();
EasyMock.expectLastCall();
}
break;
case BACK_CHANNEL:
is = EasyMock.createMock(InputStream.class);
connection.getInputStream();
EasyMock.expectLastCall().andReturn(is).anyTimes();
break;
case BACK_CHANNEL_ERROR:
is = EasyMock.createMock(InputStream.class);
connection.getInputStream();
EasyMock.expectLastCall().andReturn(is).anyTimes();
connection.getErrorStream();
EasyMock.expectLastCall().andReturn(null);
break;
case ONEWAY_NONE:
connection.getInputStream();
EasyMock.expectLastCall().andReturn(new ByteArrayInputStream(new byte[0])).anyTimes();
break;
default:
break;
}
}
private void finalVerify() {
if (control != null) {
control.verify();
control = null;
}
}
private int getResponseCode(ResponseStyle style) {
int code;
if (style == ResponseStyle.BACK_CHANNEL) {
code = HttpURLConnection.HTTP_OK;
} else if (style == ResponseStyle.BACK_CHANNEL_ERROR) {
code = HttpURLConnection.HTTP_BAD_REQUEST;
} else {
code = HttpURLConnection.HTTP_ACCEPTED;
}
return code;
}
}