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

Migrate tests to AssertJ

Browse Source 
Mostly thanks to IDEA's plugin: https://plugins.jetbrains.com/plugin/10345-assertions2assertj
There is still a lot of work to do when complex and composite matchers are used.

* Add `awaitility` dependency and deprecate `EventuallyMatcher` in favor
of `awaitility`
* Remove Hamcrest from dependencies and disable JUnit & Hamcrest
static imports to encourage to use only AssertJ
* Migrate JUnit assumptions in rules to AssertJ's assumptions
* Deprecate some custom matchers in favor of existing in Hamcrest
after upgrading the last to version `2.1`
* Replace `ExpectedException` rules with `assertThatThrownBy()`
* Mention `MessagePredicate` in the `testing.adoc`
This commit is contained in:
Artem Bilan
2019-02-20 12:28:44 -05:00
parent b62c2a8fb3
commit 622d42c71a
916 changed files with 19714 additions and 21769 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
spring-integration-http/src/test/java/org/springframework/integration/http/HttpProxyScenarioTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2013-2017 the original author or authors.
* Copyright 2013-2019 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.
@@ -16,10 +16,7 @@
package org.springframework.integration.http;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.isNull;
import java.net.URI;
@@ -115,7 +112,7 @@ public class HttpProxyScenarioTests {
request.setContentType("text/plain");
Object handler = this.handlerMapping.getHandler(request).getHandler();
assertNotNull(handler);
assertThat(handler).isNotNull();
MockHttpServletResponse response = new MockHttpServletResponse();
@@ -125,12 +122,12 @@ public class HttpProxyScenarioTests {
Mockito.doAnswer(invocation -> {
URI uri = invocation.getArgument(0);
assertEquals(new URI("http://testServer/test?foo=bar&FOO=BAR"), uri);
assertThat(uri).isEqualTo(new URI("http://testServer/test?foo=bar&FOO=BAR"));
HttpEntity<?> httpEntity = (HttpEntity<?>) invocation.getArguments()[2];
HttpHeaders httpHeaders = httpEntity.getHeaders();
assertEquals(ifModifiedSince, httpHeaders.getIfModifiedSince());
assertEquals(ifUnmodifiedSinceValue, httpHeaders.getFirst("If-Unmodified-Since"));
assertEquals("Keep-Alive", httpHeaders.getFirst("Connection"));
assertThat(httpHeaders.getIfModifiedSince()).isEqualTo(ifModifiedSince);
assertThat(httpHeaders.getFirst("If-Unmodified-Since")).isEqualTo(ifUnmodifiedSinceValue);
assertThat(httpHeaders.getFirst("Connection")).isEqualTo("Keep-Alive");
MultiValueMap<String, String> responseHeaders = new LinkedMultiValueMap<String, String>(httpHeaders);
responseHeaders.set("Connection", "close");
@@ -147,17 +144,17 @@ public class HttpProxyScenarioTests {
this.handlerAdapter.handle(request, response, handler);
assertEquals(ifModifiedSinceValue, response.getHeaderValue("If-Modified-Since"));
assertEquals(ifUnmodifiedSinceValue, response.getHeaderValue("If-Unmodified-Since"));
assertEquals("close", response.getHeaderValue("Connection"));
assertEquals(contentDispositionValue, response.getHeader("Content-Disposition"));
assertEquals("text/plain", response.getContentType());
assertThat(response.getHeaderValue("If-Modified-Since")).isEqualTo(ifModifiedSinceValue);
assertThat(response.getHeaderValue("If-Unmodified-Since")).isEqualTo(ifUnmodifiedSinceValue);
assertThat(response.getHeaderValue("Connection")).isEqualTo("close");
assertThat(response.getHeader("Content-Disposition")).isEqualTo(contentDispositionValue);
assertThat(response.getContentType()).isEqualTo("text/plain");
Message<?> message = this.checkHeadersChannel.receive(2000);
MessageHeaders headers = message.getHeaders();
assertEquals(ifModifiedSince, headers.get("If-Modified-Since"));
assertEquals(ifUnmodifiedSince, headers.get("If-Unmodified-Since"));
assertThat(headers.get("If-Modified-Since")).isEqualTo(ifModifiedSince);
assertThat(headers.get("If-Unmodified-Since")).isEqualTo(ifUnmodifiedSince);
RequestContextHolder.resetRequestAttributes();
}
@@ -171,23 +168,23 @@ public class HttpProxyScenarioTests {
request.setContent("foo".getBytes());
Object handler = this.handlerMapping.getHandler(request).getHandler();
assertNotNull(handler);
assertThat(handler).isNotNull();
MockHttpServletResponse response = new MockHttpServletResponse();
RestTemplate template = Mockito.spy(new RestTemplate());
Mockito.doAnswer(invocation -> {
URI uri = invocation.getArgument(0);
assertEquals(new URI("http://testServer/testmp"), uri);
assertThat(uri).isEqualTo(new URI("http://testServer/testmp"));
HttpEntity<?> httpEntity = (HttpEntity<?>) invocation.getArguments()[2];
HttpHeaders httpHeaders = httpEntity.getHeaders();
assertEquals("Keep-Alive", httpHeaders.getFirst("Connection"));
assertEquals("multipart/form-data;boundary=----WebKitFormBoundarywABD2xqC1FLBijlQ",
httpHeaders.getContentType().toString());
assertThat(httpHeaders.getFirst("Connection")).isEqualTo("Keep-Alive");
assertThat(httpHeaders.getContentType().toString())
.isEqualTo("multipart/form-data;boundary=----WebKitFormBoundarywABD2xqC1FLBijlQ");
HttpEntity<?> entity = (HttpEntity<?>) invocation.getArguments()[2];
assertThat(entity.getBody(), instanceOf(byte[].class));
assertEquals("foo", new String((byte[]) entity.getBody()));
assertThat(entity.getBody()).isInstanceOf(byte[].class);
assertThat(new String((byte[]) entity.getBody())).isEqualTo("foo");
MultiValueMap<String, String> responseHeaders = new LinkedMultiValueMap<String, String>(httpHeaders);
responseHeaders.set("Connection", "close");
@@ -204,8 +201,8 @@ public class HttpProxyScenarioTests {
this.handlerAdapter.handle(request, response, handler);
assertEquals("close", response.getHeaderValue("Connection"));
assertEquals("text/plain", response.getContentType());
assertThat(response.getHeaderValue("Connection")).isEqualTo("close");
assertThat(response.getContentType()).isEqualTo("text/plain");
RequestContextHolder.resetRequestAttributes();
}

11
spring-integration-http/src/test/java/org/springframework/integration/http/config/ChainElementsTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,8 +16,8 @@
package org.springframework.integration.http.config;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.io.ByteArrayInputStream;
import java.util.Properties;
@@ -52,8 +52,9 @@ public class ChainElementsTests {
"'request-channel' attribute isn't allowed for a nested " +
"(e.g. inside a <chain/>) endpoint element: 'int-http:outbound-gateway'.";
final String actualMessage = e.getMessage();
assertTrue("Error message did not start with '" + expectedMessage +
"' but instead returned: '" + actualMessage + "'", actualMessage.startsWith(expectedMessage));
assertThat(actualMessage.startsWith(expectedMessage))
.as("Error message did not start with '" + expectedMessage +
"' but instead returned: '" + actualMessage + "'").isTrue();
}
}

24
spring-integration-http/src/test/java/org/springframework/integration/http/config/DefaultConfigurationTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,9 +16,7 @@
package org.springframework.integration.http.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -53,31 +51,31 @@ public class DefaultConfigurationTests {
@Test
public void verifyErrorChannel() {
Object errorChannel = context.getBean("errorChannel");
assertNotNull(errorChannel);
assertEquals(PublishSubscribeChannel.class, errorChannel.getClass());
assertThat(errorChannel).isNotNull();
assertThat(errorChannel.getClass()).isEqualTo(PublishSubscribeChannel.class);
}
@Test
public void verifyNullChannel() {
Object nullChannel = context.getBean("nullChannel");
assertNotNull(nullChannel);
assertEquals(NullChannel.class, nullChannel.getClass());
assertThat(nullChannel).isNotNull();
assertThat(nullChannel.getClass()).isEqualTo(NullChannel.class);
}
@Test
public void verifyTaskScheduler() {
Object taskScheduler = context.getBean(IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME);
assertEquals(ThreadPoolTaskScheduler.class, taskScheduler.getClass());
assertThat(taskScheduler.getClass()).isEqualTo(ThreadPoolTaskScheduler.class);
ErrorHandler errorHandler = TestUtils.getPropertyValue(taskScheduler, "errorHandler", ErrorHandler.class);
assertEquals(MessagePublishingErrorHandler.class, errorHandler.getClass());
assertThat(errorHandler.getClass()).isEqualTo(MessagePublishingErrorHandler.class);
MessageChannel defaultErrorChannel = TestUtils.getPropertyValue(errorHandler,
"messagingTemplate.defaultDestination", MessageChannel.class);
assertNull(defaultErrorChannel);
assertThat(defaultErrorChannel).isNull();
errorHandler.handleError(new Throwable());
defaultErrorChannel = TestUtils.getPropertyValue(errorHandler, "messagingTemplate.defaultDestination",
MessageChannel.class);
assertNotNull(defaultErrorChannel);
assertEquals(context.getBean(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME), defaultErrorChannel);
assertThat(defaultErrorChannel).isNotNull();
assertThat(defaultErrorChannel).isEqualTo(context.getBean(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME));
}
}

102
spring-integration-http/src/test/java/org/springframework/integration/http/config/HttpInboundChannelAdapterParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,14 +16,7 @@
package org.springframework.integration.http.config;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
@@ -125,28 +118,28 @@ public class HttpInboundChannelAdapterParserTests extends AbstractHttpInboundTes
@Test
@SuppressWarnings("unchecked")
public void getRequestOk() throws Exception {
assertFalse(TestUtils.getPropertyValue(this.defaultAdapter, "autoStartup", Boolean.class));
assertEquals(1001, TestUtils.getPropertyValue(this.defaultAdapter, "phase"));
assertThat(TestUtils.getPropertyValue(this.defaultAdapter, "autoStartup", Boolean.class)).isFalse();
assertThat(TestUtils.getPropertyValue(this.defaultAdapter, "phase")).isEqualTo(1001);
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("GET");
request.setParameter("foo", "bar");
MockHttpServletResponse response = new MockHttpServletResponse();
this.defaultAdapter.handleRequest(request, response);
assertEquals(HttpServletResponse.SC_SERVICE_UNAVAILABLE, response.getStatus());
assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_SERVICE_UNAVAILABLE);
this.defaultAdapter.start();
response = new MockHttpServletResponse();
this.defaultAdapter.handleRequest(request, response);
assertEquals(HttpServletResponse.SC_SWITCHING_PROTOCOLS, response.getStatus());
assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_SWITCHING_PROTOCOLS);
Message<?> message = requests.receive(0);
assertNotNull(message);
assertThat(message).isNotNull();
Object payload = message.getPayload();
assertTrue(payload instanceof MultiValueMap);
assertThat(payload instanceof MultiValueMap).isTrue();
MultiValueMap<String, String> map = (MultiValueMap<String, String>) payload;
assertEquals(1, map.size());
assertEquals("foo", map.keySet().iterator().next());
assertEquals(1, map.get("foo").size());
assertEquals("bar", map.getFirst("foo"));
assertNotNull(TestUtils.getPropertyValue(this.defaultAdapter, "errorChannel"));
assertThat(map.size()).isEqualTo(1);
assertThat(map.keySet().iterator().next()).isEqualTo("foo");
assertThat(map.get("foo").size()).isEqualTo(1);
assertThat(map.getFirst("foo")).isEqualTo("bar");
assertThat(TestUtils.getPropertyValue(this.defaultAdapter, "errorChannel")).isNotNull();
}
@Test
@@ -159,9 +152,9 @@ public class HttpInboundChannelAdapterParserTests extends AbstractHttpInboundTes
headers.set("bar", "bar");
headers.set("baz", "baz");
Map<String, Object> map = headerMapper.toHeaders(headers);
assertTrue(map.size() == 2);
assertEquals("foo", map.get("foo"));
assertEquals("bar", map.get("bar"));
assertThat(map.size() == 2).isTrue();
assertThat(map.get("foo")).isEqualTo("foo");
assertThat(map.get("bar")).isEqualTo("bar");
}
@Test
@@ -184,13 +177,13 @@ public class HttpInboundChannelAdapterParserTests extends AbstractHttpInboundTes
MockHttpServletResponse response = new MockHttpServletResponse();
inboundAdapterWithExpressions.handleRequest(request, response);
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
Message<?> message = requests.receive(0);
assertNotNull(message);
assertThat(message).isNotNull();
Object payload = message.getPayload();
assertTrue(payload instanceof String);
assertEquals("bill", payload);
assertEquals("clinton", message.getHeaders().get("lname"));
assertThat(payload instanceof String).isTrue();
assertThat(payload).isEqualTo("bill");
assertThat(message.getHeaders().get("lname")).isEqualTo("clinton");
}
@Test
@@ -203,8 +196,8 @@ public class HttpInboundChannelAdapterParserTests extends AbstractHttpInboundTes
this.integrationRequestMappingHandlerMapping.getHandler(request);
}
catch (HttpRequestMethodNotSupportedException e) {
assertEquals("GET", e.getMethod());
assertArrayEquals(new String[] {"POST"}, e.getSupportedMethods());
assertThat(e.getMethod()).isEqualTo("GET");
assertThat(e.getSupportedMethods()).isEqualTo(new String[] { "POST" });
}
}
@@ -218,15 +211,15 @@ public class HttpInboundChannelAdapterParserTests extends AbstractHttpInboundTes
MockHttpServletResponse response = new MockHttpServletResponse();
postOnlyAdapter.handleRequest(request, response);
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
Message<?> message = requests.receive(0);
MessageHistory history = MessageHistory.read(message);
assertNotNull(history);
assertThat(history).isNotNull();
Properties componentHistoryRecord = TestUtils.locateComponentInHistory(history, "postOnlyAdapter", 0);
assertNotNull(componentHistoryRecord);
assertEquals("http:inbound-channel-adapter", componentHistoryRecord.get("type"));
assertNotNull(message);
assertEquals("test", message.getPayload());
assertThat(componentHistoryRecord).isNotNull();
assertThat(componentHistoryRecord.get("type")).isEqualTo("http:inbound-channel-adapter");
assertThat(message).isNotNull();
assertThat(message.getPayload()).isEqualTo("test");
}
@Test @DirtiesContext
@@ -242,11 +235,11 @@ public class HttpInboundChannelAdapterParserTests extends AbstractHttpInboundTes
MockHttpServletResponse response = new MockHttpServletResponse();
adapterWithCustomConverterWithDefaults.handleRequest(request, response);
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
Message<?> message = requests.receive(0);
assertNotNull(message);
assertTrue(message.getPayload() instanceof TestObject);
assertEquals("testObject", ((TestObject) message.getPayload()).text);
assertThat(message).isNotNull();
assertThat(message.getPayload() instanceof TestObject).isTrue();
assertThat(((TestObject) message.getPayload()).text).isEqualTo("testObject");
}
@@ -254,46 +247,47 @@ public class HttpInboundChannelAdapterParserTests extends AbstractHttpInboundTes
public void putOrDeleteMethodsSupported() throws Exception {
HttpMethod[] supportedMethods =
TestUtils.getPropertyValue(putOrDeleteAdapter, "requestMapping.methods", HttpMethod[].class);
assertEquals(2, supportedMethods.length);
assertArrayEquals(new HttpMethod[]{HttpMethod.PUT, HttpMethod.DELETE}, supportedMethods);
assertThat(supportedMethods.length).isEqualTo(2);
assertThat(supportedMethods).isEqualTo(new HttpMethod[] { HttpMethod.PUT, HttpMethod.DELETE });
}
@Test
public void testController() throws Exception {
String errorCode = TestUtils.getPropertyValue(inboundController, "errorCode", String.class);
assertEquals("oops", errorCode);
assertThat(errorCode).isEqualTo("oops");
Expression viewExpression = TestUtils.getPropertyValue(inboundController, "viewExpression", Expression.class);
assertEquals("foo", viewExpression.getExpressionString());
assertThat(viewExpression.getExpressionString()).isEqualTo("foo");
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("GET");
request.setParameter("foo", "bar");
MockHttpServletResponse response = new MockHttpServletResponse();
inboundController.handleRequest(request, response);
assertEquals(HttpServletResponse.SC_ACCEPTED, response.getStatus());
assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_ACCEPTED);
Message<?> message = requests.receive(0);
assertNotNull(message);
assertThat(message).isNotNull();
}
@Test
public void testInt2717ControllerWithViewExpression() throws Exception {
Expression viewExpression = TestUtils.getPropertyValue(inboundControllerViewExp, "viewExpression", Expression.class);
assertEquals("'foo'", viewExpression.getExpressionString());
assertThat(viewExpression.getExpressionString()).isEqualTo("'foo'");
}
@Test
public void testAutoChannel() {
assertSame(autoChannel, TestUtils.getPropertyValue(autoChannelAdapter, "requestChannel"));
assertThat(TestUtils.getPropertyValue(autoChannelAdapter, "requestChannel")).isSameAs(autoChannel);
}
@Test
public void testInboundAdapterWithMessageConverterDefaults() {
@SuppressWarnings("unchecked")
List<HttpMessageConverter<?>> messageConverters = TestUtils.getPropertyValue(adapterWithCustomConverterWithDefaults, "messageConverters", List.class);
assertTrue("There should be more than 1 message converter. The customized one and the defaults.", messageConverters.size() > 1);
assertThat(messageConverters.size() > 1)
.as("There should be more than 1 message converter. The customized one and the defaults.").isTrue();
//First converter should be the customized one
assertThat(messageConverters.get(0), instanceOf(SerializingHttpMessageConverter.class));
assertThat(messageConverters.get(0)).isInstanceOf(SerializingHttpMessageConverter.class);
}
@Test
@@ -301,15 +295,17 @@ public class HttpInboundChannelAdapterParserTests extends AbstractHttpInboundTes
@SuppressWarnings("unchecked")
List<HttpMessageConverter<?>> messageConverters = TestUtils.getPropertyValue(adapterWithCustomConverterNoDefaults, "messageConverters", List.class);
//First converter should be the customized one
assertThat(messageConverters.get(0), instanceOf(SerializingHttpMessageConverter.class));
assertTrue("There should be only the customized messageconverter registered.", messageConverters.size() == 1);
assertThat(messageConverters.get(0)).isInstanceOf(SerializingHttpMessageConverter.class);
assertThat(messageConverters.size() == 1).as("There should be only the customized messageconverter registered.")
.isTrue();
}
@Test
public void testInboundAdapterWithNoMessageConverterNoDefaults() {
@SuppressWarnings("unchecked")
List<HttpMessageConverter<?>> messageConverters = TestUtils.getPropertyValue(adapterNoCustomConverterNoDefaults, "messageConverters", List.class);
assertTrue("There should be more than 1 message converter. The defaults.", messageConverters.size() > 1);
assertThat(messageConverters.size() > 1).as("There should be more than 1 message converter. The defaults.")
.isTrue();
}
@SuppressWarnings("serial")

104
spring-integration-http/src/test/java/org/springframework/integration/http/config/HttpInboundGatewayParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,15 +16,7 @@
package org.springframework.integration.http.config;
import static org.hamcrest.CoreMatchers.any;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.integration.test.util.TestUtils.getPropertyValue;
import java.util.ArrayList;
@@ -35,7 +27,6 @@ import java.util.Map;
import javax.servlet.http.HttpServletResponse;
import org.hamcrest.Matcher;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -54,8 +45,6 @@ import org.springframework.integration.http.inbound.HttpRequestHandlingControlle
import org.springframework.integration.http.inbound.HttpRequestHandlingMessagingGateway;
import org.springframework.integration.http.support.DefaultHttpHeaderMapper;
import org.springframework.integration.test.util.TestUtils;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.PollableChannel;
import org.springframework.messaging.SubscribableChannel;
@@ -118,34 +107,37 @@ public class HttpInboundGatewayParserTests {
@Test
public void checkConfig() {
assertNotNull(this.gateway);
assertTrue(getPropertyValue(this.gateway, "expectReply", Boolean.class));
assertTrue(getPropertyValue(this.gateway, "convertExceptions", Boolean.class));
assertSame(this.responses, getPropertyValue(this.gateway, "replyChannel"));
assertNotNull(TestUtils.getPropertyValue(this.gateway, "errorChannel"));
assertThat(this.gateway).isNotNull();
assertThat(getPropertyValue(this.gateway, "expectReply", Boolean.class)).isTrue();
assertThat(getPropertyValue(this.gateway, "convertExceptions", Boolean.class)).isTrue();
assertThat(getPropertyValue(this.gateway, "replyChannel")).isSameAs(this.responses);
assertThat(TestUtils.getPropertyValue(this.gateway, "errorChannel")).isNotNull();
MessagingTemplate messagingTemplate =
TestUtils.getPropertyValue(this.gateway, "messagingTemplate", MessagingTemplate.class);
assertEquals(1234L, TestUtils.getPropertyValue(messagingTemplate, "sendTimeout"));
assertEquals(4567L, TestUtils.getPropertyValue(messagingTemplate, "receiveTimeout"));
assertThat(TestUtils.getPropertyValue(messagingTemplate, "sendTimeout")).isEqualTo(1234L);
assertThat(TestUtils.getPropertyValue(messagingTemplate, "receiveTimeout")).isEqualTo(4567L);
boolean registerDefaultConverters =
TestUtils.getPropertyValue(this.gateway, "mergeWithDefaultConverters", Boolean.class);
assertFalse("By default the register-default-converters flag should be false", registerDefaultConverters);
assertThat(registerDefaultConverters).as("By default the register-default-converters flag should be false")
.isFalse();
@SuppressWarnings("unchecked")
List<HttpMessageConverter<?>> messageConverters =
TestUtils.getPropertyValue(this.gateway, "messageConverters", List.class);
assertTrue("The default converters should have been registered, given there are no custom converters",
messageConverters.size() > 0);
assertThat(messageConverters.size() > 0)
.as("The default converters should have been registered, given there are no custom converters")
.isTrue();
assertFalse(TestUtils.getPropertyValue(this.gateway, "autoStartup", Boolean.class));
assertEquals(1001, TestUtils.getPropertyValue(this.gateway, "phase"));
assertThat(TestUtils.getPropertyValue(this.gateway, "autoStartup", Boolean.class)).isFalse();
assertThat(TestUtils.getPropertyValue(this.gateway, "phase")).isEqualTo(1001);
}
@Test
@DirtiesContext
public void checkFlow() throws Exception {
this.requests.subscribe(handlerExpecting(any(Message.class)));
this.requests.subscribe(m -> {
});
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("GET");
request.addHeader("Accept", "application/my-serialized");
@@ -162,28 +154,28 @@ public class HttpInboundGatewayParserTests {
this.gateway.start();
this.gateway.handleRequest(request, response);
assertThat(response.getStatus(), is(HttpServletResponse.SC_OK));
assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
assertEquals(response.getContentType(), "application/my-serialized");
assertThat("application/my-serialized").isEqualTo(response.getContentType());
}
@Test
public void testController() {
DirectFieldAccessor accessor = new DirectFieldAccessor(inboundController);
String errorCode = (String) accessor.getPropertyValue("errorCode");
assertEquals("oops", errorCode);
assertThat(errorCode).isEqualTo("oops");
LiteralExpression viewExpression = (LiteralExpression) accessor.getPropertyValue("viewExpression");
assertEquals("foo", viewExpression.getValue());
assertThat(viewExpression.getValue()).isEqualTo("foo");
}
@Test
public void testControllerViewExp() {
DirectFieldAccessor accessor = new DirectFieldAccessor(inboundControllerViewExp);
String errorCode = (String) accessor.getPropertyValue("errorCode");
assertEquals("oops", errorCode);
assertThat(errorCode).isEqualTo("oops");
SpelExpression viewExpression = (SpelExpression) accessor.getPropertyValue("viewExpression");
assertNotNull(viewExpression);
assertEquals("'bar'", viewExpression.getExpressionString());
assertThat(viewExpression).isNotNull();
assertThat(viewExpression.getExpressionString()).isEqualTo("'bar'");
}
@Test
@@ -196,18 +188,18 @@ public class HttpInboundGatewayParserTests {
headers.set("bar", "bar");
headers.set("baz", "baz");
Map<String, Object> map = headerMapper.toHeaders(headers);
assertEquals(2, map.size());
assertEquals("foo", map.get("foo"));
assertEquals("bar", map.get("bar"));
assertThat(map.size()).isEqualTo(2);
assertThat(map.get("foo")).isEqualTo("foo");
assertThat(map.get("bar")).isEqualTo("bar");
Map<String, Object> mapOfHeaders = new HashMap<String, Object>();
mapOfHeaders.put("abc", "abc");
MessageHeaders mh = new MessageHeaders(mapOfHeaders);
headers = new HttpHeaders();
headerMapper.fromHeaders(mh, headers);
assertEquals(1, headers.size());
assertThat(headers.size()).isEqualTo(1);
List<String> abc = headers.get("abc");
assertEquals("abc", abc.get(0));
assertThat(abc.get(0)).isEqualTo("abc");
}
@Test
@@ -223,9 +215,9 @@ public class HttpInboundGatewayParserTests {
headers.set("bar", "bar");
headers.set("baz", "baz");
Map<String, Object> map = headerMapper.toHeaders(headers);
assertEquals(2, map.size());
assertEquals("foo", map.get("foo"));
assertEquals("bar", map.get("bar"));
assertThat(map.size()).isEqualTo(2);
assertThat(map.get("foo")).isEqualTo("foo");
assertThat(map.get("bar")).isEqualTo("bar");
Map<String, Object> mapOfHeaders = new HashMap<>();
mapOfHeaders.put("abc", "abc");
@@ -235,11 +227,11 @@ public class HttpInboundGatewayParserTests {
MessageHeaders mh = new MessageHeaders(mapOfHeaders);
headers = new HttpHeaders();
headerMapper.fromHeaders(mh, headers);
assertEquals(2, headers.size());
assertThat(headers.size()).isEqualTo(2);
List<String> abc = headers.get("X-abc");
assertEquals("abc", abc.get(0));
assertThat(abc.get(0)).isEqualTo("abc");
List<String> personHeaders = headers.get("X-person");
assertEquals("Oleg", personHeaders.get(0));
assertThat(personHeaders.get(0)).isEqualTo("Oleg");
}
@Test
@@ -247,11 +239,12 @@ public class HttpInboundGatewayParserTests {
@SuppressWarnings("unchecked")
List<HttpMessageConverter<?>> messageConverters =
TestUtils.getPropertyValue(this.gatewayWithOneCustomConverter, "messageConverters", List.class);
assertThat("There should be only 1 message converter, by default register-default-converters is off",
messageConverters.size(), is(1));
assertThat(messageConverters.size())
.as("There should be only 1 message converter, by default register-default-converters is off")
.isEqualTo(1);
//The converter should be the customized one
assertThat(messageConverters.get(0), instanceOf(SerializingHttpMessageConverter.class));
assertThat(messageConverters.get(0)).isInstanceOf(SerializingHttpMessageConverter.class);
}
@Test
@@ -260,10 +253,10 @@ public class HttpInboundGatewayParserTests {
List<HttpMessageConverter<?>> messageConverters =
TestUtils.getPropertyValue(this.gatewayNoDefaultConverters, "messageConverters", List.class);
//First converter should be the customized one
assertThat(messageConverters.get(0), instanceOf(SerializingHttpMessageConverter.class));
assertThat(messageConverters.get(0)).isInstanceOf(SerializingHttpMessageConverter.class);
assertThat("There should be only 1 message converter, the register-default-converters is false",
messageConverters.size(), is(1));
assertThat(messageConverters.size())
.as("There should be only 1 message converter, the register-default-converters is false").isEqualTo(1);
}
@Test
@@ -273,18 +266,11 @@ public class HttpInboundGatewayParserTests {
TestUtils.getPropertyValue(this.gatewayWithCustomAndDefaultConverters, "messageConverters",
List.class);
//First converter should be the customized one
assertThat(messageConverters.get(0), instanceOf(SerializingHttpMessageConverter.class));
assertThat(messageConverters.get(0)).isInstanceOf(SerializingHttpMessageConverter.class);
assertTrue("There should be more than one converter",
messageConverters.size() > 1);
assertThat(messageConverters.size() > 1).as("There should be more than one converter").isTrue();
}
@SuppressWarnings("rawtypes")
private MessageHandler handlerExpecting(final Matcher<Message> messageMatcher) {
return message -> assertThat(message, is(messageMatcher));
}
public static class Person {
private String name;

155
spring-integration-http/src/test/java/org/springframework/integration/http/config/HttpOutboundChannelAdapterParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,19 +16,12 @@
package org.springframework.integration.http.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Map;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -118,21 +111,23 @@ public class HttpOutboundChannelAdapterParserTests {
DirectFieldAccessor endpointAccessor = new DirectFieldAccessor(this.minimalConfig);
RestTemplate restTemplate =
TestUtils.getPropertyValue(this.minimalConfig, "handler.restTemplate", RestTemplate.class);
assertNotSame(customRestTemplate, restTemplate);
assertThat(restTemplate).isNotSameAs(customRestTemplate);
HttpRequestExecutingMessageHandler handler = (HttpRequestExecutingMessageHandler) endpointAccessor.getPropertyValue("handler");
DirectFieldAccessor handlerAccessor = new DirectFieldAccessor(handler);
assertEquals(false, handlerAccessor.getPropertyValue("expectReply"));
assertEquals(this.applicationContext.getBean("requests"), endpointAccessor.getPropertyValue("inputChannel"));
assertNull(handlerAccessor.getPropertyValue("outputChannel"));
assertThat(handlerAccessor.getPropertyValue("expectReply")).isEqualTo(false);
assertThat(endpointAccessor.getPropertyValue("inputChannel"))
.isEqualTo(this.applicationContext.getBean("requests"));
assertThat(handlerAccessor.getPropertyValue("outputChannel")).isNull();
DirectFieldAccessor templateAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("restTemplate"));
ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory)
templateAccessor.getPropertyValue("requestFactory");
assertTrue(requestFactory instanceof SimpleClientHttpRequestFactory);
assertThat(requestFactory instanceof SimpleClientHttpRequestFactory).isTrue();
Expression uriExpression = (Expression) handlerAccessor.getPropertyValue("uriExpression");
assertEquals("http://localhost/test1", uriExpression.getValue());
assertEquals(HttpMethod.POST.name(), TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString());
assertEquals(Charset.forName("UTF-8"), handlerAccessor.getPropertyValue("charset"));
assertEquals(true, handlerAccessor.getPropertyValue("extractPayload"));
assertThat(uriExpression.getValue()).isEqualTo("http://localhost/test1");
assertThat(TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString())
.isEqualTo(HttpMethod.POST.name());
assertThat(handlerAccessor.getPropertyValue("charset")).isEqualTo(Charset.forName("UTF-8"));
assertThat(handlerAccessor.getPropertyValue("extractPayload")).isEqualTo(true);
}
@Test
@@ -141,45 +136,48 @@ public class HttpOutboundChannelAdapterParserTests {
DirectFieldAccessor endpointAccessor = new DirectFieldAccessor(this.fullConfig);
HttpRequestExecutingMessageHandler handler = (HttpRequestExecutingMessageHandler) endpointAccessor.getPropertyValue("handler");
DirectFieldAccessor handlerAccessor = new DirectFieldAccessor(handler);
assertEquals(false, handlerAccessor.getPropertyValue("expectReply"));
assertEquals(this.applicationContext.getBean("requests"), endpointAccessor.getPropertyValue("inputChannel"));
assertNull(handlerAccessor.getPropertyValue("outputChannel"));
assertEquals(77, handlerAccessor.getPropertyValue("order"));
assertEquals(Boolean.FALSE, endpointAccessor.getPropertyValue("autoStartup"));
assertThat(handlerAccessor.getPropertyValue("expectReply")).isEqualTo(false);
assertThat(endpointAccessor.getPropertyValue("inputChannel"))
.isEqualTo(this.applicationContext.getBean("requests"));
assertThat(handlerAccessor.getPropertyValue("outputChannel")).isNull();
assertThat(handlerAccessor.getPropertyValue("order")).isEqualTo(77);
assertThat(endpointAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
DirectFieldAccessor templateAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("restTemplate"));
ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory)
templateAccessor.getPropertyValue("requestFactory");
assertEquals(Boolean.class.getName(), TestUtils.getPropertyValue(handler, "expectedResponseTypeExpression", Expression.class).getValue());
assertTrue(requestFactory instanceof SimpleClientHttpRequestFactory);
assertThat(TestUtils.getPropertyValue(handler, "expectedResponseTypeExpression", Expression.class).getValue())
.isEqualTo(Boolean.class.getName());
assertThat(requestFactory instanceof SimpleClientHttpRequestFactory).isTrue();
Object converterListBean = this.applicationContext.getBean("converterList");
assertEquals(converterListBean, templateAccessor.getPropertyValue("messageConverters"));
assertThat(templateAccessor.getPropertyValue("messageConverters")).isEqualTo(converterListBean);
Object requestFactoryBean = this.applicationContext.getBean("testRequestFactory");
assertEquals(requestFactoryBean, requestFactory);
assertThat(requestFactory).isEqualTo(requestFactoryBean);
Object errorHandlerBean = this.applicationContext.getBean("testErrorHandler");
assertEquals(errorHandlerBean, templateAccessor.getPropertyValue("errorHandler"));
assertThat(templateAccessor.getPropertyValue("errorHandler")).isEqualTo(errorHandlerBean);
Expression uriExpression = (Expression) handlerAccessor.getPropertyValue("uriExpression");
assertEquals("http://localhost/test2/{foo}", uriExpression.getValue());
assertEquals(HttpMethod.GET.name(), TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString());
assertEquals(Charset.forName("UTF-8"), handlerAccessor.getPropertyValue("charset"));
assertEquals(false, handlerAccessor.getPropertyValue("extractPayload"));
assertThat(uriExpression.getValue()).isEqualTo("http://localhost/test2/{foo}");
assertThat(TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString())
.isEqualTo(HttpMethod.GET.name());
assertThat(handlerAccessor.getPropertyValue("charset")).isEqualTo(Charset.forName("UTF-8"));
assertThat(handlerAccessor.getPropertyValue("extractPayload")).isEqualTo(false);
Map<String, Expression> uriVariableExpressions =
(Map<String, Expression>) handlerAccessor.getPropertyValue("uriVariableExpressions");
assertEquals(1, uriVariableExpressions.size());
assertEquals("headers.bar", uriVariableExpressions.get("foo").getExpressionString());
assertThat(uriVariableExpressions.size()).isEqualTo(1);
assertThat(uriVariableExpressions.get("foo").getExpressionString()).isEqualTo("headers.bar");
DirectFieldAccessor mapperAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("headerMapper"));
String[] mappedRequestHeaders = (String[]) mapperAccessor.getPropertyValue("outboundHeaderNames");
String[] mappedResponseHeaders = (String[]) mapperAccessor.getPropertyValue("inboundHeaderNames");
assertEquals(2, mappedRequestHeaders.length);
assertEquals(0, mappedResponseHeaders.length);
assertTrue(ObjectUtils.containsElement(mappedRequestHeaders, "requestHeader1"));
assertTrue(ObjectUtils.containsElement(mappedRequestHeaders, "requestHeader2"));
assertThat(mappedRequestHeaders.length).isEqualTo(2);
assertThat(mappedResponseHeaders.length).isEqualTo(0);
assertThat(ObjectUtils.containsElement(mappedRequestHeaders, "requestHeader1")).isTrue();
assertThat(ObjectUtils.containsElement(mappedRequestHeaders, "requestHeader2")).isTrue();
}
@Test
public void restTemplateConfig() {
RestTemplate restTemplate =
TestUtils.getPropertyValue(this.restTemplateConfig, "handler.restTemplate", RestTemplate.class);
assertEquals(customRestTemplate, restTemplate);
assertThat(restTemplate).isEqualTo(customRestTemplate);
}
@Test(expected = BeanDefinitionParsingException.class)
@@ -193,29 +191,31 @@ public class HttpOutboundChannelAdapterParserTests {
DirectFieldAccessor endpointAccessor = new DirectFieldAccessor(this.withUrlAndTemplate);
RestTemplate restTemplate =
TestUtils.getPropertyValue(this.withUrlAndTemplate, "handler.restTemplate", RestTemplate.class);
assertSame(customRestTemplate, restTemplate);
assertThat(restTemplate).isSameAs(customRestTemplate);
HttpRequestExecutingMessageHandler handler = (HttpRequestExecutingMessageHandler) endpointAccessor.getPropertyValue("handler");
DirectFieldAccessor handlerAccessor = new DirectFieldAccessor(handler);
assertEquals(false, handlerAccessor.getPropertyValue("expectReply"));
assertEquals(this.applicationContext.getBean("requests"), endpointAccessor.getPropertyValue("inputChannel"));
assertNull(handlerAccessor.getPropertyValue("outputChannel"));
assertThat(handlerAccessor.getPropertyValue("expectReply")).isEqualTo(false);
assertThat(endpointAccessor.getPropertyValue("inputChannel"))
.isEqualTo(this.applicationContext.getBean("requests"));
assertThat(handlerAccessor.getPropertyValue("outputChannel")).isNull();
DirectFieldAccessor templateAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("restTemplate"));
ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory)
templateAccessor.getPropertyValue("requestFactory");
assertTrue(requestFactory instanceof SimpleClientHttpRequestFactory);
assertThat(requestFactory instanceof SimpleClientHttpRequestFactory).isTrue();
Expression uriExpression = (Expression) handlerAccessor.getPropertyValue("uriExpression");
assertEquals("http://localhost/test1", uriExpression.getValue());
assertEquals(HttpMethod.POST.name(), TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString());
assertEquals(Charset.forName("UTF-8"), handlerAccessor.getPropertyValue("charset"));
assertEquals(true, handlerAccessor.getPropertyValue("extractPayload"));
assertThat(uriExpression.getValue()).isEqualTo("http://localhost/test1");
assertThat(TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString())
.isEqualTo(HttpMethod.POST.name());
assertThat(handlerAccessor.getPropertyValue("charset")).isEqualTo(Charset.forName("UTF-8"));
assertThat(handlerAccessor.getPropertyValue("extractPayload")).isEqualTo(true);
//INT-3055
Object uriVariablesExpression = handlerAccessor.getPropertyValue("uriVariablesExpression");
assertNotNull(uriVariablesExpression);
assertEquals("@uriVariables", ((Expression) uriVariablesExpression).getExpressionString());
assertThat(uriVariablesExpression).isNotNull();
assertThat(((Expression) uriVariablesExpression).getExpressionString()).isEqualTo("@uriVariables");
Object uriVariableExpressions = handlerAccessor.getPropertyValue("uriVariableExpressions");
assertNotNull(uriVariableExpressions);
assertTrue(((Map<?, ?>) uriVariableExpressions).isEmpty());
assertThat(uriVariableExpressions).isNotNull();
assertThat(((Map<?, ?>) uriVariableExpressions).isEmpty()).isTrue();
}
@Test
@@ -223,57 +223,62 @@ public class HttpOutboundChannelAdapterParserTests {
DirectFieldAccessor endpointAccessor = new DirectFieldAccessor(this.withUrlExpression);
RestTemplate restTemplate =
TestUtils.getPropertyValue(this.withUrlExpression, "handler.restTemplate", RestTemplate.class);
assertNotSame(customRestTemplate, restTemplate);
assertThat(restTemplate).isNotSameAs(customRestTemplate);
HttpRequestExecutingMessageHandler handler = (HttpRequestExecutingMessageHandler) endpointAccessor.getPropertyValue("handler");
DirectFieldAccessor handlerAccessor = new DirectFieldAccessor(handler);
assertEquals(false, handlerAccessor.getPropertyValue("expectReply"));
assertEquals(this.applicationContext.getBean("requests"), endpointAccessor.getPropertyValue("inputChannel"));
assertNull(handlerAccessor.getPropertyValue("outputChannel"));
assertThat(handlerAccessor.getPropertyValue("expectReply")).isEqualTo(false);
assertThat(endpointAccessor.getPropertyValue("inputChannel"))
.isEqualTo(this.applicationContext.getBean("requests"));
assertThat(handlerAccessor.getPropertyValue("outputChannel")).isNull();
DirectFieldAccessor templateAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("restTemplate"));
ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory)
templateAccessor.getPropertyValue("requestFactory");
assertTrue(requestFactory instanceof SimpleClientHttpRequestFactory);
assertThat(requestFactory instanceof SimpleClientHttpRequestFactory).isTrue();
SpelExpression expression = (SpelExpression) handlerAccessor.getPropertyValue("uriExpression");
assertNotNull(expression);
assertEquals("'http://localhost/test1'", expression.getExpressionString());
assertEquals(HttpMethod.POST.name(), TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString());
assertEquals(Charset.forName("UTF-8"), handlerAccessor.getPropertyValue("charset"));
assertEquals(true, handlerAccessor.getPropertyValue("extractPayload"));
assertThat(expression).isNotNull();
assertThat(expression.getExpressionString()).isEqualTo("'http://localhost/test1'");
assertThat(TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString())
.isEqualTo(HttpMethod.POST.name());
assertThat(handlerAccessor.getPropertyValue("charset")).isEqualTo(Charset.forName("UTF-8"));
assertThat(handlerAccessor.getPropertyValue("extractPayload")).isEqualTo(true);
}
@Test
public void withAdvice() {
MessageHandler handler = TestUtils.getPropertyValue(this.withAdvice, "handler", MessageHandler.class);
handler.handleMessage(new GenericMessage<String>("foo"));
assertEquals(1, adviceCalled);
assertThat(adviceCalled).isEqualTo(1);
}
@Test
public void withUrlExpressionAndTemplate() {
DirectFieldAccessor endpointAccessor = new DirectFieldAccessor(this.withUrlExpressionAndTemplate);
RestTemplate restTemplate =
TestUtils.getPropertyValue(this.withUrlExpressionAndTemplate, "handler.restTemplate", RestTemplate.class);
assertSame(customRestTemplate, restTemplate);
TestUtils.getPropertyValue(this.withUrlExpressionAndTemplate, "handler.restTemplate",
RestTemplate.class);
assertThat(restTemplate).isSameAs(customRestTemplate);
HttpRequestExecutingMessageHandler handler = (HttpRequestExecutingMessageHandler) endpointAccessor.getPropertyValue("handler");
DirectFieldAccessor handlerAccessor = new DirectFieldAccessor(handler);
assertEquals(false, handlerAccessor.getPropertyValue("expectReply"));
assertEquals(this.applicationContext.getBean("requests"), endpointAccessor.getPropertyValue("inputChannel"));
assertNull(handlerAccessor.getPropertyValue("outputChannel"));
assertThat(handlerAccessor.getPropertyValue("expectReply")).isEqualTo(false);
assertThat(endpointAccessor.getPropertyValue("inputChannel"))
.isEqualTo(this.applicationContext.getBean("requests"));
assertThat(handlerAccessor.getPropertyValue("outputChannel")).isNull();
DirectFieldAccessor templateAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("restTemplate"));
ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory)
templateAccessor.getPropertyValue("requestFactory");
assertTrue(requestFactory instanceof SimpleClientHttpRequestFactory);
assertThat(requestFactory instanceof SimpleClientHttpRequestFactory).isTrue();
SpelExpression expression = (SpelExpression) handlerAccessor.getPropertyValue("uriExpression");
assertNotNull(expression);
assertEquals("'http://localhost/test1'", expression.getExpressionString());
assertEquals(HttpMethod.POST.name(), TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString());
assertEquals(Charset.forName("UTF-8"), handlerAccessor.getPropertyValue("charset"));
assertEquals(true, handlerAccessor.getPropertyValue("extractPayload"));
assertThat(expression).isNotNull();
assertThat(expression.getExpressionString()).isEqualTo("'http://localhost/test1'");
assertThat(TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString())
.isEqualTo(HttpMethod.POST.name());
assertThat(handlerAccessor.getPropertyValue("charset")).isEqualTo(Charset.forName("UTF-8"));
assertThat(handlerAccessor.getPropertyValue("extractPayload")).isEqualTo(true);
}
@Test
public void withPoller() {
assertThat(this.withPoller1, Matchers.instanceOf(PollingConsumer.class));
assertThat(this.withPoller1).isInstanceOf(PollingConsumer.class);
}
@Test(expected = BeanDefinitionParsingException.class)

111
spring-integration-http/src/test/java/org/springframework/integration/http/config/HttpOutboundGatewayParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,18 +16,13 @@
package org.springframework.integration.http.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Map;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -100,20 +95,21 @@ public class HttpOutboundGatewayParserTests {
this.minimalConfigEndpoint).getPropertyValue("handler");
MessageChannel requestChannel = (MessageChannel) new DirectFieldAccessor(
this.minimalConfigEndpoint).getPropertyValue("inputChannel");
assertEquals(this.applicationContext.getBean("requests"), requestChannel);
assertThat(requestChannel).isEqualTo(this.applicationContext.getBean("requests"));
DirectFieldAccessor handlerAccessor = new DirectFieldAccessor(handler);
Object replyChannel = handlerAccessor.getPropertyValue("outputChannel");
assertNull(replyChannel);
assertThat(replyChannel).isNull();
DirectFieldAccessor templateAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("restTemplate"));
ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory)
templateAccessor.getPropertyValue("requestFactory");
assertTrue(requestFactory instanceof SimpleClientHttpRequestFactory);
assertThat(requestFactory instanceof SimpleClientHttpRequestFactory).isTrue();
Expression uriExpression = (Expression) handlerAccessor.getPropertyValue("uriExpression");
assertEquals("http://localhost/test1", uriExpression.getValue());
assertEquals(HttpMethod.POST.name(), TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString());
assertEquals(Charset.forName("UTF-8"), handlerAccessor.getPropertyValue("charset"));
assertEquals(true, handlerAccessor.getPropertyValue("extractPayload"));
assertEquals(false, handlerAccessor.getPropertyValue("transferCookies"));
assertThat(uriExpression.getValue()).isEqualTo("http://localhost/test1");
assertThat(TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString())
.isEqualTo(HttpMethod.POST.name());
assertThat(handlerAccessor.getPropertyValue("charset")).isEqualTo(Charset.forName("UTF-8"));
assertThat(handlerAccessor.getPropertyValue("extractPayload")).isEqualTo(true);
assertThat(handlerAccessor.getPropertyValue("transferCookies")).isEqualTo(false);
}
@Test
@@ -123,46 +119,48 @@ public class HttpOutboundGatewayParserTests {
HttpRequestExecutingMessageHandler handler = (HttpRequestExecutingMessageHandler) endpointAccessor.getPropertyValue("handler");
MessageChannel requestChannel = (MessageChannel) new DirectFieldAccessor(
this.fullConfigEndpoint).getPropertyValue("inputChannel");
assertEquals(this.applicationContext.getBean("requests"), requestChannel);
assertThat(requestChannel).isEqualTo(this.applicationContext.getBean("requests"));
DirectFieldAccessor handlerAccessor = new DirectFieldAccessor(handler);
assertEquals(77, handlerAccessor.getPropertyValue("order"));
assertEquals(Boolean.FALSE, endpointAccessor.getPropertyValue("autoStartup"));
assertThat(handlerAccessor.getPropertyValue("order")).isEqualTo(77);
assertThat(endpointAccessor.getPropertyValue("autoStartup")).isEqualTo(Boolean.FALSE);
Object replyChannel = handlerAccessor.getPropertyValue("outputChannel");
assertNotNull(replyChannel);
assertEquals(this.applicationContext.getBean("replies"), replyChannel);
assertThat(replyChannel).isNotNull();
assertThat(replyChannel).isEqualTo(this.applicationContext.getBean("replies"));
DirectFieldAccessor templateAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("restTemplate"));
ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory)
templateAccessor.getPropertyValue("requestFactory");
assertTrue(requestFactory instanceof SimpleClientHttpRequestFactory);
assertThat(requestFactory instanceof SimpleClientHttpRequestFactory).isTrue();
Object converterListBean = this.applicationContext.getBean("converterList");
assertEquals(converterListBean, templateAccessor.getPropertyValue("messageConverters"));
assertThat(templateAccessor.getPropertyValue("messageConverters")).isEqualTo(converterListBean);
assertEquals(String.class.getName(), TestUtils.getPropertyValue(handler, "expectedResponseTypeExpression", Expression.class).getValue());
assertThat(TestUtils.getPropertyValue(handler, "expectedResponseTypeExpression", Expression.class).getValue())
.isEqualTo(String.class.getName());
Expression uriExpression = (Expression) handlerAccessor.getPropertyValue("uriExpression");
assertEquals("http://localhost/test2", uriExpression.getValue());
assertEquals(HttpMethod.PUT.name(), TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString());
assertEquals(Charset.forName("UTF-8"), handlerAccessor.getPropertyValue("charset"));
assertEquals(false, handlerAccessor.getPropertyValue("extractPayload"));
assertThat(uriExpression.getValue()).isEqualTo("http://localhost/test2");
assertThat(TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString())
.isEqualTo(HttpMethod.PUT.name());
assertThat(handlerAccessor.getPropertyValue("charset")).isEqualTo(Charset.forName("UTF-8"));
assertThat(handlerAccessor.getPropertyValue("extractPayload")).isEqualTo(false);
Object requestFactoryBean = this.applicationContext.getBean("testRequestFactory");
assertEquals(requestFactoryBean, requestFactory);
assertThat(requestFactory).isEqualTo(requestFactoryBean);
Object errorHandlerBean = this.applicationContext.getBean("testErrorHandler");
assertEquals(errorHandlerBean, templateAccessor.getPropertyValue("errorHandler"));
assertThat(templateAccessor.getPropertyValue("errorHandler")).isEqualTo(errorHandlerBean);
Object sendTimeout = new DirectFieldAccessor(
handlerAccessor.getPropertyValue("messagingTemplate")).getPropertyValue("sendTimeout");
assertEquals(new Long("1234"), sendTimeout);
assertThat(sendTimeout).isEqualTo(new Long("1234"));
Map<String, Expression> uriVariableExpressions =
(Map<String, Expression>) handlerAccessor.getPropertyValue("uriVariableExpressions");
assertEquals(1, uriVariableExpressions.size());
assertEquals("headers.bar", uriVariableExpressions.get("foo").getExpressionString());
assertThat(uriVariableExpressions.size()).isEqualTo(1);
assertThat(uriVariableExpressions.get("foo").getExpressionString()).isEqualTo("headers.bar");
DirectFieldAccessor mapperAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("headerMapper"));
String[] mappedRequestHeaders = (String[]) mapperAccessor.getPropertyValue("outboundHeaderNames");
String[] mappedResponseHeaders = (String[]) mapperAccessor.getPropertyValue("inboundHeaderNames");
assertEquals(2, mappedRequestHeaders.length);
assertEquals(1, mappedResponseHeaders.length);
assertTrue(ObjectUtils.containsElement(mappedRequestHeaders, "requestHeader1"));
assertTrue(ObjectUtils.containsElement(mappedRequestHeaders, "requestHeader2"));
assertEquals("responseHeader", mappedResponseHeaders[0]);
assertEquals(true, handlerAccessor.getPropertyValue("transferCookies"));
assertThat(mappedRequestHeaders.length).isEqualTo(2);
assertThat(mappedResponseHeaders.length).isEqualTo(1);
assertThat(ObjectUtils.containsElement(mappedRequestHeaders, "requestHeader1")).isTrue();
assertThat(ObjectUtils.containsElement(mappedRequestHeaders, "requestHeader2")).isTrue();
assertThat(mappedResponseHeaders[0]).isEqualTo("responseHeader");
assertThat(handlerAccessor.getPropertyValue("transferCookies")).isEqualTo(true);
}
@Test
@@ -171,29 +169,30 @@ public class HttpOutboundGatewayParserTests {
this.withUrlExpressionEndpoint).getPropertyValue("handler");
MessageChannel requestChannel = (MessageChannel) new DirectFieldAccessor(
this.withUrlExpressionEndpoint).getPropertyValue("inputChannel");
assertEquals(this.applicationContext.getBean("requests"), requestChannel);
assertThat(requestChannel).isEqualTo(this.applicationContext.getBean("requests"));
DirectFieldAccessor handlerAccessor = new DirectFieldAccessor(handler);
Object replyChannel = handlerAccessor.getPropertyValue("outputChannel");
assertNull(replyChannel);
assertThat(replyChannel).isNull();
DirectFieldAccessor templateAccessor = new DirectFieldAccessor(handlerAccessor.getPropertyValue("restTemplate"));
ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory)
templateAccessor.getPropertyValue("requestFactory");
assertTrue(requestFactory instanceof SimpleClientHttpRequestFactory);
assertThat(requestFactory instanceof SimpleClientHttpRequestFactory).isTrue();
SpelExpression expression = (SpelExpression) handlerAccessor.getPropertyValue("uriExpression");
assertNotNull(expression);
assertEquals("'http://localhost/test1'", expression.getExpressionString());
assertEquals(HttpMethod.POST.name(), TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString());
assertEquals(Charset.forName("UTF-8"), handlerAccessor.getPropertyValue("charset"));
assertEquals(true, handlerAccessor.getPropertyValue("extractPayload"));
assertEquals(false, handlerAccessor.getPropertyValue("transferCookies"));
assertThat(expression).isNotNull();
assertThat(expression.getExpressionString()).isEqualTo("'http://localhost/test1'");
assertThat(TestUtils.getPropertyValue(handler, "httpMethodExpression", Expression.class).getExpressionString())
.isEqualTo(HttpMethod.POST.name());
assertThat(handlerAccessor.getPropertyValue("charset")).isEqualTo(Charset.forName("UTF-8"));
assertThat(handlerAccessor.getPropertyValue("extractPayload")).isEqualTo(true);
assertThat(handlerAccessor.getPropertyValue("transferCookies")).isEqualTo(false);
//INT-3055
Object uriVariablesExpression = handlerAccessor.getPropertyValue("uriVariablesExpression");
assertNotNull(uriVariablesExpression);
assertEquals("@uriVariables", ((Expression) uriVariablesExpression).getExpressionString());
assertThat(uriVariablesExpression).isNotNull();
assertThat(((Expression) uriVariablesExpression).getExpressionString()).isEqualTo("@uriVariables");
Object uriVariableExpressions = handlerAccessor.getPropertyValue("uriVariableExpressions");
assertNotNull(uriVariableExpressions);
assertTrue(((Map<?, ?>) uriVariableExpressions).isEmpty());
assertThat(uriVariableExpressions).isNotNull();
assertThat(((Map<?, ?>) uriVariableExpressions).isEmpty()).isTrue();
}
@Test
@@ -201,7 +200,7 @@ public class HttpOutboundGatewayParserTests {
HttpRequestExecutingMessageHandler handler = (HttpRequestExecutingMessageHandler) new DirectFieldAccessor(
this.withAdvice).getPropertyValue("handler");
handler.handleMessage(new GenericMessage<String>("foo"));
assertEquals(1, adviceCalled);
assertThat(adviceCalled).isEqualTo(1);
}
@Test
@@ -212,14 +211,14 @@ public class HttpOutboundGatewayParserTests {
fail("Expected BeanDefinitionParsingException");
}
catch (BeansException e) {
assertTrue(e instanceof BeanDefinitionParsingException);
assertTrue(e.getMessage().contains("'request-channel' attribute isn't allowed for a nested"));
assertThat(e instanceof BeanDefinitionParsingException).isTrue();
assertThat(e.getMessage().contains("'request-channel' attribute isn't allowed for a nested")).isTrue();
}
}
@Test
public void withPoller() {
assertThat(this.withPoller1, Matchers.instanceOf(PollingConsumer.class));
assertThat(this.withPoller1).isInstanceOf(PollingConsumer.class);
}

23
spring-integration-http/src/test/java/org/springframework/integration/http/config/HttpOutboundGatewayWithMethodExpressionTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,8 +16,7 @@
package org.springframework.integration.http.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
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;
@@ -70,35 +69,35 @@ public class HttpOutboundGatewayWithMethodExpressionTests {
}
@Test
public void testDefaultMethod() throws Exception {
public void testDefaultMethod() {
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"));
this.defaultChannel.send(new GenericMessage<>("Hello"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertEquals("POST", message.getPayload());
assertThat(message).isNotNull();
assertThat(message.getPayload()).isEqualTo("POST");
this.mockServer.verify();
}
@Test
public void testExplicitlySetMethod() throws Exception {
public void testExplicitlySetMethod() {
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"));
this.requestChannel.send(new GenericMessage<>("GET"));
Message<?> message = replyChannel.receive(5000);
assertNotNull(message);
assertEquals("GET", message.getPayload());
assertThat(message).isNotNull();
assertThat(message.getPayload()).isEqualTo("GET");
this.mockServer.verify();
}
@Test(expected = BeanDefinitionParsingException.class)
public void testMutuallyExclusivityInMethodAndMethodExpression() throws Exception {
public void testMutuallyExclusivityInMethodAndMethodExpression() {
new ClassPathXmlApplicationContext(
"http-outbound-gateway-with-httpmethod-expression-fail.xml", getClass())
.close();

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2016 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,10 +16,8 @@
package org.springframework.integration.http.config;
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.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.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;
@@ -28,7 +26,6 @@ import static org.springframework.test.web.client.response.MockRestResponseCreat
import java.util.Collections;
import java.util.Map;
import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -111,8 +108,8 @@ public class OutboundResponseTypeTests {
this.requestChannel.send(new GenericMessage<String>("Hello"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof ResponseEntity);
assertThat(message).isNotNull();
assertThat(message.getPayload() instanceof ResponseEntity).isTrue();
this.mockServer.verify();
}
@@ -125,8 +122,8 @@ public class OutboundResponseTypeTests {
this.resTypeSetChannel.send(new GenericMessage<String>("Hello"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof String);
assertThat(message).isNotNull();
assertThat(message.getPayload() instanceof String).isTrue();
this.mockServer.verify();
}
@@ -139,8 +136,8 @@ public class OutboundResponseTypeTests {
this.resTypeExpressionSetChannel.send(new GenericMessage<String>("java.lang.String"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof String);
assertThat(message).isNotNull();
assertThat(message.getPayload() instanceof String).isTrue();
this.mockServer.verify();
}
@@ -154,8 +151,8 @@ public class OutboundResponseTypeTests {
this.resTypeExpressionSetSerializationChannel.send(new GenericMessage<Class<?>>(String.class));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof String);
assertThat(message).isNotNull();
assertThat(message.getPayload() instanceof String).isTrue();
this.mockServer.verify();
}
@@ -168,8 +165,8 @@ public class OutboundResponseTypeTests {
this.resTypeExpressionSetChannel.send(new GenericMessage<String>("byte[]"));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof byte[]);
assertThat(message).isNotNull();
assertThat(message.getPayload() instanceof byte[]).isTrue();
this.mockServer.verify();
}
@@ -182,8 +179,8 @@ public class OutboundResponseTypeTests {
this.resPrimitiveStringPresentationChannel.send(new GenericMessage<byte[]>("hello".getBytes()));
Message<?> message = this.replyChannel.receive(5000);
assertNotNull(message);
assertTrue(message.getPayload() instanceof byte[]);
assertThat(message).isNotNull();
assertThat(message.getPayload() instanceof byte[]).isTrue();
this.mockServer.verify();
}
@@ -195,11 +192,11 @@ public class OutboundResponseTypeTests {
fail("IllegalStateException expected.");
}
catch (Exception e) {
assertThat(e, Matchers.instanceOf(MessageHandlingException.class));
assertThat(e).isInstanceOf(MessageHandlingException.class);
Throwable t = e.getCause();
assertThat(t, Matchers.instanceOf(IllegalStateException.class));
assertThat(t.getMessage(), Matchers.containsString("'expectedResponseType' can be an instance of " +
"'Class<?>', 'String' or 'ParameterizedTypeReference<?>'"));
assertThat(t).isInstanceOf(IllegalStateException.class);
assertThat(t.getMessage()).contains("'expectedResponseType' can be an instance of " +
"'Class<?>', 'String' or 'ParameterizedTypeReference<?>'");
}
}
@@ -210,9 +207,9 @@ public class OutboundResponseTypeTests {
fail("Expected BeansException");
}
catch (BeansException e) {
assertTrue(e instanceof BeanDefinitionParsingException);
assertTrue(e.getMessage().contains("The 'expected-response-type' " +
"and 'expected-response-type-expression' are mutually exclusive"));
assertThat(e instanceof BeanDefinitionParsingException).isTrue();
assertThat(e.getMessage().contains("The 'expected-response-type' " +
"and 'expected-response-type-expression' are mutually exclusive")).isTrue();
}
}

99
spring-integration-http/src/test/java/org/springframework/integration/http/inbound/CrossOriginTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2016 the original author or authors.
* Copyright 2015-2019 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.
@@ -16,14 +16,7 @@
package org.springframework.integration.http.inbound;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Before;
import org.junit.Test;
@@ -67,7 +60,7 @@ public class CrossOriginTests {
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/no");
HandlerExecutionChain chain = this.handlerMapping.getHandler(request);
CorsConfiguration config = getCorsConfiguration(chain, false);
assertNull(config);
assertThat(config).isNull();
}
@Test
@@ -75,7 +68,7 @@ public class CrossOriginTests {
this.request.setRequestURI("/no");
HandlerExecutionChain chain = this.handlerMapping.getHandler(request);
CorsConfiguration config = getCorsConfiguration(chain, false);
assertNull(config);
assertThat(config).isNull();
}
@Test
@@ -84,7 +77,7 @@ public class CrossOriginTests {
this.request.setRequestURI("/no");
HandlerExecutionChain chain = this.handlerMapping.getHandler(this.request);
CorsConfiguration config = getCorsConfiguration(chain, false);
assertNull(config);
assertThat(config).isNull();
}
@Test
@@ -92,13 +85,13 @@ public class CrossOriginTests {
this.request.setRequestURI("/default");
HandlerExecutionChain chain = this.handlerMapping.getHandler(this.request);
CorsConfiguration config = getCorsConfiguration(chain, false);
assertNotNull(config);
assertArrayEquals(new String[] { "GET" }, config.getAllowedMethods().toArray());
assertArrayEquals(new String[] { "*" }, config.getAllowedOrigins().toArray());
assertTrue(config.getAllowCredentials());
assertArrayEquals(new String[] { "*" }, config.getAllowedHeaders().toArray());
assertNull(config.getExposedHeaders());
assertEquals(new Long(1800), config.getMaxAge());
assertThat(config).isNotNull();
assertThat(config.getAllowedMethods().toArray()).isEqualTo(new String[] { "GET" });
assertThat(config.getAllowedOrigins().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getAllowCredentials()).isTrue();
assertThat(config.getAllowedHeaders().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getExposedHeaders()).isNull();
assertThat(config.getMaxAge()).isEqualTo(new Long(1800));
}
@Test
@@ -106,13 +99,14 @@ public class CrossOriginTests {
this.request.setRequestURI("/customized");
HandlerExecutionChain chain = this.handlerMapping.getHandler(this.request);
CorsConfiguration config = getCorsConfiguration(chain, false);
assertNotNull(config);
assertArrayEquals(new String[] { "DELETE" }, config.getAllowedMethods().toArray());
assertArrayEquals(new String[] { "http://site1.com", "http://site2.com" }, config.getAllowedOrigins().toArray());
assertArrayEquals(new String[] { "header1", "header2" }, config.getAllowedHeaders().toArray());
assertArrayEquals(new String[] { "header3", "header4" }, config.getExposedHeaders().toArray());
assertEquals(new Long(123), config.getMaxAge());
assertEquals(false, config.getAllowCredentials());
assertThat(config).isNotNull();
assertThat(config.getAllowedMethods().toArray()).isEqualTo(new String[] { "DELETE" });
assertThat(config.getAllowedOrigins().toArray())
.isEqualTo(new String[] { "http://site1.com", "http://site2.com" });
assertThat(config.getAllowedHeaders().toArray()).isEqualTo(new String[] { "header1", "header2" });
assertThat(config.getExposedHeaders().toArray()).isEqualTo(new String[] { "header3", "header4" });
assertThat(config.getMaxAge()).isEqualTo(new Long(123));
assertThat(config.getAllowCredentials()).isEqualTo(false);
}
@Test
@@ -122,13 +116,13 @@ public class CrossOriginTests {
this.request.setRequestURI("/default");
HandlerExecutionChain chain = this.handlerMapping.getHandler(this.request);
CorsConfiguration config = getCorsConfiguration(chain, true);
assertNotNull(config);
assertArrayEquals(new String[] { "GET" }, config.getAllowedMethods().toArray());
assertArrayEquals(new String[] { "*" }, config.getAllowedOrigins().toArray());
assertTrue(config.getAllowCredentials());
assertArrayEquals(new String[] { "*" }, config.getAllowedHeaders().toArray());
assertNull(config.getExposedHeaders());
assertEquals(new Long(1800), config.getMaxAge());
assertThat(config).isNotNull();
assertThat(config.getAllowedMethods().toArray()).isEqualTo(new String[] { "GET" });
assertThat(config.getAllowedOrigins().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getAllowCredentials()).isTrue();
assertThat(config.getAllowedHeaders().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getExposedHeaders()).isNull();
assertThat(config.getMaxAge()).isEqualTo(new Long(1800));
}
@Test
@@ -139,13 +133,13 @@ public class CrossOriginTests {
this.request.setRequestURI("/ambiguous-header");
HandlerExecutionChain chain = this.handlerMapping.getHandler(this.request);
CorsConfiguration config = getCorsConfiguration(chain, true);
assertNotNull(config);
assertArrayEquals(new String[] { "*" }, config.getAllowedMethods().toArray());
assertArrayEquals(new String[] { "*" }, config.getAllowedOrigins().toArray());
assertArrayEquals(new String[] { "*" }, config.getAllowedHeaders().toArray());
assertTrue(config.getAllowCredentials());
assertNull(config.getExposedHeaders());
assertNull(config.getMaxAge());
assertThat(config).isNotNull();
assertThat(config.getAllowedMethods().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getAllowedOrigins().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getAllowedHeaders().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getAllowCredentials()).isTrue();
assertThat(config.getExposedHeaders()).isNull();
assertThat(config.getMaxAge()).isNull();
}
@Test
@@ -155,13 +149,13 @@ public class CrossOriginTests {
this.request.setRequestURI("/ambiguous-produces");
HandlerExecutionChain chain = this.handlerMapping.getHandler(this.request);
CorsConfiguration config = getCorsConfiguration(chain, true);
assertNotNull(config);
assertArrayEquals(new String[] { "*" }, config.getAllowedMethods().toArray());
assertArrayEquals(new String[] { "*" }, config.getAllowedOrigins().toArray());
assertArrayEquals(new String[] { "*" }, config.getAllowedHeaders().toArray());
assertTrue(config.getAllowCredentials());
assertNull(config.getExposedHeaders());
assertNull(config.getMaxAge());
assertThat(config).isNotNull();
assertThat(config.getAllowedMethods().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getAllowedOrigins().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getAllowedHeaders().toArray()).isEqualTo(new String[] { "*" });
assertThat(config.getAllowCredentials()).isTrue();
assertThat(config.getExposedHeaders()).isNull();
assertThat(config.getMaxAge()).isNull();
}
@Test
@@ -169,18 +163,17 @@ public class CrossOriginTests {
MockHttpServletRequest request = new MockHttpServletRequest("OPTIONS", "/default");
request.addHeader(HttpHeaders.ORIGIN, "http://domain2.com");
HandlerExecutionChain handler = this.handlerMapping.getHandler(request);
assertNotNull(handler);
assertThat(handler).isNotNull();
Object handlerMethod = handler.getHandler();
assertNotNull(handlerMethod);
assertThat(handlerMethod, instanceOf(HandlerMethod.class));
assertThat(((HandlerMethod) handlerMethod).getBeanType().getName(),
containsString("HttpOptionsHandler"));
assertThat(handlerMethod).isNotNull();
assertThat(handlerMethod).isInstanceOf(HandlerMethod.class);
assertThat(((HandlerMethod) handlerMethod).getBeanType().getName()).contains("HttpOptionsHandler");
}
private CorsConfiguration getCorsConfiguration(HandlerExecutionChain chain, boolean isPreFlightRequest) {
if (isPreFlightRequest) {
Object handler = chain.getHandler();
assertTrue(handler.getClass().getSimpleName().equals("PreFlightHandler"));
assertThat(handler.getClass().getSimpleName().equals("PreFlightHandler")).isTrue();
return TestUtils.getPropertyValue(handler, "config", CorsConfiguration.class);
}
else {

87
spring-integration-http/src/test/java/org/springframework/integration/http/inbound/HttpRequestHandlingControllerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2016 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,11 +16,7 @@
package org.springframework.integration.http.inbound;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import java.util.concurrent.CountDownLatch;
@@ -79,11 +75,11 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView modelAndView = controller.handleRequest(request, response);
assertEquals("foo", modelAndView.getViewName());
assertEquals(0, modelAndView.getModel().size());
assertThat(modelAndView.getViewName()).isEqualTo("foo");
assertThat(modelAndView.getModel().size()).isEqualTo(0);
Message<?> requestMessage = requestChannel.receive(0);
assertNotNull(requestMessage);
assertEquals("hello", requestMessage.getPayload());
assertThat(requestMessage).isNotNull();
assertThat(requestMessage.getPayload()).isEqualTo("hello");
}
@Test
@@ -107,11 +103,11 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView modelAndView = controller.handleRequest(request, response);
assertEquals("baz", modelAndView.getViewName());
assertEquals(0, modelAndView.getModel().size());
assertThat(modelAndView.getViewName()).isEqualTo("baz");
assertThat(modelAndView.getModel().size()).isEqualTo(0);
Message<?> requestMessage = requestChannel.receive(0);
assertNotNull(requestMessage);
assertEquals("hello", requestMessage.getPayload());
assertThat(requestMessage).isNotNull();
assertThat(requestMessage.getPayload()).isEqualTo("hello");
}
@Test
@@ -141,11 +137,11 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView modelAndView = controller.handleRequest(request, response);
assertEquals("foo", modelAndView.getViewName());
assertEquals(1, modelAndView.getModel().size());
assertThat(modelAndView.getViewName()).isEqualTo("foo");
assertThat(modelAndView.getModel().size()).isEqualTo(1);
Object reply = modelAndView.getModel().get("reply");
assertNotNull(reply);
assertEquals("HELLO", reply);
assertThat(reply).isNotNull();
assertThat(reply).isEqualTo("HELLO");
}
@Test
@@ -173,11 +169,11 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
request.setContentType("text/plain");
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView modelAndView = controller.handleRequest(request, response);
assertEquals("baz", modelAndView.getViewName());
assertEquals(1, modelAndView.getModel().size());
assertThat(modelAndView.getViewName()).isEqualTo("baz");
assertThat(modelAndView.getModel().size()).isEqualTo(1);
Object reply = modelAndView.getModel().get("reply");
assertNotNull(reply);
assertEquals("foo", reply);
assertThat(reply).isNotNull();
assertThat(reply).isEqualTo("foo");
}
@Test
@@ -206,11 +202,11 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
request.setContentType("text/plain");
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView modelAndView = controller.handleRequest(request, response);
assertSame(view, modelAndView.getView());
assertEquals(1, modelAndView.getModel().size());
assertThat(modelAndView.getView()).isSameAs(view);
assertThat(modelAndView.getModel().size()).isEqualTo(1);
Object reply = modelAndView.getModel().get("reply");
assertNotNull(reply);
assertEquals("foo", reply);
assertThat(reply).isNotNull();
assertThat(reply).isEqualTo("foo");
}
@Test
@@ -241,11 +237,11 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView modelAndView = controller.handleRequest(request, response);
assertEquals("foo", modelAndView.getViewName());
assertEquals(1, modelAndView.getModel().size());
assertNull(modelAndView.getModel().get("reply"));
assertThat(modelAndView.getViewName()).isEqualTo("foo");
assertThat(modelAndView.getModel().size()).isEqualTo(1);
assertThat(modelAndView.getModel().get("reply")).isNull();
Object reply = modelAndView.getModel().get("myReply");
assertEquals("HOWDY", reply);
assertThat(reply).isEqualTo("HOWDY");
}
@Test
@@ -276,12 +272,12 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView modelAndView = controller.handleRequest(request, response);
assertEquals("foo", modelAndView.getViewName());
assertEquals(1, modelAndView.getModel().size());
assertThat(modelAndView.getViewName()).isEqualTo("foo");
assertThat(modelAndView.getModel().size()).isEqualTo(1);
Object reply = modelAndView.getModel().get("reply");
assertNotNull(reply);
assertTrue(reply instanceof Message<?>);
assertEquals("ABC", ((Message<?>) reply).getPayload());
assertThat(reply).isNotNull();
assertThat(reply instanceof Message<?>).isTrue();
assertThat(((Message<?>) reply).getPayload()).isEqualTo("ABC");
}
@Test
@@ -304,12 +300,13 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
request.setContentType("text/plain");
MockHttpServletResponse response = new MockHttpServletResponse();
ModelAndView modelAndView = controller.handleRequest(request, response);
assertEquals(1, modelAndView.getModel().size());
assertThat(modelAndView.getModel().size()).isEqualTo(1);
Errors errors = (Errors) modelAndView.getModel().get("errors");
assertEquals(1, errors.getErrorCount());
assertThat(errors.getErrorCount()).isEqualTo(1);
ObjectError error = errors.getAllErrors().get(0);
assertEquals(3, error.getArguments().length);
assertTrue("Wrong message: " + error, ((String) error.getArguments()[1]).startsWith("failed to send Message"));
assertThat(error.getArguments().length).isEqualTo(3);
assertThat(((String) error.getArguments()[1]).startsWith("failed to send Message"))
.as("Wrong message: " + error).isTrue();
}
@Test
@@ -372,14 +369,14 @@ public class HttpRequestHandlingControllerTests extends AbstractHttpInboundTests
});
ModelAndView modelAndView = controller.handleRequest(request, response);
// verify we get a 503 after shutdown starts
assertEquals(1, active.get());
assertTrue(expected503.get());
assertThat(active.get()).isEqualTo(1);
assertThat(expected503.get()).isTrue();
// verify the active request still processed ok
assertEquals("foo", modelAndView.getViewName());
assertEquals(1, modelAndView.getModel().size());
assertThat(modelAndView.getViewName()).isEqualTo("foo");
assertThat(modelAndView.getModel().size()).isEqualTo(1);
Object reply = modelAndView.getModel().get("reply");
assertNotNull(reply);
assertEquals("HELLO", reply);
assertThat(reply).isNotNull();
assertThat(reply).isEqualTo("HELLO");
}

84
spring-integration-http/src/test/java/org/springframework/integration/http/inbound/HttpRequestHandlingMessagingGatewayTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,10 +16,7 @@
package org.springframework.integration.http.inbound;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -34,7 +31,6 @@ import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
@@ -91,11 +87,11 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
Message<?> message = requestChannel.receive(0);
assertNotNull(message);
assertEquals(LinkedMultiValueMap.class, message.getPayload().getClass());
assertThat(message).isNotNull();
assertThat(message.getPayload().getClass()).isEqualTo(LinkedMultiValueMap.class);
LinkedMultiValueMap<String, String> map = (LinkedMultiValueMap<String, String>) message.getPayload();
assertEquals(1, map.get("foo").size());
assertEquals("bar", map.getFirst("foo"));
assertThat(map.get("foo").size()).isEqualTo(1);
assertThat(map.getFirst("foo")).isEqualTo("bar");
}
@Test
@@ -115,9 +111,9 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
Message<?> message = requestChannel.receive(0);
assertNotNull(message);
assertEquals(String.class, message.getPayload().getClass());
assertEquals("hello", message.getPayload());
assertThat(message).isNotNull();
assertThat(message.getPayload().getClass()).isEqualTo(String.class);
assertThat(message.getPayload()).isEqualTo("hello");
}
@Test
@@ -156,7 +152,7 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
request.setContent("hello".getBytes());
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
assertEquals("HELLO", response.getContentAsString());
assertThat(response.getContentAsString()).isEqualTo("HELLO");
}
@Test // INT-1767
@@ -182,9 +178,9 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
request.setContent("hello".getBytes());
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
assertEquals("HELLO", response.getContentAsString());
assertThat(response.getContentAsString()).isEqualTo("HELLO");
//INT-3120
assertNull(response.getHeader("Accept-Charset"));
assertThat(response.getHeader("Accept-Charset")).isNull();
}
@Test
@@ -210,7 +206,7 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
String content = response.getContentAsString();
assertEquals("Planned", content);
assertThat(content).isEqualTo("Planned");
}
@Test
@@ -229,18 +225,18 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
Message<?> message = channel.receive(0);
assertNotNull(message);
assertNotNull(message.getPayload());
assertEquals(LinkedMultiValueMap.class, message.getPayload().getClass());
assertThat(message).isNotNull();
assertThat(message.getPayload()).isNotNull();
assertThat(message.getPayload().getClass()).isEqualTo(LinkedMultiValueMap.class);
@SuppressWarnings("unchecked")
LinkedMultiValueMap<String, String> map = (LinkedMultiValueMap<String, String>) message.getPayload();
List<String> fooValues = map.get("foo");
List<String> barValues = map.get("bar");
assertEquals(1, fooValues.size());
assertEquals("123", fooValues.get(0));
assertEquals(2, barValues.size());
assertEquals("456", barValues.get(0));
assertEquals("789", barValues.get(1));
assertThat(fooValues.size()).isEqualTo(1);
assertThat(fooValues.get(0)).isEqualTo("123");
assertThat(barValues.size()).isEqualTo(2);
assertThat(barValues.get(0)).isEqualTo("456");
assertThat(barValues.get(1)).isEqualTo("789");
}
@Test
@@ -267,14 +263,14 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
byte[] bytes = response.getContentAsByteArray();
assertNotNull(bytes);
assertThat(bytes).isNotNull();
Message<?> message = channel.receive(0);
assertNotNull(message);
assertNotNull(message.getPayload());
assertEquals(TestBean.class, message.getPayload().getClass());
assertThat(message).isNotNull();
assertThat(message.getPayload()).isNotNull();
assertThat(message.getPayload().getClass()).isEqualTo(TestBean.class);
TestBean result = (TestBean) message.getPayload();
assertEquals("T. Bean", result.name);
assertEquals(84, result.age);
assertThat(result.name).isEqualTo("T. Bean");
assertThat(result.age).isEqualTo(84);
}
@Test
@@ -314,14 +310,14 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
final ContentTypeCheckingMockHttpServletResponse response = new ContentTypeCheckingMockHttpServletResponse();
gateway.handleRequest(request, response);
assertEquals("Cartman", response.getContentAsString());
assertThat(response.getContentAsString()).isEqualTo("Cartman");
/* Before fixing INT2680, 2 content type headers were being written. */
final List<String> contentTypes = response.getContentTypeList();
assertEquals("Expecting only 1 content type being set.",
Integer.valueOf(1), Integer.valueOf(contentTypes.size()));
assertEquals("text/plain", contentTypes.get(0));
assertThat(Integer.valueOf(contentTypes.size())).as("Expecting only 1 content type being set.")
.isEqualTo(Integer.valueOf(1));
assertThat(contentTypes.get(0)).isEqualTo("text/plain");
}
@Test
@@ -338,8 +334,8 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
Message<?> message = requestChannel.receive(0);
assertNotNull(message);
assertEquals(500, response.getStatus());
assertThat(message).isNotNull();
assertThat(response.getStatus()).isEqualTo(500);
}
@Test
@@ -358,8 +354,8 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
Message<?> message = requestChannel.receive(0);
assertNotNull(message);
assertEquals(501, response.getStatus());
assertThat(message).isNotNull();
assertThat(response.getStatus()).isEqualTo(501);
}
@Test
@@ -388,8 +384,8 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
Message<?> message = requestChannel.receive(0);
assertNotNull(message);
assertEquals(504, response.getStatus());
assertThat(message).isNotNull();
assertThat(response.getStatus()).isEqualTo(504);
}
@Test
@@ -410,9 +406,9 @@ public class HttpRequestHandlingMessagingGatewayTests extends AbstractHttpInboun
MockHttpServletResponse response = new MockHttpServletResponse();
gateway.handleRequest(request, response);
Message<?> message = requestChannel.receive(0);
assertNotNull(message);
assertEquals(501, response.getStatus());
assertThat(response.getContentAsString(), Matchers.containsString("from error channel"));
assertThat(message).isNotNull();
assertThat(response.getStatus()).isEqualTo(501);
assertThat(response.getContentAsString()).contains("from error channel");
}

18
spring-integration-http/src/test/java/org/springframework/integration/http/inbound/HttpRequestHandlingMessagingGatewayWithPathMappingTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,9 +16,7 @@
package org.springframework.integration.http.inbound;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import java.io.IOException;
@@ -85,8 +83,8 @@ public class HttpRequestHandlingMessagingGatewayWithPathMappingTests extends Abs
RequestEntity<Object> httpEntity = prepareRequestEntity(body, new ServletServerHttpRequest(request));
Object result = gateway.doHandleRequest(request, httpEntity, response);
assertThat(result, instanceOf(Message.class));
assertEquals("hello", ((Message<?>) result).getPayload());
assertThat(result).isInstanceOf(Message.class);
assertThat(((Message<?>) result).getPayload()).isEqualTo("hello");
}
@@ -130,8 +128,8 @@ public class HttpRequestHandlingMessagingGatewayWithPathMappingTests extends Abs
RequestEntity<Object> httpEntity = prepareRequestEntity(body, new ServletServerHttpRequest(request));
Object result = gateway.doHandleRequest(request, httpEntity, response);
assertThat(result, instanceOf(Message.class));
assertEquals("bill", ((Message<?>) result).getPayload());
assertThat(result).isInstanceOf(Message.class);
assertThat(((Message<?>) result).getPayload()).isEqualTo("bill");
}
@SuppressWarnings("unchecked")
@@ -176,8 +174,8 @@ public class HttpRequestHandlingMessagingGatewayWithPathMappingTests extends Abs
RequestEntity<Object> httpEntity = prepareRequestEntity(body, new ServletServerHttpRequest(request));
Object result = gateway.doHandleRequest(request, httpEntity, response);
assertThat(result, instanceOf(Message.class));
assertEquals("bill", ((Map<String, Object>) ((Message<?>) result).getPayload()).get("f"));
assertThat(result).isInstanceOf(Message.class);
assertThat(((Map<String, Object>) ((Message<?>) result).getPayload()).get("f")).isEqualTo("bill");
}
private static RequestEntity<Object> prepareRequestEntity(Object body, ServletServerHttpRequest request) throws IOException {

61
spring-integration-http/src/test/java/org/springframework/integration/http/inbound/Int2312RequestMappingIntegrationTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2013-2016 the original author or authors.
* Copyright 2013-2019 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.
@@ -16,11 +16,7 @@
package org.springframework.integration.http.inbound;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Collections;
import java.util.HashMap;
@@ -28,7 +24,6 @@ import java.util.Map;
import javax.servlet.http.Cookie;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -83,7 +78,7 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
MockHttpServletResponse response = new MockHttpServletResponse();
Object handler = this.handlerMapping.getHandler(request).getHandler();
this.handlerAdapter.handle(request, response, handler);
assertEquals(TEST_STRING_MULTIPLE_PATHS, response.getContentAsString());
assertThat(response.getContentAsString()).isEqualTo(TEST_STRING_MULTIPLE_PATHS);
request = new MockHttpServletRequest();
request.setMethod("GET");
@@ -91,7 +86,7 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
response = new MockHttpServletResponse();
handler = this.handlerMapping.getHandler(request).getHandler();
this.handlerAdapter.handle(request, response, handler);
assertEquals(TEST_STRING_MULTIPLE_PATHS, response.getContentAsString());
assertThat(response.getContentAsString()).isEqualTo(TEST_STRING_MULTIPLE_PATHS);
}
@@ -120,28 +115,28 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
this.toLowerCaseChannel.subscribe(message -> {
MessageHeaders headers = message.getHeaders();
assertEquals(attributes, headers.get("requestAttributes"));
assertThat(headers.get("requestAttributes")).isEqualTo(attributes);
Object requestParams = headers.get("requestParams");
assertNotNull(requestParams);
assertEquals(params, ((MultiValueMap<String, String>) requestParams).toSingleValueMap());
assertThat(requestParams).isNotNull();
assertThat(((MultiValueMap<String, String>) requestParams).toSingleValueMap()).isEqualTo(params);
Object matrixVariables = headers.get("matrixVariables");
assertThat(matrixVariables, Matchers.instanceOf(Map.class));
assertThat(matrixVariables).isInstanceOf(Map.class);
Object value = ((Map<?, ?>) matrixVariables).get("value");
assertThat(value, Matchers.instanceOf(MultiValueMap.class));
assertEquals("1", ((MultiValueMap<String, ?>) value).getFirst("q1"));
assertEquals("2", ((MultiValueMap<String, ?>) value).getFirst("q2"));
assertThat(value).isInstanceOf(MultiValueMap.class);
assertThat(((MultiValueMap<String, ?>) value).getFirst("q1")).isEqualTo("1");
assertThat(((MultiValueMap<String, ?>) value).getFirst("q2")).isEqualTo("2");
Object requestHeaders = headers.get("requestHeaders");
assertNotNull(requestParams);
assertEquals(MediaType.TEXT_PLAIN, ((HttpHeaders) requestHeaders).getContentType());
assertThat(requestParams).isNotNull();
assertThat(((HttpHeaders) requestHeaders).getContentType()).isEqualTo(MediaType.TEXT_PLAIN);
Map<String, Cookie> cookies = (Map<String, Cookie>) headers.get("cookies");
assertEquals(1, cookies.size());
assertThat(cookies.size()).isEqualTo(1);
Cookie foo = cookies.get("foo");
assertNotNull(foo);
assertEquals(cookie, foo);
assertThat(foo).isNotNull();
assertThat(foo).isEqualTo(cookie);
});
MockHttpServletResponse response = new MockHttpServletResponse();
@@ -149,7 +144,7 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
Object handler = this.handlerMapping.getHandler(request).getHandler();
this.handlerAdapter.handle(request, response, handler);
final String testResponse = response.getContentAsString();
assertEquals(testRequest.split(";")[0].toLowerCase(), testResponse);
assertThat(testResponse).isEqualTo(testRequest.split(";")[0].toLowerCase());
RequestContextHolder.resetRequestAttributes();
}
@@ -164,7 +159,7 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
catch (Exception e) {
// There is no matching handlers and some default handler
//See org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping#handleNoMatch
assertTrue(e instanceof UnsatisfiedServletRequestParameterException);
assertThat(e instanceof UnsatisfiedServletRequestParameterException).isTrue();
}
request = new MockHttpServletRequest("GET", "/params");
@@ -177,7 +172,7 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
this.handlerAdapter.handle(request, response, handler);
String testResponse = response.getContentAsString();
assertEquals("User=1;account=1", testResponse);
assertThat(testResponse).isEqualTo("User=1;account=1");
request = new MockHttpServletRequest("GET", "/params");
request.addParameter("param1", "1");
@@ -187,7 +182,7 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
this.handlerAdapter.handle(request, response, handler);
testResponse = response.getContentAsString();
assertEquals("User=1", testResponse);
assertThat(testResponse).isEqualTo("User=1");
}
@Test
@@ -199,7 +194,7 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
this.handlerAdapter.handle(request, response, handler);
String testResponse = response.getContentAsString();
assertEquals("BAR", testResponse);
assertThat(testResponse).isEqualTo("BAR");
request = new MockHttpServletRequest("GET", "/consumes");
request.setContentType("text/xml");
@@ -208,7 +203,7 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
this.handlerAdapter.handle(request, response, handler);
testResponse = response.getContentAsString();
assertEquals("<test>TEXT_XML</test>", testResponse);
assertThat(testResponse).isEqualTo("<test>TEXT_XML</test>");
}
@Test
@@ -218,28 +213,28 @@ public class Int2312RequestMappingIntegrationTests extends AbstractHttpInboundTe
Object handler = this.handlerMapping.getHandler(request).getHandler();
//See org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping#handleMatch
assertEquals(Collections.singleton(MediaType.APPLICATION_XML),
request.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE));
assertThat(request.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE))
.isEqualTo(Collections.singleton(MediaType.APPLICATION_XML));
MockHttpServletResponse response = new MockHttpServletResponse();
this.handlerAdapter.handle(request, response, handler);
String testResponse = response.getContentAsString();
assertEquals("<test>XML</test>", testResponse);
assertThat(testResponse).isEqualTo("<test>XML</test>");
request = new MockHttpServletRequest("GET", "/produces");
request.addHeader("Accept", "application/json");
handler = this.handlerMapping.getHandler(request).getHandler();
//See org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping#handleMatch
assertNull("Negated expression should not be listed as a producible type",
request.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE));
assertThat(request.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE))
.as("Negated expression should not be listed as a producible type").isNull();
response = new MockHttpServletResponse();
this.handlerAdapter.handle(request, response, handler);
testResponse = response.getContentAsString();
assertEquals("{\"json\":\"body\"}", testResponse);
assertThat(testResponse).isEqualTo("{\"json\":\"body\"}");
}
}

13
spring-integration-http/src/test/java/org/springframework/integration/http/inbound/MultipartAsRawByteArrayTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2017 the original author or authors.
* Copyright 2015-2019 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.
@@ -16,10 +16,7 @@
package org.springframework.integration.http.inbound;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
@@ -90,9 +87,9 @@ public class MultipartAsRawByteArrayTests {
RequestContextHolder.setRequestAttributes(mock(RequestAttributes.class));
gw.handleRequest(request, mock(HttpServletResponse.class));
Message<?> received = requestChannel.receive(10000);
assertNotNull(received);
assertThat(received.getPayload(), instanceOf(byte[].class));
assertEquals("foo", new String((byte[]) received.getPayload()));
assertThat(received).isNotNull();
assertThat(received.getPayload()).isInstanceOf(byte[].class);
assertThat(new String((byte[]) received.getPayload())).isEqualTo("foo");
}
}

29
spring-integration-http/src/test/java/org/springframework/integration/http/management/IntegrationGraphControllerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016 the original author or authors.
* Copyright 2016-2019 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.
@@ -16,12 +16,7 @@
package org.springframework.integration.http.management;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.not;
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.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.handler;
@@ -94,7 +89,7 @@ public class IntegrationGraphControllerTests {
.andExpect(jsonPath("$.nodes..name")
.value(Matchers.containsInAnyOrder("nullChannel", "errorChannel",
"_org.springframework.integration.errorLogger")))
// .andDo(print())
// .andDo(print())
.andExpect(jsonPath("$.contentDescriptor.name").value("testApplication"))
.andExpect(jsonPath("$.links").exists());
}
@@ -117,19 +112,19 @@ public class IntegrationGraphControllerTests {
MockHttpServletResponse response = new MockHttpServletResponse();
HandlerExecutionChain executionChain = handlerMapping.getHandler(request);
assertNotNull(executionChain);
assertThat(executionChain).isNotNull();
Object handler = executionChain.getHandler();
for (HandlerInterceptor handlerInterceptor : executionChain.getInterceptors()) {
// Assert the CORS config
assertTrue(handlerInterceptor.preHandle(request, response, handler));
assertThat(handlerInterceptor.preHandle(request, response, handler)).isTrue();
}
handlerAdapter.handle(request, response, handler);
assertEquals(HttpStatus.OK.value(), response.getStatus());
assertThat(response.getContentAsString(), containsString("\"name\":\"nullChannel\","));
assertThat(response.getContentAsString(), not(containsString("\"name\":\"myChannel\",")));
assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
assertThat(response.getContentAsString()).contains("\"name\":\"nullChannel\",");
assertThat(response.getContentAsString()).doesNotContain("\"name\":\"myChannel\",");
context.getBeanFactory().registerSingleton("myChannel", new DirectChannel());
@@ -139,18 +134,18 @@ public class IntegrationGraphControllerTests {
response = new MockHttpServletResponse();
executionChain = handlerMapping.getHandler(request);
assertNotNull(executionChain);
assertThat(executionChain).isNotNull();
handler = executionChain.getHandler();
for (HandlerInterceptor handlerInterceptor : executionChain.getInterceptors()) {
// Assert the CORS config
assertTrue(handlerInterceptor.preHandle(request, response, handler));
assertThat(handlerInterceptor.preHandle(request, response, handler)).isTrue();
}
handlerAdapter.handle(request, response, handler);
assertEquals(HttpStatus.OK.value(), response.getStatus());
assertThat(response.getContentAsString(), containsString("\"name\":\"myChannel\","));
assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
assertThat(response.getContentAsString()).contains("\"name\":\"myChannel\",");
context.close();
}

28
spring-integration-http/src/test/java/org/springframework/integration/http/outbound/CookieTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,10 +16,7 @@
package org.springframework.integration.http.outbound;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
@@ -32,7 +29,6 @@ import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -71,26 +67,26 @@ public class CookieTests {
private static ByteArrayOutputStream bos = new ByteArrayOutputStream();
private static List<HttpHeaders> allHeaders = new ArrayList<HttpHeaders>();
private static List<HttpHeaders> allHeaders = new ArrayList<>();
@Test
public void testCookie() throws Exception {
ch1.send(new GenericMessage<>("Hello, world!"));
Assert.assertNotNull(ch6.receive());
assertThat(ch6.receive()).isNotNull();
bos.close();
BufferedReader br = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(bos.toByteArray())));
String line = br.readLine();
assertEquals("Hello, world!Hello, again!Hello, once more!", line);
assertNull(br.readLine());
assertThat(line).isEqualTo("Hello, world!Hello, again!Hello, once more!");
assertThat(br.readLine()).isNull();
br.close();
assertEquals(3, allHeaders.size());
assertFalse(allHeaders.get(0).containsKey("Cookie"));
assertTrue(allHeaders.get(1).containsKey("Cookie"));
assertEquals("JSESSIONID=X123", allHeaders.get(1).get("Cookie").get(0));
assertTrue(allHeaders.get(2).containsKey("Cookie"));
assertEquals("JSESSIONID=X124", allHeaders.get(2).get("Cookie").get(0));
assertThat(allHeaders.size()).isEqualTo(3);
assertThat(allHeaders.get(0).containsKey("Cookie")).isFalse();
assertThat(allHeaders.get(1).containsKey("Cookie")).isTrue();
assertThat(allHeaders.get(1).get("Cookie").get(0)).isEqualTo("JSESSIONID=X123");
assertThat(allHeaders.get(2).containsKey("Cookie")).isTrue();
assertThat(allHeaders.get(2).get("Cookie").get(0)).isEqualTo("JSESSIONID=X124");
}
public static class RequestFactory implements ClientHttpRequestFactory {

278
spring-integration-http/src/test/java/org/springframework/integration/http/outbound/HttpRequestExecutingMessageHandlerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,13 +16,8 @@
package org.springframework.integration.http.outbound;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -110,16 +105,16 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertNotNull(request.getHeaders().getContentType());
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(request.getHeaders().getContentType()).isNotNull();
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
assertEquals("1", map.get("a").iterator().next());
assertEquals("2", map.get("b").iterator().next());
assertEquals("3", map.get("c").iterator().next());
assertEquals(MediaType.APPLICATION_FORM_URLENCODED, request.getHeaders().getContentType());
assertThat(map.get("a").iterator().next()).isEqualTo("1");
assertThat(map.get("b").iterator().next()).isEqualTo("2");
assertThat(map.get("c").iterator().next()).isEqualTo("3");
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_FORM_URLENCODED);
}
@Test
@@ -145,15 +140,15 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
assertEquals("Philadelphia", map.get("a").get(0).toString());
assertEquals("Ambler", map.get("b").get(0).toString());
assertEquals("Mohnton", map.get("c").get(0).toString());
assertEquals(MediaType.MULTIPART_FORM_DATA, request.getHeaders().getContentType());
assertThat(map.get("a").get(0).toString()).isEqualTo("Philadelphia");
assertThat(map.get("b").get(0).toString()).isEqualTo("Ambler");
assertThat(map.get("c").get(0).toString()).isEqualTo("Mohnton");
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.MULTIPART_FORM_DATA);
}
@Test
@@ -179,16 +174,16 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof Map<?, ?>);
assertThat(body instanceof Map<?, ?>).isTrue();
Map<?, ?> map = (Map<?, ?>) body;
assertEquals("Philadelphia", map.get(1).toString());
assertEquals("Ambler", map.get(2).toString());
assertEquals("Mohnton", map.get(3).toString());
assertEquals("application", request.getHeaders().getContentType().getType());
assertEquals("x-java-serialized-object", request.getHeaders().getContentType().getSubtype());
assertThat(map.get(1).toString()).isEqualTo("Philadelphia");
assertThat(map.get(2).toString()).isEqualTo("Ambler");
assertThat(map.get(3).toString()).isEqualTo("Mohnton");
assertThat(request.getHeaders().getContentType().getType()).isEqualTo("application");
assertThat(request.getHeaders().getContentType().getSubtype()).isEqualTo("x-java-serialized-object");
}
@Test
@@ -213,30 +208,30 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
List<?> aValue = map.get("a");
assertEquals(3, aValue.size());
assertEquals("1", aValue.get(0));
assertEquals("2", aValue.get(1));
assertEquals("3", aValue.get(2));
assertThat(aValue.size()).isEqualTo(3);
assertThat(aValue.get(0)).isEqualTo("1");
assertThat(aValue.get(1)).isEqualTo("2");
assertThat(aValue.get(2)).isEqualTo("3");
List<?> bValue = map.get("b");
assertEquals(1, bValue.size());
assertEquals("4", bValue.get(0));
assertThat(bValue.size()).isEqualTo(1);
assertThat(bValue.get(0)).isEqualTo("4");
List<?> cValue = map.get("c");
assertEquals(1, cValue.size());
assertEquals("5", cValue.get(0));
assertThat(cValue.size()).isEqualTo(1);
assertThat(cValue.get(0)).isEqualTo("5");
List<?> dValue = map.get("d");
assertEquals(1, dValue.size());
assertEquals("6", dValue.get(0));
assertEquals(MediaType.APPLICATION_FORM_URLENCODED, request.getHeaders().getContentType());
assertThat(dValue.size()).isEqualTo(1);
assertThat(dValue.get(0)).isEqualTo("6");
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_FORM_URLENCODED);
}
@Test
@@ -261,33 +256,33 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
List<?> aValue = map.get("a");
assertEquals(1, aValue.size());
assertThat(aValue.size()).isEqualTo(1);
Object value = aValue.get(0);
assertTrue(value.getClass().isArray());
assertThat(value.getClass().isArray()).isTrue();
int[] y = (int[]) value;
assertEquals(1, y[0]);
assertEquals(2, y[1]);
assertEquals(3, y[2]);
assertThat(y[0]).isEqualTo(1);
assertThat(y[1]).isEqualTo(2);
assertThat(y[2]).isEqualTo(3);
List<?> bValue = map.get("b");
assertEquals(1, bValue.size());
assertEquals("4", bValue.get(0));
assertThat(bValue.size()).isEqualTo(1);
assertThat(bValue.get(0)).isEqualTo("4");
List<?> cValue = map.get("c");
assertEquals(1, cValue.size());
assertEquals("5", cValue.get(0));
assertThat(cValue.size()).isEqualTo(1);
assertThat(cValue.get(0)).isEqualTo("5");
List<?> dValue = map.get("d");
assertEquals(1, dValue.size());
assertEquals("6", dValue.get(0));
assertEquals(MediaType.MULTIPART_FORM_DATA, request.getHeaders().getContentType());
assertThat(dValue.size()).isEqualTo(1);
assertThat(dValue.get(0)).isEqualTo("6");
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.MULTIPART_FORM_DATA);
}
@Test
@@ -310,23 +305,23 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
List<?> aValue = map.get("a");
assertEquals(3, aValue.size());
assertNull(aValue.get(0));
assertEquals(4, aValue.get(1));
assertNull(aValue.get(2));
assertThat(aValue.size()).isEqualTo(3);
assertThat(aValue.get(0)).isNull();
assertThat(aValue.get(1)).isEqualTo(4);
assertThat(aValue.get(2)).isNull();
List<?> bValue = map.get("b");
assertEquals(1, bValue.size());
assertEquals("4", bValue.get(0));
assertThat(bValue.size()).isEqualTo(1);
assertThat(bValue.get(0)).isEqualTo("4");
assertEquals(MediaType.MULTIPART_FORM_DATA, request.getHeaders().getContentType());
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.MULTIPART_FORM_DATA);
}
/**
@@ -358,23 +353,23 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
List<?> aValue = map.get("a");
assertEquals(3, aValue.size());
assertNull(aValue.get(0));
assertEquals("5", aValue.get(1));
assertNull(aValue.get(2));
assertThat(aValue.size()).isEqualTo(3);
assertThat(aValue.get(0)).isNull();
assertThat(aValue.get(1)).isEqualTo("5");
assertThat(aValue.get(2)).isNull();
List<?> bValue = map.get("b");
assertEquals(1, bValue.size());
assertEquals("4", bValue.get(0));
assertThat(bValue.size()).isEqualTo(1);
assertThat(bValue.get(0)).isEqualTo("4");
assertEquals(MediaType.APPLICATION_FORM_URLENCODED, request.getHeaders().getContentType());
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_FORM_URLENCODED);
}
/**
@@ -405,23 +400,23 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
List<?> aValue = map.get("a");
assertEquals(3, aValue.size());
assertNull(aValue.get(0));
assertEquals(5, aValue.get(1));
assertNull(aValue.get(2));
assertThat(aValue.size()).isEqualTo(3);
assertThat(aValue.get(0)).isNull();
assertThat(aValue.get(1)).isEqualTo(5);
assertThat(aValue.get(2)).isNull();
List<?> bValue = map.get("b");
assertEquals(1, bValue.size());
assertEquals("4", bValue.get(0));
assertThat(bValue.size()).isEqualTo(1);
assertThat(bValue.get(0)).isEqualTo("4");
assertEquals(MediaType.MULTIPART_FORM_DATA, request.getHeaders().getContentType());
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.MULTIPART_FORM_DATA);
}
@Test
@@ -448,25 +443,25 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
List<?> aValue = map.get("a");
assertEquals(2, aValue.size());
assertEquals("1", aValue.get(0));
assertEquals("2", aValue.get(1));
assertThat(aValue.size()).isEqualTo(2);
assertThat(aValue.get(0)).isEqualTo("1");
assertThat(aValue.get(1)).isEqualTo("2");
List<?> bValue = map.get("b");
assertEquals(0, bValue.size());
assertThat(bValue.size()).isEqualTo(0);
List<?> cValue = map.get("c");
assertEquals(1, cValue.size());
assertEquals("3", cValue.get(0));
assertThat(cValue.size()).isEqualTo(1);
assertThat(cValue.get(0)).isEqualTo("3");
assertEquals(MediaType.APPLICATION_FORM_URLENCODED, request.getHeaders().getContentType());
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_FORM_URLENCODED);
}
@Test
@@ -493,25 +488,25 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
List<?> aValue = map.get("a");
assertEquals(2, aValue.size());
assertEquals("Philadelphia", aValue.get(0).toString());
assertEquals("Ambler", aValue.get(1).toString());
assertThat(aValue.size()).isEqualTo(2);
assertThat(aValue.get(0).toString()).isEqualTo("Philadelphia");
assertThat(aValue.get(1).toString()).isEqualTo("Ambler");
List<?> bValue = map.get("b");
assertEquals(0, bValue.size());
assertThat(bValue.size()).isEqualTo(0);
List<?> cValue = map.get("c");
assertEquals(1, cValue.size());
assertEquals("Mohnton", cValue.get(0).toString());
assertThat(cValue.size()).isEqualTo(1);
assertThat(cValue.get(0).toString()).isEqualTo("Mohnton");
assertEquals(MediaType.MULTIPART_FORM_DATA, request.getHeaders().getContentType());
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.MULTIPART_FORM_DATA);
}
@Test
@@ -535,20 +530,20 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof MultiValueMap<?, ?>);
assertThat(body instanceof MultiValueMap<?, ?>).isTrue();
MultiValueMap<?, ?> map = (MultiValueMap<?, ?>) body;
assertTrue(map.containsKey("a"));
assertTrue(map.get("a").size() == 1);
assertNull(map.get("a").get(0));
assertThat(map.containsKey("a")).isTrue();
assertThat(map.get("a").size() == 1).isTrue();
assertThat(map.get("a").get(0)).isNull();
List<?> entryB = map.get("b");
assertEquals("foo", entryB.get(0));
assertTrue(map.containsKey("c"));
assertTrue(map.get("c").size() == 1);
assertNull(map.get("c").get(0));
assertEquals(MediaType.APPLICATION_FORM_URLENCODED, request.getHeaders().getContentType());
assertThat(entryB.get(0)).isEqualTo("foo");
assertThat(map.containsKey("c")).isTrue();
assertThat(map.get("c").size() == 1).isTrue();
assertThat(map.get("c").get(0)).isNull();
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_FORM_URLENCODED);
}
@SuppressWarnings("cast")
@@ -571,12 +566,12 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof byte[]);
assertEquals("Hello World", new String(bytes));
assertEquals(MediaType.APPLICATION_OCTET_STREAM, request.getHeaders().getContentType());
assertThat(body instanceof byte[]).isTrue();
assertThat(new String(bytes)).isEqualTo("Hello World");
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_OCTET_STREAM);
}
@Test
@@ -597,11 +592,11 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertEquals("intentional", exception.getCause().getMessage());
assertThat(exception.getCause().getMessage()).isEqualTo("intentional");
HttpEntity<?> request = template.lastRequestEntity.get();
Object body = request.getBody();
assertTrue(body instanceof Source);
assertEquals(MediaType.TEXT_XML, request.getHeaders().getContentType());
assertThat(body instanceof Source).isTrue();
assertThat(request.getHeaders().getContentType()).isEqualTo(MediaType.TEXT_XML);
}
@Test // no assertions just a warn message in a log
@@ -654,8 +649,8 @@ public class HttpRequestExecutingMessageHandlerTests {
fail("An Exception expected");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertNull(template.lastRequestEntity.get().getHeaders().getContentType());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
assertThat(template.lastRequestEntity.get().getHeaders().getContentType()).isNull();
}
//HEAD
@@ -667,8 +662,8 @@ public class HttpRequestExecutingMessageHandlerTests {
fail("An Exception expected");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertNull(template.lastRequestEntity.get().getHeaders().getContentType());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
assertThat(template.lastRequestEntity.get().getHeaders().getContentType()).isNull();
}
@@ -681,8 +676,8 @@ public class HttpRequestExecutingMessageHandlerTests {
fail("An Exception expected");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertEquals(MediaType.TEXT_XML, template.lastRequestEntity.get().getHeaders().getContentType());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
assertThat(template.lastRequestEntity.get().getHeaders().getContentType()).isEqualTo(MediaType.TEXT_XML);
}
//TRACE
@@ -694,8 +689,8 @@ public class HttpRequestExecutingMessageHandlerTests {
fail("An Exception expected");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertNull(template.lastRequestEntity.get().getHeaders().getContentType());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
assertThat(template.lastRequestEntity.get().getHeaders().getContentType()).isNull();
}
}
@@ -710,7 +705,7 @@ public class HttpRequestExecutingMessageHandlerTests {
Mockito.eq(HttpMethod.POST), Mockito.any(HttpEntity.class), Mockito.<Class<Object>>eq(null));
HttpRequestExecutingMessageHandler handler = ctx.getBean("chain$child.adapter.handler",
HttpRequestExecutingMessageHandler.class);
assertThat(TestUtils.getPropertyValue(handler, "trustedSpel"), equalTo(Boolean.TRUE));
assertThat(TestUtils.getPropertyValue(handler, "trustedSpel")).isEqualTo(Boolean.TRUE);
ctx.close();
}
@@ -724,7 +719,7 @@ public class HttpRequestExecutingMessageHandlerTests {
PollableChannel output = ctx.getBean("replyChannel", PollableChannel.class);
Message<?> receive = output.receive();
assertEquals(HttpStatus.OK, ((ResponseEntity<?>) receive.getPayload()).getStatusCode());
assertThat(((ResponseEntity<?>) receive.getPayload()).getStatusCode()).isEqualTo(HttpStatus.OK);
Mockito.verify(restTemplate).exchange(
Mockito.eq(new URI("http://localhost:51235/%2f/testApps?param=http+Outbound+Gateway+Within+Chain")),
Mockito.eq(HttpMethod.POST), Mockito.any(HttpEntity.class),
@@ -748,7 +743,7 @@ public class HttpRequestExecutingMessageHandlerTests {
}
catch (Exception e) {
}
assertEquals(theURL, restTemplate.actualUrl.get());
assertThat(restTemplate.actualUrl.get()).isEqualTo(theURL);
}
@Test
@@ -765,7 +760,8 @@ public class HttpRequestExecutingMessageHandlerTests {
}
catch (Exception e) {
}
assertEquals("http://my.RabbitMQ.com/api/queues/%2f/si.test.queue?foo#bar", restTemplate.actualUrl.get());
assertThat(restTemplate.actualUrl.get())
.isEqualTo("http://my.RabbitMQ.com/api/queues/%2f/si.test.queue?foo#bar");
}
@Test
@@ -793,13 +789,13 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertTrue(requestHeaders.getAccept() != null);
assertTrue(requestHeaders.getAccept().size() > 0);
assertEquals("404 Not Found", exception.getCause().getMessage());
assertThat(requestHeaders.getAccept() != null).isTrue();
assertThat(requestHeaders.getAccept().size() > 0).isTrue();
assertThat(exception.getCause().getMessage()).isEqualTo("404 Not Found");
List<MediaType> accept = requestHeaders.getAccept();
assertTrue(accept != null && accept.size() > 0);
assertEquals("application", accept.get(0).getType());
assertEquals("x-java-serialized-object", accept.get(0).getSubtype());
assertThat(accept != null && accept.size() > 0).isTrue();
assertThat(accept.get(0).getType()).isEqualTo("application");
assertThat(accept.get(0).getSubtype()).isEqualTo("x-java-serialized-object");
}
@Test
@@ -829,13 +825,13 @@ public class HttpRequestExecutingMessageHandlerTests {
catch (Exception e) {
exception = e;
}
assertTrue(requestHeaders.getAccept() != null);
assertTrue(requestHeaders.getAccept().size() > 0);
assertEquals("404 Not Found", exception.getCause().getMessage());
assertThat(requestHeaders.getAccept() != null).isTrue();
assertThat(requestHeaders.getAccept().size() > 0).isTrue();
assertThat(exception.getCause().getMessage()).isEqualTo("404 Not Found");
List<MediaType> accept = requestHeaders.getAccept();
assertTrue(accept != null && accept.size() > 0);
assertEquals("application", accept.get(0).getType());
assertEquals("x-java-serialized-object", accept.get(0).getSubtype());
assertThat(accept != null && accept.size() > 0).isTrue();
assertThat(accept.get(0).getType()).isEqualTo("application");
assertThat(accept.get(0).getSubtype()).isEqualTo("x-java-serialized-object");
}
private void setBeanFactory(HttpRequestExecutingMessageHandler handler) {

28
spring-integration-http/src/test/java/org/springframework/integration/http/outbound/UriVariableExpressionTests.java
View File

@@ -16,10 +16,8 @@
package org.springframework.integration.http.outbound;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.Mockito.mock;
import java.net.URI;
@@ -72,9 +70,9 @@ public class UriVariableExpressionTests {
fail("Exception expected.");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
}
assertEquals("http://test/bar", uriHolder.get().toString());
assertThat(uriHolder.get().toString()).isEqualTo("http://test/bar");
}
/**
@@ -101,9 +99,9 @@ public class UriVariableExpressionTests {
fail("Exception expected.");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
}
assertEquals("http://test/bar", uriHolder.get().toString());
assertThat(uriHolder.get().toString()).isEqualTo("http://test/bar");
}
@Test
@@ -137,10 +135,10 @@ public class UriVariableExpressionTests {
fail("Exception expected.");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
}
assertEquals("http://test/bar", uriHolder.get().toString());
assertThat(uriHolder.get().toString()).isEqualTo("http://test/bar");
expressions.put("foo", new SpelExpressionParser().parseExpression("'bar'.toUpperCase()"));
try {
@@ -150,10 +148,10 @@ public class UriVariableExpressionTests {
fail("Exception expected.");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
}
assertEquals("http://test/BAR", uriHolder.get().toString());
assertThat(uriHolder.get().toString()).isEqualTo("http://test/BAR");
expressions.put("foo", new SpelExpressionParser().parseExpression("T(Integer).valueOf('42')"));
try {
@@ -163,7 +161,7 @@ public class UriVariableExpressionTests {
fail("Exception expected.");
}
catch (Exception e) {
assertThat(e.getCause().getMessage(), containsString("Type cannot be found"));
assertThat(e.getCause().getMessage()).contains("Type cannot be found");
}
handler.setTrustedSpel(true);
@@ -174,9 +172,9 @@ public class UriVariableExpressionTests {
fail("Exception expected.");
}
catch (Exception e) {
assertEquals("intentional", e.getCause().getMessage());
assertThat(e.getCause().getMessage()).isEqualTo("intentional");
}
assertEquals("http://test/42", uriHolder.get().toString());
assertThat(uriHolder.get().toString()).isEqualTo("http://test/42");
context.close();
}

208
spring-integration-http/src/test/java/org/springframework/integration/http/support/DefaultHttpHeaderMapperFromMessageInboundTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2016 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,10 +16,7 @@
package org.springframework.integration.http.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.net.URI;
import java.text.ParseException;
@@ -73,8 +70,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(1, headers.getAllow().size());
assertEquals(HttpMethod.GET, headers.getAllow().iterator().next());
assertThat(headers.getAllow().size()).isEqualTo(1);
assertThat(headers.getAllow().iterator().next()).isEqualTo(HttpMethod.GET);
}
@Test
@@ -85,8 +82,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(1, headers.getAllow().size());
assertEquals(HttpMethod.GET, headers.getAllow().iterator().next());
assertThat(headers.getAllow().size()).isEqualTo(1);
assertThat(headers.getAllow().iterator().next()).isEqualTo(HttpMethod.GET);
}
@Test
@@ -97,8 +94,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(1, headers.getAllow().size());
assertEquals(HttpMethod.GET, headers.getAllow().iterator().next());
assertThat(headers.getAllow().size()).isEqualTo(1);
assertThat(headers.getAllow().iterator().next()).isEqualTo(HttpMethod.GET);
}
@Test
@@ -109,9 +106,9 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAllow().size());
assertTrue(headers.getAllow().contains(HttpMethod.GET));
assertTrue(headers.getAllow().contains(HttpMethod.POST));
assertThat(headers.getAllow().size()).isEqualTo(2);
assertThat(headers.getAllow().contains(HttpMethod.GET)).isTrue();
assertThat(headers.getAllow().contains(HttpMethod.POST)).isTrue();
}
@Test
@@ -122,9 +119,9 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAllow().size());
assertTrue(headers.getAllow().contains(HttpMethod.GET));
assertTrue(headers.getAllow().contains(HttpMethod.POST));
assertThat(headers.getAllow().size()).isEqualTo(2);
assertThat(headers.getAllow().contains(HttpMethod.GET)).isTrue();
assertThat(headers.getAllow().contains(HttpMethod.POST)).isTrue();
}
@Test
@@ -135,9 +132,9 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAllow().size());
assertTrue(headers.getAllow().contains(HttpMethod.GET));
assertTrue(headers.getAllow().contains(HttpMethod.POST));
assertThat(headers.getAllow().size()).isEqualTo(2);
assertThat(headers.getAllow().contains(HttpMethod.GET)).isTrue();
assertThat(headers.getAllow().contains(HttpMethod.POST)).isTrue();
}
@Test
@@ -148,9 +145,9 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAllow().size());
assertTrue(headers.getAllow().contains(HttpMethod.GET));
assertTrue(headers.getAllow().contains(HttpMethod.POST));
assertThat(headers.getAllow().size()).isEqualTo(2);
assertThat(headers.getAllow().contains(HttpMethod.GET)).isTrue();
assertThat(headers.getAllow().contains(HttpMethod.POST)).isTrue();
}
@Test
@@ -161,9 +158,9 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAllow().size());
assertTrue(headers.getAllow().contains(HttpMethod.GET));
assertTrue(headers.getAllow().contains(HttpMethod.POST));
assertThat(headers.getAllow().size()).isEqualTo(2);
assertThat(headers.getAllow().contains(HttpMethod.GET)).isTrue();
assertThat(headers.getAllow().contains(HttpMethod.POST)).isTrue();
}
// Cache-Control tested as part of DefaultHttpHeaderMapperFromMessageOutboundTests
@@ -181,7 +178,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals("\"1234\"", headers.getETag());
assertThat(headers.getETag()).isEqualTo("\"1234\"");
}
// Expires tests
@@ -196,7 +193,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getExpires());
assertThat(headers.getExpires()).isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
@Test
@@ -209,7 +206,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getExpires());
assertThat(headers.getExpires()).isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
@Test
@@ -222,7 +219,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getExpires());
assertThat(headers.getExpires()).isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
// Last-Modified tests
@@ -237,7 +234,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getLastModified());
assertThat(headers.getLastModified())
.isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
@Test
@@ -250,7 +248,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getLastModified());
assertThat(headers.getLastModified())
.isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
@Test
@@ -263,7 +262,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getLastModified());
assertThat(headers.getLastModified())
.isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
// Location tests
@@ -276,7 +276,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(new URI("http://foo.com").toString(), headers.getLocation().toString());
assertThat(headers.getLocation().toString()).isEqualTo(new URI("http://foo.com").toString());
}
// Transfer Encoding tests
@@ -289,8 +289,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertTrue(String.format("'Headers' is not empty. It contains '%s' element(s).",
headers.size()), headers.isEmpty());
assertThat(headers.isEmpty()).as(String.format("'Headers' is not empty. It contains '%s' element(s).",
headers.size())).isTrue();
}
@Test
@@ -301,8 +301,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
headers.set("Transfer-Encoding", "chunked");
Map<String, ?> result = mapper.toHeaders(headers);
assertEquals(1, result.size());
assertEquals("chunked", result.get("Transfer-Encoding"));
assertThat(result.size()).isEqualTo(1);
assertThat(result.get("Transfer-Encoding")).isEqualTo("chunked");
}
@@ -314,8 +314,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
headers.set("Transfer-Encoding", "chunked");
Map<String, ?> result = mapper.toHeaders(headers);
assertTrue(String.format("'result' is not empty. It contains '%s' element(s).",
result.size()), result.isEmpty());
assertThat(result.isEmpty()).as(String.format("'result' is not empty. It contains '%s' element(s).",
result.size())).isTrue();
}
@@ -330,11 +330,11 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("bar", "123");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.size());
assertEquals(1, headers.get("foo").size());
assertEquals("abc", headers.getFirst("foo"));
assertEquals(1, headers.get("bar").size());
assertEquals("123", headers.getFirst("bar"));
assertThat(headers.size()).isEqualTo(2);
assertThat(headers.get("foo").size()).isEqualTo(1);
assertThat(headers.getFirst("foo")).isEqualTo("abc");
assertThat(headers.get("bar").size()).isEqualTo(1);
assertThat(headers.getFirst("bar")).isEqualTo("123");
}
@Test
@@ -351,17 +351,17 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("abcdef", "abcdef-value");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(3, headers.size());
assertNull(headers.get("1x"));
assertNull(headers.get("z1"));
assertNull(headers.get("abc"));
assertNull(headers.get("def"));
assertEquals(1, headers.get("x1").size());
assertEquals("x1-value", headers.getFirst("x1"));
assertEquals(1, headers.get("1z").size());
assertEquals("1z-value", headers.getFirst("1z"));
assertEquals(1, headers.get("abcdef").size());
assertEquals("abcdef-value", headers.getFirst("abcdef"));
assertThat(headers.size()).isEqualTo(3);
assertThat(headers.get("1x")).isNull();
assertThat(headers.get("z1")).isNull();
assertThat(headers.get("abc")).isNull();
assertThat(headers.get("def")).isNull();
assertThat(headers.get("x1").size()).isEqualTo(1);
assertThat(headers.getFirst("x1")).isEqualTo("x1-value");
assertThat(headers.get("1z").size()).isEqualTo(1);
assertThat(headers.getFirst("1z")).isEqualTo("1z-value");
assertThat(headers.get("abcdef").size()).isEqualTo(1);
assertThat(headers.getFirst("abcdef")).isEqualTo("abcdef-value");
}
@Test
@@ -375,11 +375,11 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("Content-Type", "text/xml");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.size());
assertTrue(headers.getAccept().isEmpty());
assertEquals(MediaType.TEXT_XML, headers.getContentType());
assertEquals(1, headers.get("X-foobar").size());
assertEquals("abc", headers.getFirst("X-foobar"));
assertThat(headers.size()).isEqualTo(2);
assertThat(headers.getAccept().isEmpty()).isTrue();
assertThat(headers.getContentType()).isEqualTo(MediaType.TEXT_XML);
assertThat(headers.get("X-foobar").size()).isEqualTo(1);
assertThat(headers.getFirst("X-foobar")).isEqualTo("abc");
}
@Test
@@ -393,11 +393,11 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("Content-Type", "text/xml");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.size());
assertTrue(headers.getAccept().isEmpty());
assertEquals(MediaType.TEXT_XML, headers.getContentType());
assertEquals(1, headers.get("Z-foobar").size());
assertEquals("abc", headers.getFirst("Z-foobar"));
assertThat(headers.size()).isEqualTo(2);
assertThat(headers.getAccept().isEmpty()).isTrue();
assertThat(headers.getContentType()).isEqualTo(MediaType.TEXT_XML);
assertThat(headers.get("Z-foobar").size()).isEqualTo(1);
assertThat(headers.getFirst("Z-foobar")).isEqualTo("abc");
}
@Test
@@ -411,11 +411,11 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("Content-Type", "text/xml");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.size());
assertTrue(headers.getAccept().isEmpty());
assertEquals(MediaType.TEXT_XML, headers.getContentType());
assertEquals(1, headers.get("foobar").size());
assertEquals("abc", headers.getFirst("foobar"));
assertThat(headers.size()).isEqualTo(2);
assertThat(headers.getAccept().isEmpty()).isTrue();
assertThat(headers.getContentType()).isEqualTo(MediaType.TEXT_XML);
assertThat(headers.get("foobar").size()).isEqualTo(1);
assertThat(headers.getFirst("foobar")).isEqualTo("abc");
}
@Test
@@ -429,11 +429,11 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("Content-Type", "text/xml");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.size());
assertTrue(headers.getAccept().isEmpty());
assertEquals(MediaType.TEXT_XML, headers.getContentType());
assertEquals(1, headers.get("foobar").size());
assertEquals("abc", headers.getFirst("foobar"));
assertThat(headers.size()).isEqualTo(2);
assertThat(headers.getAccept().isEmpty()).isTrue();
assertThat(headers.getContentType()).isEqualTo(MediaType.TEXT_XML);
assertThat(headers.get("foobar").size()).isEqualTo(1);
assertThat(headers.getFirst("foobar")).isEqualTo("abc");
}
@Test
@@ -444,9 +444,9 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
headers.set("foo", "abc");
headers.set("bar", "123");
Map<String, ?> result = mapper.toHeaders(headers);
assertEquals(2, result.size());
assertEquals("abc", result.get("foo"));
assertEquals("123", result.get("bar"));
assertThat(result.size()).isEqualTo(2);
assertThat(result.get("foo")).isEqualTo("abc");
assertThat(result.get("bar")).isEqualTo("123");
}
@Test
@@ -462,14 +462,14 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
headers.set("def", "def-value");
headers.set("abcdef", "abcdef-value");
Map<String, ?> result = mapper.toHeaders(headers);
assertEquals(3, result.size());
assertNull(result.get("1x"));
assertNull(result.get("z1"));
assertNull(result.get("abc"));
assertNull(result.get("def"));
assertEquals("x1-value", result.get("x1"));
assertEquals("1z-value", result.get("1z"));
assertEquals("abcdef-value", result.get("abcdef"));
assertThat(result.size()).isEqualTo(3);
assertThat(result.get("1x")).isNull();
assertThat(result.get("z1")).isNull();
assertThat(result.get("abc")).isNull();
assertThat(result.get("def")).isNull();
assertThat(result.get("x1")).isEqualTo("x1-value");
assertThat(result.get("1z")).isEqualTo("1z-value");
assertThat(result.get("abcdef")).isEqualTo("abcdef-value");
}
@Test
@@ -481,10 +481,10 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
headers.setAccept(Collections.singletonList(MediaType.TEXT_XML));
headers.setLocation(new URI("http://example.org"));
Map<String, ?> result = mapper.toHeaders(headers);
assertEquals(2, result.size());
assertNull(result.get("Location"));
assertEquals("abc", result.get("foobar"));
assertEquals(MediaType.TEXT_XML, result.get("Accept"));
assertThat(result.size()).isEqualTo(2);
assertThat(result.get("Location")).isNull();
assertThat(result.get("foobar")).isEqualTo("abc");
assertThat(result.get("Accept")).isEqualTo(MediaType.TEXT_XML);
}
@Test
@@ -498,8 +498,8 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("customHeaderB", new TestClass());
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertNull(headers.get("X-customHeaderA"));
assertNull(headers.get("X-customHeaderB"));
assertThat(headers.get("X-customHeaderA")).isNull();
assertThat(headers.get("X-customHeaderB")).isNull();
}
@@ -519,9 +519,9 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("customHeaderB", new TestClass());
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertNotNull(headers.get("customHeaderA"));
assertEquals("123", headers.get("customHeaderA").get(0));
assertNull(headers.get("customHeaderB"));
assertThat(headers.get("customHeaderA")).isNotNull();
assertThat(headers.get("customHeaderA").get(0)).isEqualTo("123");
assertThat(headers.get("customHeaderB")).isNull();
}
@Test
@@ -541,10 +541,10 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
messageHeaders.put("customHeaderB", new TestClass());
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertNotNull(headers.get("customHeaderA"));
assertEquals("123", headers.get("customHeaderA").get(0));
assertNotNull(headers.get("customHeaderB"));
assertEquals("TestClass.class", headers.get("customHeaderB").get(0));
assertThat(headers.get("customHeaderA")).isNotNull();
assertThat(headers.get("customHeaderA").get(0)).isEqualTo("123");
assertThat(headers.get("customHeaderB")).isNotNull();
assertThat(headers.get("customHeaderB").get(0)).isEqualTo("TestClass.class");
}
@Test
@@ -556,7 +556,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
Map<String, Object> messageHeaders = mapper.toHeaders(headers);
headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertNull(headers.get("Content-Length"));
assertThat(headers.get("Content-Length")).isNull();
}
@Test
@@ -570,7 +570,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
Calendar c = Calendar.getInstance();
c.setTime(ifModifiedSince);
c.set(Calendar.MILLISECOND, 0);
assertEquals(c.getTimeInMillis(), result.get("If-Modified-Since"));
assertThat(result.get("If-Modified-Since")).isEqualTo(c.getTimeInMillis());
}
@Test
@@ -581,7 +581,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
MessageHeaders messageHeaders = new MessageHeaders(map);
HttpHeaders httpHeaders = new HttpHeaders();
mapper.fromHeaders(messageHeaders, httpHeaders);
assertEquals(MediaType.valueOf("text/plain"), httpHeaders.getContentType());
assertThat(httpHeaders.getContentType()).isEqualTo(MediaType.valueOf("text/plain"));
}
@Test
@@ -590,7 +590,7 @@ public class DefaultHttpHeaderMapperFromMessageInboundTests {
HttpHeaders headers = new HttpHeaders();
headers.add(HttpHeaders.CONTENT_TYPE.toLowerCase(), "text/plain");
Map<String, ?> result = mapper.toHeaders(headers);
assertEquals(MediaType.valueOf("text/plain"), result.get(MessageHeaders.CONTENT_TYPE));
assertThat(result.get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MediaType.valueOf("text/plain"));
}

232
spring-integration-http/src/test/java/org/springframework/integration/http/support/DefaultHttpHeaderMapperFromMessageOutboundTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 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.
@@ -16,10 +16,7 @@
package org.springframework.integration.http.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
@@ -75,8 +72,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals("bar", headers.getAccept().get(0).getType());
assertEquals("foo", headers.getAccept().get(0).getSubtype());
assertThat(headers.getAccept().get(0).getType()).isEqualTo("bar");
assertThat(headers.getAccept().get(0).getSubtype()).isEqualTo("foo");
}
@Test
@@ -88,8 +85,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals("bar", headers.getAccept().get(0).getType());
assertEquals("foo", headers.getAccept().get(0).getSubtype());
assertThat(headers.getAccept().get(0).getType()).isEqualTo("bar");
assertThat(headers.getAccept().get(0).getSubtype()).isEqualTo("foo");
}
@Test
@@ -100,9 +97,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAccept().size());
assertEquals("bar/foo", headers.getAccept().get(0).toString());
assertEquals("text/xml", headers.getAccept().get(1).toString());
assertThat(headers.getAccept().size()).isEqualTo(2);
assertThat(headers.getAccept().get(0).toString()).isEqualTo("bar/foo");
assertThat(headers.getAccept().get(1).toString()).isEqualTo("text/xml");
}
@Test
@@ -113,9 +110,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAccept().size());
assertEquals("bar/foo", headers.getAccept().get(0).toString());
assertEquals("text/xml", headers.getAccept().get(1).toString());
assertThat(headers.getAccept().size()).isEqualTo(2);
assertThat(headers.getAccept().get(0).toString()).isEqualTo("bar/foo");
assertThat(headers.getAccept().get(1).toString()).isEqualTo("text/xml");
}
@Test
@@ -126,9 +123,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAccept().size());
assertEquals("bar/foo", headers.getAccept().get(0).toString());
assertEquals("text/xml", headers.getAccept().get(1).toString());
assertThat(headers.getAccept().size()).isEqualTo(2);
assertThat(headers.getAccept().get(0).toString()).isEqualTo("bar/foo");
assertThat(headers.getAccept().get(1).toString()).isEqualTo("text/xml");
}
@Test
@@ -139,9 +136,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAccept().size());
assertEquals("bar/foo", headers.getAccept().get(0).toString());
assertEquals("text/xml", headers.getAccept().get(1).toString());
assertThat(headers.getAccept().size()).isEqualTo(2);
assertThat(headers.getAccept().get(0).toString()).isEqualTo("bar/foo");
assertThat(headers.getAccept().get(1).toString()).isEqualTo("text/xml");
}
@Test
@@ -152,9 +149,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAccept().size());
assertEquals("bar/foo", headers.getAccept().get(0).toString());
assertEquals("text/xml", headers.getAccept().get(1).toString());
assertThat(headers.getAccept().size()).isEqualTo(2);
assertThat(headers.getAccept().get(0).toString()).isEqualTo("bar/foo");
assertThat(headers.getAccept().get(1).toString()).isEqualTo("text/xml");
}
// ACCEPT_CHARSET tests
@@ -176,8 +173,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(1, headers.getAcceptCharset().size());
assertEquals("UTF-8", headers.getAcceptCharset().get(0).displayName());
assertThat(headers.getAcceptCharset().size()).isEqualTo(1);
assertThat(headers.getAcceptCharset().get(0).displayName()).isEqualTo("UTF-8");
}
@Test
@@ -188,8 +185,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(1, headers.getAcceptCharset().size());
assertEquals("UTF-8", headers.getAcceptCharset().get(0).displayName());
assertThat(headers.getAcceptCharset().size()).isEqualTo(1);
assertThat(headers.getAcceptCharset().get(0).displayName()).isEqualTo("UTF-8");
}
@Test
@@ -200,10 +197,10 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAcceptCharset().size());
assertThat(headers.getAcceptCharset().size()).isEqualTo(2);
// validate contains since the order is not enforced
assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8")));
assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1")));
assertThat(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))).isTrue();
assertThat(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))).isTrue();
}
@Test
@@ -214,10 +211,10 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAcceptCharset().size());
assertThat(headers.getAcceptCharset().size()).isEqualTo(2);
// validate contains since the order is not enforced
assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8")));
assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1")));
assertThat(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))).isTrue();
assertThat(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))).isTrue();
}
@Test
@@ -228,10 +225,10 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAcceptCharset().size());
assertThat(headers.getAcceptCharset().size()).isEqualTo(2);
// validate contains since the order is not enforced
assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8")));
assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1")));
assertThat(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))).isTrue();
assertThat(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))).isTrue();
}
@Test
@@ -242,10 +239,10 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAcceptCharset().size());
assertThat(headers.getAcceptCharset().size()).isEqualTo(2);
// validate contains since the order is not enforced
assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8")));
assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1")));
assertThat(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))).isTrue();
assertThat(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))).isTrue();
}
@Test
@@ -256,10 +253,10 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getAcceptCharset().size());
assertThat(headers.getAcceptCharset().size()).isEqualTo(2);
// validate contains since the order is not enforced
assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8")));
assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1")));
assertThat(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))).isTrue();
assertThat(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))).isTrue();
}
// Cache-Control tests
@@ -272,7 +269,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals("foo", headers.getCacheControl());
assertThat(headers.getCacheControl()).isEqualTo("foo");
}
// Content-Length tests
@@ -285,7 +282,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(1, headers.getContentLength());
assertThat(headers.getContentLength()).isEqualTo(1);
}
@Test
@@ -296,7 +293,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(1, headers.getContentLength());
assertThat(headers.getContentLength()).isEqualTo(1);
}
@Test(expected = NumberFormatException.class)
@@ -329,8 +326,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals("text", headers.getContentType().getType());
assertEquals("html", headers.getContentType().getSubtype());
assertThat(headers.getContentType().getType()).isEqualTo("text");
assertThat(headers.getContentType().getSubtype()).isEqualTo("html");
}
@Test
@@ -341,8 +338,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals("text", headers.getContentType().getType());
assertEquals("html", headers.getContentType().getSubtype());
assertThat(headers.getContentType().getType()).isEqualTo("text");
assertThat(headers.getContentType().getSubtype()).isEqualTo("html");
}
// Date test
@@ -357,7 +354,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getDate());
assertThat(headers.getDate()).isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
@Test
@@ -370,7 +367,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getDate());
assertThat(headers.getDate()).isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
@Test
@@ -383,7 +380,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getDate());
assertThat(headers.getDate()).isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
// If-Modified-Since tests
@@ -398,7 +395,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getIfModifiedSince());
assertThat(headers.getIfModifiedSince())
.isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
@Test
@@ -411,7 +409,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getIfModifiedSince());
assertThat(headers.getIfModifiedSince())
.isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
@Test
@@ -424,7 +423,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getIfModifiedSince());
assertThat(headers.getIfModifiedSince())
.isEqualTo(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime());
}
// If-None-Match
@@ -437,8 +437,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(1, headers.getIfNoneMatch().size());
assertEquals("\"1234567\"", headers.getIfNoneMatch().get(0));
assertThat(headers.getIfNoneMatch().size()).isEqualTo(1);
assertThat(headers.getIfNoneMatch().get(0)).isEqualTo("\"1234567\"");
}
@Test
@@ -449,9 +449,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getIfNoneMatch().size());
assertEquals("\"123,4567\"", headers.getIfNoneMatch().get(0));
assertEquals("\"123\"", headers.getIfNoneMatch().get(1));
assertThat(headers.getIfNoneMatch().size()).isEqualTo(2);
assertThat(headers.getIfNoneMatch().get(0)).isEqualTo("\"123,4567\"");
assertThat(headers.getIfNoneMatch().get(1)).isEqualTo("\"123\"");
}
@Test
@@ -462,9 +462,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getIfNoneMatch().size());
assertEquals("\"1234567\"", headers.getIfNoneMatch().get(0));
assertEquals("\"123\"", headers.getIfNoneMatch().get(1));
assertThat(headers.getIfNoneMatch().size()).isEqualTo(2);
assertThat(headers.getIfNoneMatch().get(0)).isEqualTo("\"1234567\"");
assertThat(headers.getIfNoneMatch().get(1)).isEqualTo("\"123\"");
}
@Test
@@ -475,9 +475,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getIfNoneMatch().size());
assertEquals("\"123.4567\"", headers.getIfNoneMatch().get(0));
assertEquals("\"123\"", headers.getIfNoneMatch().get(1));
assertThat(headers.getIfNoneMatch().size()).isEqualTo(2);
assertThat(headers.getIfNoneMatch().get(0)).isEqualTo("\"123.4567\"");
assertThat(headers.getIfNoneMatch().get(1)).isEqualTo("\"123\"");
}
@Test
@@ -488,9 +488,9 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(2, headers.getIfNoneMatch().size());
assertEquals("\"1234567\"", headers.getIfNoneMatch().get(0));
assertEquals("\"123\"", headers.getIfNoneMatch().get(1));
assertThat(headers.getIfNoneMatch().size()).isEqualTo(2);
assertThat(headers.getIfNoneMatch().get(0)).isEqualTo("\"1234567\"");
assertThat(headers.getIfNoneMatch().get(1)).isEqualTo("\"123\"");
}
// Pragma tests
@@ -501,7 +501,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
messageHeaders.put("Pragma", "foo");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals("foo", headers.getPragma());
assertThat(headers.getPragma()).isEqualTo("foo");
}
// Transfer-Encoding tests
@@ -512,7 +512,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
messageHeaders.put("Transfer-Encoding", "chunked");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertNull(headers.get("Transfer-Encoding"));
assertThat(headers.get("Transfer-Encoding")).isNull();
}
@Test
@@ -523,7 +523,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
httpHeaders.set("Transfer-Encoding", "chunked");
Map<String, ?> messageHeaders = mapper.toHeaders(httpHeaders);
assertEquals(1, messageHeaders.size());
assertThat(messageHeaders.size()).isEqualTo(1);
}
@@ -560,8 +560,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
messageHeaders.put("foo", "foo");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertNull(headers.get("foo"));
assertNull(headers.get("X-foo"));
assertThat(headers.get("foo")).isNull();
assertThat(headers.get("X-foo")).isNull();
}
@Test
@@ -572,10 +572,10 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
messageHeaders.put("foo", "foo");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertNull(headers.get("X-foo"));
assertNotNull(headers.get("foo"));
assertTrue(headers.get("foo").size() == 1);
assertEquals("foo", headers.get("foo").get(0));
assertThat(headers.get("X-foo")).isNull();
assertThat(headers.get("foo")).isNotNull();
assertThat(headers.get("foo").size() == 1).isTrue();
assertThat(headers.get("foo").get(0)).isEqualTo("foo");
}
@Test
@@ -592,17 +592,17 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
messageHeaders.put("abcdef", "abcdef-value");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(3, headers.size());
assertNull(headers.get("1x"));
assertNull(headers.get("z1"));
assertNull(headers.get("abc"));
assertNull(headers.get("def"));
assertEquals(1, headers.get("x1").size());
assertEquals("x1-value", headers.getFirst("x1"));
assertEquals(1, headers.get("1z").size());
assertEquals("1z-value", headers.getFirst("1z"));
assertEquals(1, headers.get("abcdef").size());
assertEquals("abcdef-value", headers.getFirst("abcdef"));
assertThat(headers.size()).isEqualTo(3);
assertThat(headers.get("1x")).isNull();
assertThat(headers.get("z1")).isNull();
assertThat(headers.get("abc")).isNull();
assertThat(headers.get("def")).isNull();
assertThat(headers.get("x1").size()).isEqualTo(1);
assertThat(headers.getFirst("x1")).isEqualTo("x1-value");
assertThat(headers.get("1z").size()).isEqualTo(1);
assertThat(headers.getFirst("1z")).isEqualTo("1z-value");
assertThat(headers.get("abcdef").size()).isEqualTo(1);
assertThat(headers.getFirst("abcdef")).isEqualTo("abcdef-value");
}
@Test
@@ -615,12 +615,12 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
messageHeaders.put("Accept", "text/xml");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(3, headers.size());
assertEquals(1, headers.get("foobar").size());
assertEquals("abc", headers.getFirst("foobar"));
assertEquals("text/html", headers.getContentType().toString());
assertEquals(1, headers.getAccept().size());
assertEquals(MediaType.TEXT_XML, headers.getAccept().get(0));
assertThat(headers.size()).isEqualTo(3);
assertThat(headers.get("foobar").size()).isEqualTo(1);
assertThat(headers.getFirst("foobar")).isEqualTo("abc");
assertThat(headers.getContentType().toString()).isEqualTo("text/html");
assertThat(headers.getAccept().size()).isEqualTo(1);
assertThat(headers.getAccept().get(0)).isEqualTo(MediaType.TEXT_XML);
}
@Test
@@ -632,10 +632,10 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
httpHeaders.setContentType(MediaType.TEXT_HTML);
httpHeaders.setAccept(Collections.singletonList(MediaType.TEXT_HTML));
Map<String, ?> messageHeaders = mapper.toHeaders(httpHeaders);
assertEquals(2, messageHeaders.size());
assertNull(messageHeaders.get("Accept"));
assertEquals("abc", messageHeaders.get("foobar"));
assertEquals("text/html", messageHeaders.get(MessageHeaders.CONTENT_TYPE).toString());
assertThat(messageHeaders.size()).isEqualTo(2);
assertThat(messageHeaders.get("Accept")).isNull();
assertThat(messageHeaders.get("foobar")).isEqualTo("abc");
assertThat(messageHeaders.get(MessageHeaders.CONTENT_TYPE).toString()).isEqualTo("text/html");
}
@Test
@@ -645,8 +645,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
headers.set("x-foo", "x-foo-value");
Map<String, ?> result = mapper.toHeaders(headers);
assertEquals(1, result.size());
assertEquals("x-foo-value", result.get("x-foo"));
assertThat(result.size()).isEqualTo(1);
assertThat(result.get("x-foo")).isEqualTo("x-foo-value");
}
@Test
@@ -656,8 +656,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
headers.set("X-Foo", "x-foo-value");
Map<String, ?> result = mapper.toHeaders(headers);
assertEquals(1, result.size());
assertEquals("x-foo-value", result.get("X-Foo"));
assertThat(result.size()).isEqualTo(1);
assertThat(result.get("X-Foo")).isEqualTo("x-foo-value");
}
@Test
@@ -673,13 +673,13 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
messageHeaders.put("Accept", "text/xml");
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertEquals(5, headers.size());
assertEquals(1, headers.get("X-foobar").size());
assertEquals(1, headers.get("x-foobar").size());
assertEquals(1, headers.get("X-bar").size());
assertEquals(1, headers.get("x-bar").size());
assertEquals(1, headers.get("X-baz").size());
assertEquals(1, headers.get("x-baz").size());
assertThat(headers.size()).isEqualTo(5);
assertThat(headers.get("X-foobar").size()).isEqualTo(1);
assertThat(headers.get("x-foobar").size()).isEqualTo(1);
assertThat(headers.get("X-bar").size()).isEqualTo(1);
assertThat(headers.get("x-bar").size()).isEqualTo(1);
assertThat(headers.get("X-baz").size()).isEqualTo(1);
assertThat(headers.get("x-baz").size()).isEqualTo(1);
}
@Test
@@ -692,7 +692,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
mapper.fromHeaders(new MessageHeaders(messageHeaders), headers);
assertNull(headers.get("Content-Length"));
assertThat(headers.get("Content-Length")).isNull();
}
@Test
@@ -700,7 +700,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
HttpHeaders headers = new HttpHeaders();
headers.set("Expires", "-1");
Map<String, Object> messageHeaders = DefaultHttpHeaderMapper.outboundMapper().toHeaders(headers);
assertEquals(0, messageHeaders.size());
assertThat(messageHeaders.size()).isEqualTo(0);
}
@Test
@@ -716,7 +716,7 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
Calendar c = Calendar.getInstance();
c.setTime(ifModifiedSince);
c.set(Calendar.MILLISECOND, 0);
assertEquals(c.getTimeInMillis(), headers.getIfModifiedSince());
assertThat(headers.getIfModifiedSince()).isEqualTo(c.getTimeInMillis());
}
@Test
@@ -725,8 +725,8 @@ public class DefaultHttpHeaderMapperFromMessageOutboundTests {
String headerValue = "attachment; filename=\"test.txt\"";
headers.set("Content-Disposition", headerValue);
Map<String, Object> messageHeaders = DefaultHttpHeaderMapper.outboundMapper().toHeaders(headers);
assertEquals(1, messageHeaders.size());
assertEquals(headerValue, messageHeaders.get("Content-Disposition"));
assertThat(messageHeaders.size()).isEqualTo(1);
assertThat(messageHeaders.get("Content-Disposition")).isEqualTo(headerValue);
}
}