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

INT-799: Remove Core Deps from s-i-test

Browse Source 
JIRA: https://jira.spring.io/browse/INT-799

Some test classes (e.g. `TestUtils`) were duplicated in core to avoid cyclic
dependency.

Now that core messaging has been moved to spring-messaging, it is possible
to remove the dependencies on `spring-integration-core` from `spring-integration-test`.

A few minor test cases have been moved to `spring-integration-core`.

The simple polishing to the `build.gradle` and `ServiceActivatorOnMockitoMockTests`
This commit is contained in:
Gary Russell
2015-11-25 17:17:41 -05:00
committed by Artem Bilan
parent 5850022bfe
commit d16cd9748c
27 changed files with 345 additions and 524 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
spring-integration-test/src/test/java/org/springframework/integration/test/matcher/HeaderMatcherTests.java
View File

@@ -1,201 +0,0 @@
/*
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.test.matcher;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.any;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasAllHeaders;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasCorrelationId;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasExpirationDate;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasHeader;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasHeaderKey;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasMessageId;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasSequenceNumber;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasSequenceSize;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasTimestamp;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import org.hamcrest.Matcher;
import org.junit.Before;
import org.junit.Test;
import org.springframework.messaging.Message;
import org.springframework.integration.support.MessageBuilder;
/**
* @author Alex Peters
* @author Iwein Fuld
* @author Gunnar Hillert
*
*/
public class HeaderMatcherTests {
static final String UNKNOWN_KEY = "unknownKey";
static final String ANY_HEADER_VALUE = "bar";
static final String ANY_HEADER_KEY = "test.foo";
static final String ANY_PAYLOAD = "bla";
static final String OTHER_HEADER_KEY = "test.number";
static final Integer OTHER_HEADER_VALUE = Integer.valueOf(123);
Message<?> message;
@Before
public void setUp() {
message = MessageBuilder.withPayload(ANY_PAYLOAD).setHeader(ANY_HEADER_KEY, ANY_HEADER_VALUE).setHeader(
OTHER_HEADER_KEY, OTHER_HEADER_VALUE).build();
}
@Test
public void hasEntry_withValidKeyValue_matches() throws Exception {
assertThat(message, hasHeader(ANY_HEADER_KEY, ANY_HEADER_VALUE));
assertThat(message, hasHeader(OTHER_HEADER_KEY, OTHER_HEADER_VALUE));
}
@Test
public void hasEntry_withUnknownKey_notMatching() throws Exception {
assertThat(message, not(hasHeader("test.unknown", ANY_HEADER_VALUE)));
}
@Test
public void hasEntry_withValidKeyAndMatcherValue_matches() throws Exception {
assertThat(message, hasHeader(ANY_HEADER_KEY, is(instanceOf(String.class))));
assertThat(message, hasHeader(ANY_HEADER_KEY, notNullValue()));
assertThat(message, hasHeader(ANY_HEADER_KEY, is(ANY_HEADER_VALUE)));
}
@Test
public void hasEntry_withValidKeyAndMatcherValue_notMatching() throws Exception {
assertThat(message, not(hasHeader(ANY_HEADER_KEY, is(instanceOf(Integer.class)))));
}
@Test
public void hasKey_withValidKey_matches() throws Exception {
assertThat(message, hasHeaderKey(ANY_HEADER_KEY));
assertThat(message, hasHeaderKey(OTHER_HEADER_KEY));
}
@Test
public void hasKey_withInvalidKey_notMatching() throws Exception {
assertThat(message, not(hasHeaderKey(UNKNOWN_KEY)));
}
@Test
public void hasAllEntries_withMessageHeader_matches() throws Exception {
Map<String, Object> expectedInHeaderMap = message.getHeaders();
assertThat(message, hasAllHeaders(expectedInHeaderMap));
}
@Test
public void hasAllEntries_withValidKeyValueOrMatcherValue_matches() throws Exception {
Map<String, Object> expectedInHeaderMap = new HashMap<String, Object>();
expectedInHeaderMap.put(ANY_HEADER_KEY, ANY_HEADER_VALUE);
expectedInHeaderMap.put(OTHER_HEADER_KEY, is(OTHER_HEADER_VALUE));
assertThat(message, hasAllHeaders(expectedInHeaderMap));
}
@Test
public void hasAllEntries_withInvalidValidKeyValueOrMatcherValue_notMatching() throws Exception {
Map<String, Object> expectedInHeaderMap = new HashMap<String, Object>();
expectedInHeaderMap.put(ANY_HEADER_KEY, ANY_HEADER_VALUE); // valid
expectedInHeaderMap.put(UNKNOWN_KEY, not(nullValue())); // fails
assertThat(message, not(hasAllHeaders(expectedInHeaderMap)));
expectedInHeaderMap.remove(UNKNOWN_KEY);
expectedInHeaderMap.put(OTHER_HEADER_KEY, ANY_HEADER_VALUE); // fails
}
@Test
public void readableException_singleHeader() throws Exception {
try {
assertThat(message, hasHeader("corn", "bread"));
}
catch (AssertionError ae) {
assertTrue(ae.getMessage().contains("Expected: a Message with Headers containing "));
}
}
@Test
public void readableException_allHeaders() throws Exception {
try {
Map<String, String> entries = new HashMap<String, String>();
entries.put("corn", "bread");
entries.put("chocolate", "pudding");
assertThat(message, hasAllHeaders(entries));
}
catch (AssertionError ae) {
assertTrue(ae.getMessage().contains("Expected: a Message with Headers containing "));
}
}
@Test
public void hasMessageId_sameId() throws Exception {
assertThat(message, hasMessageId(message.getHeaders().getId()));
}
@Test
public void hasCorrelationId_() throws Exception {
UUID correlationId = message.getHeaders().getId();
message = MessageBuilder.withPayload("blabla").setCorrelationId(correlationId).build();
assertThat(message, hasCorrelationId(correlationId));
}
@Test
public void hasSequenceNumber_() throws Exception {
int sequenceNumber = 123;
message = MessageBuilder.fromMessage(message).setSequenceNumber(sequenceNumber).build();
assertThat(message, hasSequenceNumber(sequenceNumber));
}
@Test
public void hasSequenceSize_() throws Exception {
int sequenceSize = 123;
message = MessageBuilder.fromMessage(message).setSequenceSize(sequenceSize).build();
assertThat(message, hasSequenceSize(sequenceSize));
assertThat(message, hasSequenceSize(is(sequenceSize)));
}
@Test
public void hasTimestamp_() throws Exception {
assertThat(message, hasTimestamp(new Date(message.getHeaders().getTimestamp())));
}
@Test
public void hasExpirationDate_() throws Exception {
Matcher<Long> anyMatcher = any(Long.class);
assertThat(message, not(hasExpirationDate(anyMatcher)));
Date expirationDate = new Date(System.currentTimeMillis() + 10000);
message = MessageBuilder.fromMessage(message).setExpirationDate(expirationDate).build();
assertThat(message, hasExpirationDate(expirationDate));
assertThat(message, hasExpirationDate(not(is((System.currentTimeMillis())))));
}
}

31
spring-integration-test/src/test/java/org/springframework/integration/test/matcher/MockitoMessageMatchersTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2015 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,21 +15,8 @@
*/
package org.springframework.integration.test.matcher;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
import org.mockito.runners.MockitoJUnitRunner;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import org.springframework.integration.support.MessageBuilder;
import java.util.Date;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.verify;
@@ -37,6 +24,20 @@ import static org.mockito.Mockito.when;
import static org.springframework.integration.test.matcher.MockitoMessageMatchers.messageWithHeaderEntry;
import static org.springframework.integration.test.matcher.MockitoMessageMatchers.messageWithPayload;
import java.util.Date;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
import org.mockito.runners.MockitoJUnitRunner;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.support.MessageBuilder;
/**
* @author Alex Peters
* @author Iwein Fuld

7
spring-integration-test/src/test/java/org/springframework/integration/test/matcher/PayloadMatcherTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2015 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,8 +15,8 @@
*/
package org.springframework.integration.test.matcher;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertThat;
@@ -26,8 +26,9 @@ import static org.springframework.integration.test.matcher.PayloadMatcher.hasPay
import java.math.BigDecimal;
import org.junit.Test;
import org.springframework.messaging.Message;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.support.MessageBuilder;
/**
* @author Alex Peters

52
spring-integration-test/src/test/java/org/springframework/integration/test/mockito/ServiceActivatorOnMockitoMockTests-context.xml
View File

@@ -1,52 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:int="http://www.springframework.org/schema/integration"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd">
<int:channel id="in" />
<int:chain input-channel="in" output-channel="out">
<int:filter expression="payload == 'singleAnnotatedMethodOnClass'" throw-exception-on-rejection="true"/>
<int:service-activator ref="singleAnnotatedMethodOnClass" />
</int:chain>
<bean id="singleAnnotatedMethodOnClass" class="org.mockito.Mockito"
factory-method="mock">
<constructor-arg
value="org.springframework.integration.test.mockito.ServiceActivatorOnMockitoMockTests.SingleAnnotatedMethodOnClass" />
</bean>
<int:chain input-channel="in" output-channel="out">
<int:filter expression="payload == 'SingleMethodOnClass'" throw-exception-on-rejection="true"/>
<int:service-activator ref="singleMethodOnClass" />
</int:chain>
<bean id="singleMethodOnClass" class="org.mockito.Mockito"
factory-method="mock">
<constructor-arg
value="org.springframework.integration.test.mockito.ServiceActivatorOnMockitoMockTests.SingleMethodOnClass" />
</bean>
<int:chain input-channel="in" output-channel="out">
<int:filter expression="payload == 'SingleMethodAcceptingHeaderOnClass'" throw-exception-on-rejection="true"/>
<int:service-activator ref="singleMethodAcceptingHeaderOnClass" />
</int:chain>
<bean id="singleMethodAcceptingHeaderOnClass" class="org.mockito.Mockito"
factory-method="mock">
<constructor-arg
value="org.springframework.integration.test.mockito.ServiceActivatorOnMockitoMockTests.SingleMethodAcceptingHeaderOnClass" />
</bean>
<int:channel id="out">
<int:queue capacity="10" />
</int:channel>
</beans>

102
spring-integration-test/src/test/java/org/springframework/integration/test/mockito/ServiceActivatorOnMockitoMockTests.java
View File

@@ -1,102 +0,0 @@
/*
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.test.mockito;
import static org.mockito.Mockito.verify;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.PollableChannel;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* @author Iwein Fuld
* @author Gunnar Hillert
*/
@ContextConfiguration
@RunWith(SpringJUnit4ClassRunner.class)
public class ServiceActivatorOnMockitoMockTests {
@Autowired
@Qualifier("in")
MessageChannel in;
@Autowired
@Qualifier("out")
PollableChannel out;
public static class SingleAnnotatedMethodOnClass {
@ServiceActivator
public String move(String s) {
return s;
}
}
@Autowired
SingleAnnotatedMethodOnClass singleAnnotatedMethodOnClass;
@Test
public void shouldInvokeMockedSingleAnnotatedMethodOnClass() {
in.send(MessageBuilder.withPayload("singleAnnotatedMethodOnClass").build());
verify(singleAnnotatedMethodOnClass).move("singleAnnotatedMethodOnClass");
}
public static class SingleMethodOnClass {
public String move(String s) {
return s;
}
}
@Autowired
SingleMethodOnClass singleMethodOnClass;
@Test
public void shouldInvokeMockedSingleMethodOnClass() {
in.send(MessageBuilder.withPayload("SingleMethodOnClass").build());
verify(singleMethodOnClass).move("SingleMethodOnClass");
}
@SuppressWarnings("deprecation")
public static class SingleMethodAcceptingHeaderOnClass {
public String move(@org.springframework.integration.annotation.Header("s") String s) {
return s;
}
}
@Autowired
SingleMethodAcceptingHeaderOnClass singleMethodAcceptingHeaderOnClass;
@Test
public void shouldInvokeMockedSingleMethodAcceptingHeaderOnClass() {
in.send(MessageBuilder.withPayload("SingleMethodAcceptingHeaderOnClass")
.setHeader("s", "SingleMethodAcceptingHeaderOnClass")
.build());
verify(singleMethodAcceptingHeaderOnClass).move("SingleMethodAcceptingHeaderOnClass");
}
}

18
spring-integration-test/src/test/java/org/springframework/integration/test/support/MessageScenariosTests-context.xml
View File

@@ -1,18 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:int="http://www.springframework.org/schema/integration"
xsi:schemaLocation="http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<int:transformer input-channel="inputChannel" output-channel="outputChannel" expression="payload.toUpperCase()"/>
<int:channel id="outputChannel"/>
<int:transformer input-channel="inputChannel2" output-channel="outputChannel2" expression="payload.toUpperCase()"/>
<int:channel id="outputChannel2">
<int:queue/>
</int:channel>
</beans>

77
spring-integration-test/src/test/java/org/springframework/integration/test/support/MessageScenariosTests.java
View File

@@ -1,77 +0,0 @@
/*
* Copyright 2002-2011 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.test.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.springframework.integration.test.matcher.HeaderMatcher.hasHeader;
import static org.springframework.integration.test.matcher.PayloadMatcher.hasPayload;
import java.util.ArrayList;
import java.util.List;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.Message;
import org.springframework.test.context.ContextConfiguration;
@ContextConfiguration
public class MessageScenariosTests extends AbstractRequestResponseScenarioTests {
@Override
protected List<RequestResponseScenario> defineRequestResponseScenarios() {
List<RequestResponseScenario> scenarios= new ArrayList<RequestResponseScenario>();
RequestResponseScenario scenario1 = new RequestResponseScenario(
"inputChannel","outputChannel")
.setPayload("hello")
.setResponseValidator(new PayloadValidator<String>() {
@Override
protected void validateResponse(String response) {
assertEquals("HELLO",response);
}
});
scenarios.add(scenario1);
RequestResponseScenario scenario2 = new RequestResponseScenario(
"inputChannel","outputChannel")
.setMessage(MessageBuilder.withPayload("hello").setHeader("foo", "bar").build())
.setResponseValidator(new MessageValidator() {
@Override
protected void validateMessage(Message<?> message) {
assertThat(message,hasPayload("HELLO"));
assertThat(message,hasHeader("foo","bar"));
}
});
scenarios.add(scenario2);
RequestResponseScenario scenario3 = new RequestResponseScenario(
"inputChannel2","outputChannel2")
.setMessage(MessageBuilder.withPayload("hello").setHeader("foo", "bar").build())
.setResponseValidator(new MessageValidator() {
@Override
protected void validateMessage(Message<?> message) {
assertThat(message,hasPayload("HELLO"));
assertThat(message,hasHeader("foo","bar"));
}
});
scenarios.add(scenario3);
return scenarios;
}
}

42
spring-integration-test/src/test/java/org/springframework/integration/test/support/SingleScenarioTests.java
View File

@@ -1,42 +0,0 @@
/*
* Copyright 2002-2011 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.integration.test.support;
import static org.junit.Assert.assertEquals;
import org.springframework.test.context.ContextConfiguration;
@ContextConfiguration("MessageScenariosTests-context.xml")
public class SingleScenarioTests extends SingleRequestResponseScenarioTests {
/* (non-Javadoc)
* @see org.springframework.integration.test.support.SingleRequestResponseScenarioTest#defineRequestResponseScenario()
*/
@Override
protected RequestResponseScenario defineRequestResponseScenario() {
RequestResponseScenario scenario = new RequestResponseScenario(
"inputChannel","outputChannel")
.setPayload("hello")
.setResponseValidator(new PayloadValidator<String>() {
@Override
protected void validateResponse(String response) {
assertEquals("HELLO",response);
}
});
return scenario;
}
}