Spring/spring-integration
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

INT-3918: Use MockMvc instead of Sun HttpServer

Browse Source 
JIRA: https://jira.spring.io/browse/INT-3918
This commit is contained in:
Artem Bilan
2015-12-18 18:31:09 -05:00
committed by Gary Russell
parent 8bf8caa22e
commit f5781bfff8
6 changed files with 196 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
spring-integration-http/src/test/java/org/springframework/integration/http/config/HttpOutboundGatewayWithMethodExpression.java
View File

@@ -1,130 +0,0 @@
/*
* Copyright 2002-2012 the original author or authors.
*
* 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 org.springframework.integration.http.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.parsing.BeanDefinitionParsingException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.integration.test.util.SocketUtils;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
/**
* @author Oleg Zhurakousky
*
* see https://jira.springsource.org/browse/INT-2397
*/
public class HttpOutboundGatewayWithMethodExpression {
private HttpServer server;
private MyHandler httpHandler;
@Before
public void createServer() throws Exception {
int httpPort = SocketUtils.findAvailableServerSocket();
System.setProperty("httpPort", String.valueOf(httpPort));
httpHandler = new MyHandler();
server = HttpServer.create(new InetSocketAddress(httpPort), 0);
server.createContext("/testApps/httpMethod", httpHandler);
server.start();
}
@After
public void stopServer() throws Exception {
server.stop(0);
}
@Test
public void testDefaultMethod() throws Exception{
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
"http-outbound-gateway-with-httpmethod-expression.xml", this.getClass());
MessageChannel channel = context.getBean("defaultChannel", MessageChannel.class);
QueueChannel replyChannel = context.getBean("replyChannel", QueueChannel.class);
httpHandler.setHttpMethod("POST");
channel.send(new GenericMessage<String>("Hello"));
Message<?> message = replyChannel.receive(5000);
assertNotNull(message);
assertEquals("POST", message.getPayload());
}
@Test
public void testExplicitlySetMethod() throws Exception{
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
"http-outbound-gateway-with-httpmethod-expression.xml", this.getClass());
MessageChannel channel = context.getBean("requestChannel", MessageChannel.class);
QueueChannel replyChannel = context.getBean("replyChannel", QueueChannel.class);
httpHandler.setHttpMethod("GET");
channel.send(new GenericMessage<String>("GET"));
Message<?> message = replyChannel.receive(5000);
assertNotNull(message);
assertEquals("GET", message.getPayload());
}
@Test(expected=BeanDefinitionParsingException.class)
public void testMutuallyExclusivityInMethodAndMethodExpression() throws Exception{
new ClassPathXmlApplicationContext(
"http-outbound-gateway-with-httpmethod-expression-fail.xml", this.getClass());
}
class MyHandler implements HttpHandler {
private String httpMethod;
public void setHttpMethod(String httpMethod){
this.httpMethod = httpMethod;
}
public void handle(HttpExchange t) throws IOException {
String requestMethod = t.getRequestMethod();
String response = null;
if (requestMethod.equalsIgnoreCase(this.httpMethod)){
response = httpMethod;
t.getResponseHeaders().add("Content-Type", "text/plain"); //Required for Spring 3.0.x
t.sendResponseHeaders(200, response.length());
}
else {
response = "Request is NOT valid";
t.sendResponseHeaders(404, 0);
}
OutputStream os = t.getResponseBody();
os.write(response.getBytes());
os.close();
}
}
}

7
spring-integration-http/src/test/java/org/springframework/integration/http/config/http-outbound-gateway-with-httpmethod-expression.xml → spring-integration-http/src/test/java/org/springframework/integration/http/config/HttpOutboundGatewayWithMethodExpressionTests-context.xml
View File

@@ -7,16 +7,19 @@
http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
http://www.springframework.org/schema/integration/http http://www.springframework.org/schema/integration/http/spring-integration-http.xsd">
<bean id="restTemplate" class="org.springframework.web.client.RestTemplate"/>
<int-http:outbound-gateway url="http://localhost:#{systemProperties.httpPort}/testApps/httpMethod"
<int-http:outbound-gateway url="/testApps/httpMethod"
request-channel="requestChannel"
reply-channel="replyChannel"
rest-template="restTemplate"
expected-response-type="java.lang.String"
http-method-expression="payload"/>
<int-http:outbound-gateway url="http://localhost:#{systemProperties.httpPort}/testApps/httpMethod"
<int-http:outbound-gateway url="/testApps/httpMethod"
request-channel="defaultChannel"
reply-channel="replyChannel"
rest-template="restTemplate"
expected-response-type="java.lang.String"/>
<int:channel id="replyChannel">

107
spring-integration-http/src/test/java/org/springframework/integration/http/config/HttpOutboundGatewayWithMethodExpressionTests.java Normal file
View File

@@ -0,0 +1,107 @@
/*
* Copyright 2002-2015 the original author or authors.
*
* 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 org.springframework.integration.http.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.parsing.BeanDefinitionParsingException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.PollableChannel;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.web.client.MockRestServiceServer;
import org.springframework.web.client.RestTemplate;
/**
* @author Oleg Zhurakousky
* @author Artem Bilan
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@DirtiesContext
public class HttpOutboundGatewayWithMethodExpressionTests {
@Autowired
private MessageChannel defaultChannel;
@Autowired
private MessageChannel requestChannel;
@Autowired
private PollableChannel replyChannel;
@Autowired
private RestTemplate restTemplate;
private MockRestServiceServer mockServer;
@Before
public void setup() {
this.mockServer = MockRestServiceServer.createServer(this.restTemplate);
}
@Test
public void testDefaultMethod() throws Exception {
this.mockServer.expect(requestTo("/testApps/httpMethod"))
.andExpect(method(HttpMethod.POST))
.andRespond(withSuccess(HttpMethod.POST.name(), MediaType.TEXT_PLAIN));
this.defaultChannel.send(new GenericMessage<String>("Hello"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertEquals("POST", message.getPayload());
this.mockServer.verify();
}
@Test
public void testExplicitlySetMethod() throws Exception {
this.mockServer.expect(requestTo("/testApps/httpMethod"))
.andExpect(method(HttpMethod.GET))
.andRespond(withSuccess(HttpMethod.GET.name(), MediaType.TEXT_PLAIN));
this.requestChannel.send(new GenericMessage<String>("GET"));
Message<?> message = replyChannel.receive(5000);
assertNotNull(message);
assertEquals("GET", message.getPayload());
this.mockServer.verify();
}
@Test(expected = BeanDefinitionParsingException.class)
public void testMutuallyExclusivityInMethodAndMethodExpression() throws Exception {
new ClassPathXmlApplicationContext(
"http-outbound-gateway-with-httpmethod-expression-fail.xml", getClass())
.close();
}
}

12
spring-integration-http/src/test/java/org/springframework/integration/http/config/OutboundResponseTypeTests-context-fail.xml
View File

@@ -1,23 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:int="http://www.springframework.org/schema/integration"
xmlns:int-http="http://www.springframework.org/schema/integration/http"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
http://www.springframework.org/schema/integration/http http://www.springframework.org/schema/integration/http/spring-integration-http.xsd">
<bean id="portBean" class="org.springframework.integration.http.config.OutboundResponseTypeTests$Port" />
<int-http:outbound-gateway url="http://localhost:#{portBean.port}/testApps/outboundResponse"
<int-http:outbound-gateway url="/testApps/outboundResponse"
request-channel="resTypeSetChannel"
reply-channel="replyChannel"
expected-response-type="java.lang.String"
expected-response-type-expression="payload"/>
<int:channel id="replyChannel">
<int:queue/>
</int:channel>
</beans>

37
spring-integration-http/src/test/java/org/springframework/integration/http/config/OutboundResponseTypeTests-context.xml
View File

@@ -13,48 +13,55 @@
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd">
<bean id="portBean" class="org.springframework.integration.http.config.OutboundResponseTypeTests$Port"/>
<bean id="restTemplate" class="org.springframework.web.client.RestTemplate"/>
<int-http:outbound-gateway url="http://localhost:#{portBean.port}/testApps/outboundResponse"
<int-http:outbound-gateway url="/testApps/outboundResponse"
rest-template="restTemplate"
request-channel="requestChannel"
reply-channel="replyChannel"/>
<int-http:outbound-gateway url="http://localhost:#{portBean.port}/testApps/outboundResponse"
<int-http:outbound-gateway url="/testApps/outboundResponse"
rest-template="restTemplate"
request-channel="resTypeSetChannel"
reply-channel="replyChannel"
expected-response-type="java.lang.String"/>
<int-http:outbound-gateway url="http://localhost:#{portBean.port}/testApps/outboundResponse"
<int-http:outbound-gateway url="/testApps/outboundResponse"
rest-template="restTemplate"
request-channel="resPrimitiveStringPresentationChannel"
reply-channel="replyChannel"
expected-response-type="[B"/>
<int-http:outbound-gateway url="http://localhost:#{portBean.port}/testApps/outboundResponse"
<int-http:outbound-gateway url="/testApps/outboundResponse"
rest-template="restTemplate"
request-channel="resTypeExpressionSetChannel"
reply-channel="replyChannel"
expected-response-type-expression="payload"/>
<int-http:outbound-gateway url="http://localhost:#{portBean.port}/testApps/outboundResponse"
<int-http:outbound-gateway url="/testApps/outboundResponse"
rest-template="restTemplateWithConverters"
request-channel="resTypeExpressionSetSerializationChannel"
reply-channel="replyChannel"
message-converters="stringAndSerializingConverters"
expected-response-type-expression="payload"/>
<int-http:outbound-gateway url="http://localhost:#{portBean.port}/testApps/outboundResponse"
<bean id="restTemplateWithConverters" class="org.springframework.web.client.RestTemplate">
<property name="messageConverters">
<list>
<bean class="org.springframework.integration.http.converter.SerializingHttpMessageConverter"/>
<bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
</list>
</property>
</bean>
<int-http:outbound-gateway url="/testApps/outboundResponse"
request-channel="invalidResponseTypeChannel"
expected-response-type-expression="new java.util.Date()"/>
<int:chain input-channel="contentTypePropagationChannel" output-channel="nullChannel">
<int:object-to-json-transformer/>
<int-http:outbound-gateway url="http://localhost:#{portBean.port}/testApps/outboundResponse"/>
<int-http:outbound-gateway url="/testApps/outboundResponse" rest-template="restTemplate"/>
</int:chain>
<util:list id="stringAndSerializingConverters">
<bean class="org.springframework.integration.http.converter.SerializingHttpMessageConverter"/>
<bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
</util:list>
<int:channel id="replyChannel">
<int:queue/>
</int:channel>

126
spring-integration-http/src/test/java/org/springframework/integration/http/config/OutboundResponseTypeTests.java
View File

@@ -16,43 +16,41 @@
package org.springframework.integration.http.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.header;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.Collections;
import java.util.Map;
import org.hamcrest.Matchers;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import com.sun.net.httpserver.Headers;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.parsing.BeanDefinitionParsingException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.test.util.SocketUtils;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandlingException;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.web.client.MockRestServiceServer;
import org.springframework.web.client.RestTemplate;
/**
* @author Oleg Zhurakousky
@@ -67,9 +65,11 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
public class OutboundResponseTypeTests {
private static HttpServer server;
@Autowired
private RestTemplate restTemplate;
private static MyHandler httpHandler;
@Autowired
private RestTemplate restTemplateWithConverters;
@Autowired
private QueueChannel replyChannel;
@@ -95,67 +95,96 @@ public class OutboundResponseTypeTests {
@Autowired
private MessageChannel contentTypePropagationChannel;
private static int port = SocketUtils.findAvailableServerSocket();
private MockRestServiceServer mockServer;
@BeforeClass
public static void createServer() throws Exception {
httpHandler = new MyHandler();
server = HttpServer.create(new InetSocketAddress(port), 0);
server.createContext("/testApps/outboundResponse", httpHandler);
server.start();
}
@AfterClass
public static void stopServer() throws Exception {
server.stop(0);
@Before
public void setup() {
this.mockServer = MockRestServiceServer.createServer(this.restTemplate);
}
@Test
public void testDefaultResponseType() throws Exception {
this.mockServer.expect(requestTo("/testApps/outboundResponse"))
.andExpect(method(HttpMethod.POST))
.andRespond(withSuccess(HttpMethod.POST.name(), MediaType.TEXT_PLAIN));
this.requestChannel.send(new GenericMessage<String>("Hello"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof ResponseEntity);
this.mockServer.verify();
}
@Test
public void testWithResponseTypeSet() throws Exception {
this.mockServer.expect(requestTo("/testApps/outboundResponse"))
.andExpect(method(HttpMethod.POST))
.andRespond(withSuccess(HttpMethod.POST.name(), MediaType.TEXT_PLAIN));
this.resTypeSetChannel.send(new GenericMessage<String>("Hello"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof String);
this.mockServer.verify();
}
@Test
public void testWithResponseTypeExpressionSet() throws Exception {
this.mockServer.expect(requestTo("/testApps/outboundResponse"))
.andExpect(method(HttpMethod.POST))
.andRespond(withSuccess(HttpMethod.POST.name(), MediaType.TEXT_PLAIN));
this.resTypeExpressionSetChannel.send(new GenericMessage<String>("java.lang.String"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof String);
this.mockServer.verify();
}
@Test
public void testWithResponseTypeExpressionSetAsClass() throws Exception {
this.mockServer = MockRestServiceServer.createServer(this.restTemplateWithConverters);
this.mockServer.expect(requestTo("/testApps/outboundResponse"))
.andExpect(method(HttpMethod.POST))
.andRespond(withSuccess(HttpMethod.POST.name(), MediaType.TEXT_PLAIN));
this.resTypeExpressionSetSerializationChannel.send(new GenericMessage<Class<?>>(String.class));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof String);
this.mockServer.verify();
}
@Test
public void testInt2706ResponseTypeExpressionAsPrimitive() throws Exception {
this.mockServer.expect(requestTo("/testApps/outboundResponse"))
.andExpect(method(HttpMethod.POST))
.andRespond(withSuccess(HttpMethod.POST.name(), MediaType.TEXT_PLAIN));
this.resTypeExpressionSetChannel.send(new GenericMessage<String>("byte[]"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof byte[]);
this.mockServer.verify();
}
@Test
public void testInt2706ResponseTypePrimitiveArrayClassAsString() throws Exception {
this.mockServer.expect(requestTo("/testApps/outboundResponse"))
.andExpect(method(HttpMethod.POST))
.andRespond(withSuccess(HttpMethod.POST.name(), MediaType.TEXT_PLAIN));
this.resPrimitiveStringPresentationChannel.send(new GenericMessage<byte[]>("hello".getBytes()));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof byte[]);
this.mockServer.verify();
}
@Test
@@ -188,48 +217,15 @@ public class OutboundResponseTypeTests {
@Test
public void testContentTypePropagation() throws Exception {
this.mockServer.expect(requestTo("/testApps/outboundResponse"))
.andExpect(method(HttpMethod.POST))
.andExpect(header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON.toString()))
.andRespond(withSuccess(HttpMethod.POST.name(), MediaType.TEXT_PLAIN));
this.contentTypePropagationChannel
.send(new GenericMessage<Map<String, String>>(Collections.singletonMap("foo", "bar")));
assertEquals(MediaType.APPLICATION_JSON.toString(), httpHandler.requestHeaders.getFirst("Content-Type"));
}
static class MyHandler implements HttpHandler {
private String httpMethod = "POST";
private volatile Headers requestHeaders;
public void setHttpMethod(String httpMethod) {
this.httpMethod = httpMethod;
}
public void handle(HttpExchange t) throws IOException {
String requestMethod = t.getRequestMethod();
requestHeaders = t.getRequestHeaders();
String response = null;
if (requestMethod.equalsIgnoreCase(this.httpMethod)) {
response = httpMethod;
t.getResponseHeaders().add("Content-Type", MediaType.TEXT_PLAIN.toString()); //Required for Spring 3.0.x
t.sendResponseHeaders(200, response.length());
}
else {
response = "Request is NOT valid";
t.sendResponseHeaders(404, 0);
}
OutputStream os = t.getResponseBody();
os.write(response.getBytes());
os.close();
}
}
public static class Port {
public String getPort() {
return Integer.toString(port);
}
this.mockServer.verify();
}
}