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

53
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/config/MongoDbInboundChannelAdapterIntegrationTests.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.mongodb.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 java.util.List;
@@ -111,9 +109,9 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
@SuppressWarnings("unchecked")
Message<List<Person>> message = (Message<List<Person>>) replyChannel.receive(10000);
assertNotNull(message);
assertEquals("Bob", message.getPayload().get(0).getName());
assertNotNull(this.replyChannel.receive(10000));
assertThat(message).isNotNull();
assertThat(message.getPayload().get(0).getName()).isEqualTo("Bob");
assertThat(this.replyChannel.receive(10000)).isNotNull();
this.mongoInboundAdapter.stop();
this.replyChannel.purge(null);
@@ -128,8 +126,8 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
@SuppressWarnings("unchecked")
Message<List<Document>> message = (Message<List<Document>>) replyChannel.receive(10000);
assertNotNull(message);
assertEquals("Bob", message.getPayload().get(0).get("name"));
assertThat(message).isNotNull();
assertThat(message.getPayload().get(0).get("name")).isEqualTo("Bob");
this.mongoInboundAdapterNamedFactory.stop();
this.replyChannel.purge(null);
@@ -144,8 +142,8 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
@SuppressWarnings("unchecked")
Message<Person> message = (Message<Person>) replyChannel.receive(10000);
assertNotNull(message);
assertEquals("Bob", message.getPayload().getName());
assertThat(message).isNotNull();
assertThat(message.getPayload().getName()).isEqualTo("Bob");
this.mongoInboundAdapterWithTemplate.stop();
this.replyChannel.purge(null);
@@ -160,8 +158,8 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
@SuppressWarnings("unchecked")
Message<List<Person>> message = (Message<List<Person>>) replyChannel.receive(10000);
assertNotNull(message);
assertEquals("Bob", message.getPayload().get(0).getName());
assertThat(message).isNotNull();
assertThat(message.getPayload().get(0).getName()).isEqualTo("Bob");
this.mongoInboundAdapterWithNamedCollection.stop();
this.replyChannel.purge(null);
@@ -175,9 +173,9 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
this.mongoInboundAdapterWithQueryExpression.start();
@SuppressWarnings("unchecked")
Message<List<Person>> message = (Message<List<Person>>) replyChannel.receive(10000);
assertNotNull(message);
assertEquals(1, message.getPayload().size());
assertEquals("Bob", message.getPayload().get(0).getName());
assertThat(message).isNotNull();
assertThat(message.getPayload().size()).isEqualTo(1);
assertThat(message.getPayload().get(0).getName()).isEqualTo("Bob");
this.mongoInboundAdapterWithQueryExpression.stop();
}
@@ -188,8 +186,8 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
this.mongoInboundAdapterWithStringQueryExpression.start();
@SuppressWarnings("unchecked")
Message<List<Person>> message = (Message<List<Person>>) replyChannel.receive(10000);
assertNotNull(message);
assertEquals("Bob", message.getPayload().get(0).getName());
assertThat(message).isNotNull();
assertThat(message.getPayload().get(0).getName()).isEqualTo("Bob");
this.mongoInboundAdapterWithStringQueryExpression.stop();
}
@@ -202,8 +200,8 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
@SuppressWarnings("unchecked")
Message<List<Person>> message = (Message<List<Person>>) replyChannel.receive(10000);
assertNotNull(message);
assertEquals("Bob", message.getPayload().get(0).getName());
assertThat(message).isNotNull();
assertThat(message.getPayload().get(0).getName()).isEqualTo("Bob");
this.mongoInboundAdapterWithNamedCollectionExpression.stop();
this.replyChannel.purge(null);
@@ -216,12 +214,13 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
this.inboundAdapterWithOnSuccessDisposition.start();
assertNotNull(replyChannel.receive(10000));
assertNull(replyChannel.receive(100));
assertThat(replyChannel.receive(10000)).isNotNull();
assertThat(replyChannel.receive(100)).isNull();
assertNotNull(this.afterCommitChannel.receive(10000));
assertThat(this.afterCommitChannel.receive(10000)).isNotNull();
assertNull(this.mongoTemplate.findOne(new Query(Criteria.where("name").is("Bob")), Person.class, "data"));
assertThat(this.mongoTemplate.findOne(new Query(Criteria.where("name").is("Bob")), Person.class, "data"))
.isNull();
this.inboundAdapterWithOnSuccessDisposition.stop();
this.replyChannel.purge(null);
}
@@ -235,9 +234,9 @@ public class MongoDbInboundChannelAdapterIntegrationTests extends MongoDbAvailab
@SuppressWarnings("unchecked")
Message<List<Person>> message = (Message<List<Person>>) replyChannel.receive(10000);
assertNotNull(message);
assertEquals("Bob", message.getPayload().get(0).getName());
assertNotNull(replyChannel.receive(10000));
assertThat(message).isNotNull();
assertThat(message.getPayload().get(0).getName()).isEqualTo("Bob");
assertThat(replyChannel.receive(10000)).isNotNull();
this.mongoInboundAdapterWithConverter.stop();
this.replyChannel.purge(null);

68
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/config/MongoDbInboundChannelAdapterParserTests.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.mongodb.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -93,48 +90,52 @@ public class MongoDbInboundChannelAdapterParserTests {
MongoDbMessageSource source = TestUtils.getPropertyValue(this.minimalConfigAdapter, "source",
MongoDbMessageSource.class);
assertEquals(false, TestUtils.getPropertyValue(this.minimalConfigAdapter, "shouldTrack"));
assertNotNull(TestUtils.getPropertyValue(source, "mongoTemplate"));
assertEquals(this.mongoDbFactory, TestUtils.getPropertyValue(source, "mongoDbFactory"));
assertNotNull(TestUtils.getPropertyValue(source, "evaluationContext"));
assertTrue(TestUtils.getPropertyValue(source, "collectionNameExpression") instanceof LiteralExpression);
assertEquals("data", TestUtils.getPropertyValue(source, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(this.minimalConfigAdapter, "shouldTrack")).isEqualTo(false);
assertThat(TestUtils.getPropertyValue(source, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(source, "mongoDbFactory")).isEqualTo(this.mongoDbFactory);
assertThat(TestUtils.getPropertyValue(source, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(source, "collectionNameExpression") instanceof LiteralExpression)
.isTrue();
assertThat(TestUtils.getPropertyValue(source, "collectionNameExpression.literalValue")).isEqualTo("data");
}
@Test
public void fullConfigWithCollectionExpression() {
MongoDbMessageSource source = assertMongoDbMessageSource(this.fullConfigWithCollectionExpressionAdapter);
assertTrue(TestUtils.getPropertyValue(source, "collectionNameExpression") instanceof SpelExpression);
assertEquals("'foo'", TestUtils.getPropertyValue(source, "collectionNameExpression.expression"));
assertThat(TestUtils.getPropertyValue(source, "collectionNameExpression") instanceof SpelExpression).isTrue();
assertThat(TestUtils.getPropertyValue(source, "collectionNameExpression.expression")).isEqualTo("'foo'");
}
@Test
public void fullConfigWithQueryExpression() {
MongoDbMessageSource source = assertMongoDbMessageSource(this.fullConfigWithQueryExpressionAdapter);
assertTrue(TestUtils.getPropertyValue(source, "queryExpression") instanceof SpelExpression);
assertEquals("new BasicQuery('{''address.state'' : ''PA''}').limit(2)",
TestUtils.getPropertyValue(source, "queryExpression.expression"));
assertThat(TestUtils.getPropertyValue(source, "queryExpression") instanceof SpelExpression).isTrue();
assertThat(TestUtils.getPropertyValue(source, "queryExpression.expression"))
.isEqualTo("new BasicQuery('{''address.state'' : ''PA''}').limit(2)");
}
@Test
public void fullConfigWithSpelQuery() {
MongoDbMessageSource source = assertMongoDbMessageSource(this.fullConfigWithSpelQueryAdapter);
assertTrue(TestUtils.getPropertyValue(source, "queryExpression") instanceof LiteralExpression);
assertEquals("{''address.state'' : ''PA''}", TestUtils.getPropertyValue(source, "queryExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(source, "queryExpression") instanceof LiteralExpression).isTrue();
assertThat(TestUtils.getPropertyValue(source, "queryExpression.literalValue"))
.isEqualTo("{''address.state'' : ''PA''}");
}
@Test
public void fullConfigWithQuery() {
MongoDbMessageSource source = assertMongoDbMessageSource(this.fullConfigWithQueryAdapter);
assertTrue(TestUtils.getPropertyValue(source, "queryExpression") instanceof LiteralExpression);
assertEquals("{'address.state' : 'PA'}", TestUtils.getPropertyValue(source, "queryExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(source, "queryExpression") instanceof LiteralExpression).isTrue();
assertThat(TestUtils.getPropertyValue(source, "queryExpression.literalValue"))
.isEqualTo("{'address.state' : 'PA'}");
}
@Test
public void fullConfigWithCollectionName() {
MongoDbMessageSource source = assertMongoDbMessageSource(this.fullConfigWithCollectionNameAdapter);
assertTrue(TestUtils.getPropertyValue(source, "collectionNameExpression") instanceof LiteralExpression);
assertEquals("foo", TestUtils.getPropertyValue(source, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(source, "collectionNameExpression") instanceof LiteralExpression)
.isTrue();
assertThat(TestUtils.getPropertyValue(source, "collectionNameExpression.literalValue")).isEqualTo("foo");
}
@Test
@@ -142,12 +143,13 @@ public class MongoDbInboundChannelAdapterParserTests {
MongoDbMessageSource source = TestUtils.getPropertyValue(this.fullConfigWithMongoTemplateAdapter, "source",
MongoDbMessageSource.class);
assertEquals(false, TestUtils.getPropertyValue(this.fullConfigWithMongoTemplateAdapter, "shouldTrack"));
assertNotNull(TestUtils.getPropertyValue(source, "mongoTemplate"));
assertSame(this.mongoDbTemplate, TestUtils.getPropertyValue(source, "mongoTemplate"));
assertNotNull(TestUtils.getPropertyValue(source, "evaluationContext"));
assertTrue(TestUtils.getPropertyValue(source, "collectionNameExpression") instanceof LiteralExpression);
assertEquals("foo", TestUtils.getPropertyValue(source, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(this.fullConfigWithMongoTemplateAdapter, "shouldTrack")).isEqualTo(false);
assertThat(TestUtils.getPropertyValue(source, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(source, "mongoTemplate")).isSameAs(this.mongoDbTemplate);
assertThat(TestUtils.getPropertyValue(source, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(source, "collectionNameExpression") instanceof LiteralExpression)
.isTrue();
assertThat(TestUtils.getPropertyValue(source, "collectionNameExpression.literalValue")).isEqualTo("foo");
}
@Test(expected = BeanDefinitionParsingException.class)
@@ -165,11 +167,11 @@ public class MongoDbInboundChannelAdapterParserTests {
private MongoDbMessageSource assertMongoDbMessageSource(Object testedBean) {
MongoDbMessageSource source = TestUtils.getPropertyValue(testedBean, "source", MongoDbMessageSource.class);
assertEquals(false, TestUtils.getPropertyValue(testedBean, "shouldTrack"));
assertNotNull(TestUtils.getPropertyValue(source, "mongoTemplate"));
assertEquals(this.mongoDbFactory, TestUtils.getPropertyValue(source, "mongoDbFactory"));
assertEquals(this.mongoConverter, TestUtils.getPropertyValue(source, "mongoConverter"));
assertNotNull(TestUtils.getPropertyValue(source, "evaluationContext"));
assertThat(TestUtils.getPropertyValue(testedBean, "shouldTrack")).isEqualTo(false);
assertThat(TestUtils.getPropertyValue(source, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(source, "mongoDbFactory")).isEqualTo(this.mongoDbFactory);
assertThat(TestUtils.getPropertyValue(source, "mongoConverter")).isEqualTo(this.mongoConverter);
assertThat(TestUtils.getPropertyValue(source, "evaluationContext")).isNotNull();
return source;
}

16
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/config/MongoDbOutboundChannelAdapterIntegrationTests.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,7 +16,7 @@
package org.springframework.integration.mongodb.config;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
@@ -51,7 +51,7 @@ public class MongoDbOutboundChannelAdapterIntegrationTests extends MongoDbAvaila
MongoDbFactory mongoDbFactory = this.prepareMongoFactory();
MongoTemplate template = new MongoTemplate(mongoDbFactory);
assertNotNull(template.find(new BasicQuery("{'name' : 'Bob'}"), Person.class, "data"));
assertThat(template.find(new BasicQuery("{'name' : 'Bob'}"), Person.class, "data")).isNotNull();
context.close();
}
@@ -70,7 +70,7 @@ public class MongoDbOutboundChannelAdapterIntegrationTests extends MongoDbAvaila
channel.send(message);
MongoTemplate template = new MongoTemplate(mongoDbFactory);
assertNotNull(template.find(new BasicQuery("{'name' : 'Bob'}"), Person.class, "foo"));
assertThat(template.find(new BasicQuery("{'name' : 'Bob'}"), Person.class, "foo")).isNotNull();
context.close();
}
@@ -90,7 +90,7 @@ public class MongoDbOutboundChannelAdapterIntegrationTests extends MongoDbAvaila
channel.send(message);
MongoTemplate template = new MongoTemplate(mongoDbFactory);
assertNotNull(template.find(new BasicQuery("{'name' : 'Bob'}"), Person.class, "foo"));
assertThat(template.find(new BasicQuery("{'name' : 'Bob'}"), Person.class, "foo")).isNotNull();
context.close();
}
@@ -114,7 +114,7 @@ public class MongoDbOutboundChannelAdapterIntegrationTests extends MongoDbAvaila
channel.send(message);
MongoTemplate template = new MongoTemplate(mongoDbFactory);
assertNotNull(template.find(new BasicQuery("{'foo' : 'bar'}"), BasicDBObject.class, "foo"));
assertThat(template.find(new BasicQuery("{'foo' : 'bar'}"), BasicDBObject.class, "foo")).isNotNull();
context.close();
}
@@ -138,7 +138,7 @@ public class MongoDbOutboundChannelAdapterIntegrationTests extends MongoDbAvaila
channel.send(message);
MongoTemplate template = new MongoTemplate(mongoDbFactory);
assertNotNull(template.find(new BasicQuery("{'foo' : 'bar'}"), BasicDBObject.class, "foo"));
assertThat(template.find(new BasicQuery("{'foo' : 'bar'}"), BasicDBObject.class, "foo")).isNotNull();
context.close();
}
@@ -154,7 +154,7 @@ public class MongoDbOutboundChannelAdapterIntegrationTests extends MongoDbAvaila
MongoDbFactory mongoDbFactory = this.prepareMongoFactory();
MongoTemplate template = new MongoTemplate(mongoDbFactory);
assertNotNull(template.find(new BasicQuery("{'name' : 'Bob'}"), Person.class, "data"));
assertThat(template.find(new BasicQuery("{'name' : 'Bob'}"), Person.class, "data")).isNotNull();
context.close();
}

75
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/config/MongoDbOutboundChannelAdapterParserTests.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,14 +16,10 @@
package org.springframework.integration.mongodb.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.springframework.aop.support.AopUtils;
@@ -50,13 +46,14 @@ public class MongoDbOutboundChannelAdapterParserTests {
new ClassPathXmlApplicationContext("outbound-adapter-parser-config.xml", this.getClass());
MongoDbStoringMessageHandler handler =
TestUtils.getPropertyValue(context.getBean("minimalConfig.adapter"), "handler", MongoDbStoringMessageHandler.class);
assertEquals("minimalConfig.adapter", TestUtils.getPropertyValue(handler, "componentName"));
assertEquals(false, TestUtils.getPropertyValue(handler, "shouldTrack"));
assertNotNull(TestUtils.getPropertyValue(handler, "mongoTemplate"));
assertEquals(context.getBean("mongoDbFactory"), TestUtils.getPropertyValue(handler, "mongoDbFactory"));
assertNotNull(TestUtils.getPropertyValue(handler, "evaluationContext"));
assertTrue(TestUtils.getPropertyValue(handler, "collectionNameExpression") instanceof LiteralExpression);
assertEquals("data", TestUtils.getPropertyValue(handler, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(handler, "componentName")).isEqualTo("minimalConfig.adapter");
assertThat(TestUtils.getPropertyValue(handler, "shouldTrack")).isEqualTo(false);
assertThat(TestUtils.getPropertyValue(handler, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(handler, "mongoDbFactory")).isEqualTo(context.getBean("mongoDbFactory"));
assertThat(TestUtils.getPropertyValue(handler, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(handler, "collectionNameExpression") instanceof LiteralExpression)
.isTrue();
assertThat(TestUtils.getPropertyValue(handler, "collectionNameExpression.literalValue")).isEqualTo("data");
context.close();
}
@@ -66,13 +63,15 @@ public class MongoDbOutboundChannelAdapterParserTests {
new ClassPathXmlApplicationContext("outbound-adapter-parser-config.xml", this.getClass());
MongoDbStoringMessageHandler handler =
TestUtils.getPropertyValue(context.getBean("fullConfigWithCollectionExpression.adapter"), "handler", MongoDbStoringMessageHandler.class);
assertEquals("fullConfigWithCollectionExpression.adapter", TestUtils.getPropertyValue(handler, "componentName"));
assertEquals(false, TestUtils.getPropertyValue(handler, "shouldTrack"));
assertNotNull(TestUtils.getPropertyValue(handler, "mongoTemplate"));
assertEquals(context.getBean("mongoDbFactory"), TestUtils.getPropertyValue(handler, "mongoDbFactory"));
assertNotNull(TestUtils.getPropertyValue(handler, "evaluationContext"));
assertTrue(TestUtils.getPropertyValue(handler, "collectionNameExpression") instanceof SpelExpression);
assertEquals("headers.collectionName", TestUtils.getPropertyValue(handler, "collectionNameExpression.expression"));
assertThat(TestUtils.getPropertyValue(handler, "componentName"))
.isEqualTo("fullConfigWithCollectionExpression.adapter");
assertThat(TestUtils.getPropertyValue(handler, "shouldTrack")).isEqualTo(false);
assertThat(TestUtils.getPropertyValue(handler, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(handler, "mongoDbFactory")).isEqualTo(context.getBean("mongoDbFactory"));
assertThat(TestUtils.getPropertyValue(handler, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(handler, "collectionNameExpression") instanceof SpelExpression).isTrue();
assertThat(TestUtils.getPropertyValue(handler, "collectionNameExpression.expression"))
.isEqualTo("headers.collectionName");
context.close();
}
@@ -82,13 +81,14 @@ public class MongoDbOutboundChannelAdapterParserTests {
new ClassPathXmlApplicationContext("outbound-adapter-parser-config.xml", this.getClass());
MongoDbStoringMessageHandler handler =
TestUtils.getPropertyValue(context.getBean("fullConfigWithCollection.adapter"), "handler", MongoDbStoringMessageHandler.class);
assertEquals("fullConfigWithCollection.adapter", TestUtils.getPropertyValue(handler, "componentName"));
assertEquals(false, TestUtils.getPropertyValue(handler, "shouldTrack"));
assertNotNull(TestUtils.getPropertyValue(handler, "mongoTemplate"));
assertEquals(context.getBean("mongoDbFactory"), TestUtils.getPropertyValue(handler, "mongoDbFactory"));
assertNotNull(TestUtils.getPropertyValue(handler, "evaluationContext"));
assertTrue(TestUtils.getPropertyValue(handler, "collectionNameExpression") instanceof LiteralExpression);
assertEquals("foo", TestUtils.getPropertyValue(handler, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(handler, "componentName")).isEqualTo("fullConfigWithCollection.adapter");
assertThat(TestUtils.getPropertyValue(handler, "shouldTrack")).isEqualTo(false);
assertThat(TestUtils.getPropertyValue(handler, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(handler, "mongoDbFactory")).isEqualTo(context.getBean("mongoDbFactory"));
assertThat(TestUtils.getPropertyValue(handler, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(handler, "collectionNameExpression") instanceof LiteralExpression)
.isTrue();
assertThat(TestUtils.getPropertyValue(handler, "collectionNameExpression.literalValue")).isEqualTo("foo");
context.close();
}
@@ -98,12 +98,14 @@ public class MongoDbOutboundChannelAdapterParserTests {
new ClassPathXmlApplicationContext("outbound-adapter-parser-config.xml", this.getClass());
MongoDbStoringMessageHandler handler =
TestUtils.getPropertyValue(context.getBean("fullConfigWithMongoTemplate.adapter"), "handler", MongoDbStoringMessageHandler.class);
assertEquals("fullConfigWithMongoTemplate.adapter", TestUtils.getPropertyValue(handler, "componentName"));
assertEquals(false, TestUtils.getPropertyValue(handler, "shouldTrack"));
assertNotNull(TestUtils.getPropertyValue(handler, "mongoTemplate"));
assertNotNull(TestUtils.getPropertyValue(handler, "evaluationContext"));
assertTrue(TestUtils.getPropertyValue(handler, "collectionNameExpression") instanceof LiteralExpression);
assertEquals("foo", TestUtils.getPropertyValue(handler, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(handler, "componentName"))
.isEqualTo("fullConfigWithMongoTemplate.adapter");
assertThat(TestUtils.getPropertyValue(handler, "shouldTrack")).isEqualTo(false);
assertThat(TestUtils.getPropertyValue(handler, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(handler, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(handler, "collectionNameExpression") instanceof LiteralExpression)
.isTrue();
assertThat(TestUtils.getPropertyValue(handler, "collectionNameExpression.literalValue")).isEqualTo("foo");
context.close();
}
@@ -124,12 +126,11 @@ public class MongoDbOutboundChannelAdapterParserTests {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
"outbound-adapter-parser-config.xml", this.getClass());
AbstractEndpoint endpoint = context.getBean("pollableAdapter", AbstractEndpoint.class);
assertThat(endpoint, Matchers.instanceOf(PollingConsumer.class));
assertThat(endpoint).isInstanceOf(PollingConsumer.class);
MessageHandler handler = TestUtils.getPropertyValue(endpoint, "handler", MessageHandler.class);
assertTrue(AopUtils.isAopProxy(handler));
assertThat(AopUtils.isAopProxy(handler)).isTrue();
List<?> advisors = TestUtils.getPropertyValue(handler, "h.advised.advisors", List.class);
assertThat(TestUtils.getPropertyValue(advisors.get(0), "advice"),
Matchers.instanceOf(RequestHandlerRetryAdvice.class));
assertThat(TestUtils.getPropertyValue(advisors.get(0), "advice")).isInstanceOf(RequestHandlerRetryAdvice.class);
context.close();
}

89
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/config/MongoDbOutboundGatewayParserTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016-2018 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,16 +16,10 @@
package org.springframework.integration.mongodb.config;
import static org.hamcrest.Matchers.instanceOf;
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.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -49,7 +43,7 @@ import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
/**
* @author Xavier Padró
* @author Xavier Padr?
* @author Artem Bilan
*
* @since 5.0
@@ -74,17 +68,17 @@ public class MongoDbOutboundGatewayParserTests {
MongoDbOutboundGateway gateway =
TestUtils.getPropertyValue(endpoint, "handler", MongoDbOutboundGateway.class);
assertNotNull(TestUtils.getPropertyValue(gateway, "mongoTemplate"));
assertSame(this.mongoDbFactory, TestUtils.getPropertyValue(gateway, "mongoDbFactory"));
assertNotNull(TestUtils.getPropertyValue(gateway, "evaluationContext"));
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"),
instanceOf(LiteralExpression.class));
assertEquals("foo", TestUtils.getPropertyValue(gateway, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(gateway, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(gateway, "mongoDbFactory")).isSameAs(this.mongoDbFactory);
assertThat(TestUtils.getPropertyValue(gateway, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"))
.isInstanceOf(LiteralExpression.class);
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression.literalValue")).isEqualTo("foo");
assertThat(endpoint, Matchers.instanceOf(PollingConsumer.class));
assertThat(endpoint).isInstanceOf(PollingConsumer.class);
MessageHandler handler = TestUtils.getPropertyValue(endpoint, "handler", MessageHandler.class);
List<?> advices = TestUtils.getPropertyValue(handler, "adviceChain", List.class);
assertThat(advices.get(0), Matchers.instanceOf(RequestHandlerRetryAdvice.class));
assertThat(advices.get(0)).isInstanceOf(RequestHandlerRetryAdvice.class);
}
@Test
@@ -92,14 +86,13 @@ public class MongoDbOutboundGatewayParserTests {
MongoDbOutboundGateway gateway = TestUtils.getPropertyValue(
context.getBean("fullConfigWithCollectionExpression"), "handler", MongoDbOutboundGateway.class);
assertNotNull(TestUtils.getPropertyValue(gateway, "mongoTemplate"));
assertSame(this.mongoDbFactory, TestUtils.getPropertyValue(gateway, "mongoDbFactory"));
assertSame(this.mongoConverter, TestUtils.getPropertyValue(gateway, "mongoConverter"));
assertNotNull(TestUtils.getPropertyValue(gateway, "evaluationContext"));
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"),
instanceOf(SpelExpression.class));
assertEquals("headers.collectionName",
TestUtils.getPropertyValue(gateway, "collectionNameExpression.expression"));
assertThat(TestUtils.getPropertyValue(gateway, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(gateway, "mongoDbFactory")).isSameAs(this.mongoDbFactory);
assertThat(TestUtils.getPropertyValue(gateway, "mongoConverter")).isSameAs(this.mongoConverter);
assertThat(TestUtils.getPropertyValue(gateway, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression")).isInstanceOf(SpelExpression.class);
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression.expression"))
.isEqualTo("headers.collectionName");
}
@Test
@@ -107,13 +100,13 @@ public class MongoDbOutboundGatewayParserTests {
MongoDbOutboundGateway gateway = TestUtils.getPropertyValue(
context.getBean("fullConfigWithCollection"), "handler", MongoDbOutboundGateway.class);
assertNotNull(TestUtils.getPropertyValue(gateway, "mongoTemplate"));
assertSame(this.mongoDbFactory, TestUtils.getPropertyValue(gateway, "mongoDbFactory"));
assertSame(this.mongoConverter, TestUtils.getPropertyValue(gateway, "mongoConverter"));
assertNotNull(TestUtils.getPropertyValue(gateway, "evaluationContext"));
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"),
instanceOf(LiteralExpression.class));
assertEquals("foo", TestUtils.getPropertyValue(gateway, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(gateway, "mongoTemplate")).isNotNull();
assertThat(TestUtils.getPropertyValue(gateway, "mongoDbFactory")).isSameAs(this.mongoDbFactory);
assertThat(TestUtils.getPropertyValue(gateway, "mongoConverter")).isSameAs(this.mongoConverter);
assertThat(TestUtils.getPropertyValue(gateway, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"))
.isInstanceOf(LiteralExpression.class);
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression.literalValue")).isEqualTo("foo");
}
@Test
@@ -121,13 +114,13 @@ public class MongoDbOutboundGatewayParserTests {
MongoDbOutboundGateway gateway = TestUtils.getPropertyValue(
context.getBean("fullConfigWithTemplate"), "handler", MongoDbOutboundGateway.class);
assertSame(context.getBean("mongoDbTemplate"), TestUtils.getPropertyValue(gateway, "mongoTemplate"));
assertNull(TestUtils.getPropertyValue(gateway, "mongoDbFactory"));
assertNull(TestUtils.getPropertyValue(gateway, "mongoConverter"));
assertNotNull(TestUtils.getPropertyValue(gateway, "evaluationContext"));
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"),
instanceOf(LiteralExpression.class));
assertEquals("foo", TestUtils.getPropertyValue(gateway, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(gateway, "mongoTemplate")).isSameAs(context.getBean("mongoDbTemplate"));
assertThat(TestUtils.getPropertyValue(gateway, "mongoDbFactory")).isNull();
assertThat(TestUtils.getPropertyValue(gateway, "mongoConverter")).isNull();
assertThat(TestUtils.getPropertyValue(gateway, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"))
.isInstanceOf(LiteralExpression.class);
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression.literalValue")).isEqualTo("foo");
}
@Test
@@ -135,15 +128,15 @@ public class MongoDbOutboundGatewayParserTests {
MongoDbOutboundGateway gateway = TestUtils.getPropertyValue(
context.getBean("fullConfigWithMongoDbCollectionCallback"), "handler", MongoDbOutboundGateway.class);
assertSame(context.getBean("mongoDbTemplate"), TestUtils.getPropertyValue(gateway, "mongoTemplate"));
assertNull(TestUtils.getPropertyValue(gateway, "mongoDbFactory"));
assertNull(TestUtils.getPropertyValue(gateway, "mongoConverter"));
assertNotNull(TestUtils.getPropertyValue(gateway, "evaluationContext"));
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"),
instanceOf(LiteralExpression.class));
assertEquals("foo", TestUtils.getPropertyValue(gateway, "collectionNameExpression.literalValue"));
assertThat(TestUtils.getPropertyValue(gateway, "collectionCallback"),
instanceOf(MessageCollectionCallback.class));
assertThat(TestUtils.getPropertyValue(gateway, "mongoTemplate")).isSameAs(context.getBean("mongoDbTemplate"));
assertThat(TestUtils.getPropertyValue(gateway, "mongoDbFactory")).isNull();
assertThat(TestUtils.getPropertyValue(gateway, "mongoConverter")).isNull();
assertThat(TestUtils.getPropertyValue(gateway, "evaluationContext")).isNotNull();
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression"))
.isInstanceOf(LiteralExpression.class);
assertThat(TestUtils.getPropertyValue(gateway, "collectionNameExpression.literalValue")).isEqualTo("foo");
assertThat(TestUtils.getPropertyValue(gateway, "collectionCallback"))
.isInstanceOf(MessageCollectionCallback.class);
}
@Test(expected = BeanDefinitionParsingException.class)

39
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/dsl/MongoDbTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016-2018 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,8 +16,7 @@
package org.springframework.integration.mongodb.dsl;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.List;
@@ -57,7 +56,7 @@ import org.springframework.test.context.junit4.SpringRunner;
import com.mongodb.MongoClient;
/**
* @author Xavier Padró
* @author Xavier Padr?
* @author Gary Russell
* @author Artem Bilan
*
@@ -127,9 +126,9 @@ public class MongoDbTests extends MongoDbAvailableTests {
Message<?> result = this.getResultChannel.receive(10_000);
assertNotNull(result);
assertThat(result).isNotNull();
Person retrievedPerson = (Person) result.getPayload();
assertEquals("Xavi", retrievedPerson.getName());
assertThat(retrievedPerson.getName()).isEqualTo("Xavi");
}
@Test
@@ -139,9 +138,9 @@ public class MongoDbTests extends MongoDbAvailableTests {
Message<?> result = this.getResultChannel.receive(10_000);
assertNotNull(result);
assertThat(result).isNotNull();
Person retrievedPerson = (Person) result.getPayload();
assertEquals("Xavi", retrievedPerson.getName());
assertThat(retrievedPerson.getName()).isEqualTo("Xavi");
}
@Test
@@ -154,9 +153,9 @@ public class MongoDbTests extends MongoDbAvailableTests {
Message<?> result = this.getResultChannel.receive(10_000);
assertNotNull(result);
assertThat(result).isNotNull();
Person retrievedPerson = (Person) result.getPayload();
assertEquals("Artem", retrievedPerson.getName());
assertThat(retrievedPerson.getName()).isEqualTo("Artem");
}
@Test(expected = ReplyRequiredException.class)
@@ -180,9 +179,9 @@ public class MongoDbTests extends MongoDbAvailableTests {
Message<?> result = this.getResultChannel.receive(10_000);
assertNotNull(result);
assertThat(result).isNotNull();
List<Person> retrievedPersons = getPersons(result);
assertEquals(4, retrievedPersons.size());
assertThat(retrievedPersons.size()).isEqualTo(4);
}
@Test
@@ -195,9 +194,9 @@ public class MongoDbTests extends MongoDbAvailableTests {
Message<?> result = this.getResultChannel.receive(10_000);
assertNotNull(result);
assertThat(result).isNotNull();
List<Person> retrievedPersons = getPersons(result);
assertEquals(2, retrievedPersons.size());
assertThat(retrievedPersons.size()).isEqualTo(2);
}
@Test
@@ -210,9 +209,9 @@ public class MongoDbTests extends MongoDbAvailableTests {
Message<?> result = this.getResultChannel.receive(10_000);
assertNotNull(result);
assertThat(result).isNotNull();
Person person = (Person) result.getPayload();
assertEquals("Gary", person.getName());
assertThat(person.getName()).isEqualTo("Gary");
}
@Test
@@ -225,9 +224,9 @@ public class MongoDbTests extends MongoDbAvailableTests {
Message<?> result = this.getResultChannel.receive(10_000);
assertNotNull(result);
assertThat(result).isNotNull();
Person person = (Person) result.getPayload();
assertEquals("Gary", person.getName());
assertThat(person.getName()).isEqualTo("Gary");
}
@Test
@@ -239,9 +238,9 @@ public class MongoDbTests extends MongoDbAvailableTests {
Message<?> result = this.getResultChannel.receive(10_000);
assertNotNull(result);
assertThat(result).isNotNull();
long count = (Long) result.getPayload();
assertEquals(4, count);
assertThat(count).isEqualTo(4);
}
@SuppressWarnings("unchecked")

37
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/inbound/MongoDbMessageSourceTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2007-2017 the original author or authors.
* Copyright 2007-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.mongodb.inbound;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
@@ -92,10 +91,10 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
messageSource.afterPropertiesSet();
@SuppressWarnings("unchecked")
List<Document> results = ((List<Document>) messageSource.receive().getPayload());
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
Document resultObject = results.get(0);
assertEquals("Oleg", resultObject.get("name"));
assertThat(resultObject.get("name")).isEqualTo("Oleg");
}
@Test
@@ -114,10 +113,10 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
messageSource.afterPropertiesSet();
@SuppressWarnings("unchecked")
List<Person> results = ((List<Person>) messageSource.receive().getPayload());
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
Person person = results.get(0);
assertEquals("Oleg", person.getName());
assertEquals("PA", person.getAddress().getState());
assertThat(person.getName()).isEqualTo("Oleg");
assertThat(person.getAddress().getState()).isEqualTo("PA");
}
@Test
@@ -137,8 +136,8 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
messageSource.afterPropertiesSet();
Person person = (Person) messageSource.receive().getPayload();
assertEquals("Oleg", person.getName());
assertEquals("PA", person.getAddress().getState());
assertThat(person.getName()).isEqualTo("Oleg");
assertThat(person.getAddress().getState()).isEqualTo("PA");
}
@@ -159,15 +158,15 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
@SuppressWarnings("unchecked")
List<Person> results = ((List<Person>) messageSource.receive().getPayload());
Person person = results.get(0);
assertEquals("Oleg", person.getName());
assertEquals("PA", person.getAddress().getState());
assertThat(person.getName()).isEqualTo("Oleg");
assertThat(person.getAddress().getState()).isEqualTo("PA");
}
@Test
@MongoDbAvailable
public void validateSuccessfulQueryWithMultipleElements() throws Exception {
List<Person> persons = queryMultipleElements(new LiteralExpression("{'address.state' : 'PA'}"));
assertEquals(3, persons.size());
assertThat(persons.size()).isEqualTo(3);
}
@Test
@@ -175,7 +174,7 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
public void validateSuccessfulStringQueryExpressionWithMultipleElements() throws Exception {
List<Person> persons = queryMultipleElements(new SpelExpressionParser()
.parseExpression("\"{'address.state' : 'PA'}\""));
assertEquals(3, persons.size());
assertThat(persons.size()).isEqualTo(3);
}
@Test
@@ -183,7 +182,7 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
public void validateSuccessfulBasicQueryExpressionWithMultipleElements() throws Exception {
List<Person> persons = queryMultipleElements(new SpelExpressionParser()
.parseExpression("new BasicQuery(\"{'address.state' : 'PA'}\").limit(2)"));
assertEquals(2, persons.size());
assertThat(persons.size()).isEqualTo(2);
}
@SuppressWarnings("unchecked")
@@ -217,7 +216,7 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
MongoDbMessageSource messageSource = new MongoDbMessageSource(mongoDbFactory, queryExpression);
messageSource.setBeanFactory(mock(BeanFactory.class));
messageSource.afterPropertiesSet();
assertNull(messageSource.receive());
assertThat(messageSource.receive()).isNull();
}
@SuppressWarnings("unchecked")
@@ -242,7 +241,7 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
messageSource.afterPropertiesSet();
List<Person> persons = (List<Person>) messageSource.receive().getPayload();
assertEquals(3, persons.size());
assertThat(persons.size()).isEqualTo(3);
verify(converter, times(3)).read((Class<Person>) Mockito.any(), Mockito.any(Bson.class));
}
@@ -269,7 +268,7 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
writingTemplate.save(this.createPerson("Jack"), "data");
List<Person> persons = (List<Person>) messageSource.receive().getPayload();
assertEquals(3, persons.size());
assertThat(persons.size()).isEqualTo(3);
verify(converter, times(3)).read((Class<Person>) Mockito.any(), Mockito.any(Bson.class));
}
@@ -293,7 +292,7 @@ public class MongoDbMessageSourceTests extends MongoDbAvailableTests {
result.put("company", "PepBoys");
template.save(result, "data");
result = (Document) messageSource.receive().getPayload();
assertEquals(id, result.get("_id"));
assertThat(result.get("_id")).isEqualTo(id);
}
}

46
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/metadata/MongoDbMetadataStoreTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2018 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,11 +16,7 @@
package org.springframework.integration.mongodb.metadata;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
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 org.junit.Before;
import org.junit.Test;
@@ -82,13 +78,13 @@ public class MongoDbMetadataStoreTests extends MongoDbAvailableTests {
private void testBasics() {
String fileID = store.get(file1);
assertNull(fileID);
assertThat(fileID).isNull();
store.put(file1, file1Id);
fileID = store.get(file1);
assertNotNull(fileID);
assertEquals(file1Id, fileID);
assertThat(fileID).isNotNull();
assertThat(fileID).isEqualTo(file1Id);
}
@Test
@@ -101,16 +97,16 @@ public class MongoDbMetadataStoreTests extends MongoDbAvailableTests {
@MongoDbAvailable
public void testPutIfAbsent() {
String fileID = store.get(file1);
assertNull("Get First time, Value must not exist", fileID);
assertThat(fileID).as("Get First time, Value must not exist").isNull();
fileID = store.putIfAbsent(file1, file1Id);
assertNull("Insert First time, Value must return null", fileID);
assertThat(fileID).as("Insert First time, Value must return null").isNull();
fileID = store.putIfAbsent(file1, "56789");
assertNotNull("Key Already Exists - Insertion Failed, ol value must be returned", fileID);
assertEquals("The Old Value must be equal to returned", file1Id, fileID);
assertThat(fileID).as("Key Already Exists - Insertion Failed, ol value must be returned").isNotNull();
assertThat(fileID).as("The Old Value must be equal to returned").isEqualTo(file1Id);
assertEquals("The Old Value must return", file1Id, store.get(file1));
assertThat(store.get(file1)).as("The Old Value must return").isEqualTo(file1Id);
}
@@ -118,36 +114,36 @@ public class MongoDbMetadataStoreTests extends MongoDbAvailableTests {
@MongoDbAvailable
public void testRemove() {
String fileID = store.remove(file1);
assertNull(fileID);
assertThat(fileID).isNull();
fileID = store.putIfAbsent(file1, file1Id);
assertNull(fileID);
assertThat(fileID).isNull();
fileID = store.remove(file1);
assertNotNull(fileID);
assertEquals(file1Id, fileID);
assertThat(fileID).isNotNull();
assertThat(fileID).isEqualTo(file1Id);
fileID = store.get(file1);
assertNull(fileID);
assertThat(fileID).isNull();
}
@Test
@MongoDbAvailable
public void testReplace() {
boolean removedValue = store.replace(file1, file1Id, "4567");
assertFalse(removedValue);
assertThat(removedValue).isFalse();
String fileID = store.get(file1);
assertNull(fileID);
assertThat(fileID).isNull();
fileID = store.putIfAbsent(file1, file1Id);
assertNull(fileID);
assertThat(fileID).isNull();
removedValue = store.replace(file1, file1Id, "4567");
assertTrue(removedValue);
assertThat(removedValue).isTrue();
fileID = store.get(file1);
assertNotNull(fileID);
assertEquals("4567", fileID);
assertThat(fileID).isNotNull();
assertThat(fileID).isEqualTo("4567");
}
}

59
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/outbound/MongoDbOutboundGatewayTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016-2018 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,10 +16,8 @@
package org.springframework.integration.mongodb.outbound;
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 static org.assertj.core.api.Assertions.fail;
import java.util.Arrays;
import java.util.List;
@@ -27,7 +25,6 @@ import java.util.function.Function;
import org.bson.Document;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -53,7 +50,7 @@ import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit4.SpringRunner;
/**
* @author Xavier Padró
* @author Xavier Padr?
* @author Gary Rssell
* @author Artem Bilan
*
@@ -101,10 +98,10 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
try {
new MongoDbOutboundGateway((MongoDbFactory) null);
Assert.fail("Expected the test case to throw an IllegalArgumentException");
fail("Expected the test case to throw an IllegalArgumentException");
}
catch (IllegalArgumentException e) {
assertEquals("MongoDbFactory translator must not be null!", e.getMessage());
assertThat(e.getMessage()).isEqualTo("MongoDbFactory translator must not be null!");
}
}
@@ -113,10 +110,10 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
public void testNoTemplateSpecified() {
try {
new MongoDbOutboundGateway((MongoTemplate) null);
Assert.fail("Expected the test case to throw an IllegalArgumentException");
fail("Expected the test case to throw an IllegalArgumentException");
}
catch (IllegalArgumentException e) {
assertEquals("mongoTemplate must not be null.", e.getMessage());
assertThat(e.getMessage()).isEqualTo("mongoTemplate must not be null.");
}
}
@@ -129,10 +126,10 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
try {
gateway.afterPropertiesSet();
gateway.handleRequestMessage(message);
Assert.fail("Expected the test case to throw an IllegalArgumentException");
fail("Expected the test case to throw an IllegalArgumentException");
}
catch (IllegalStateException e) {
assertEquals("no query or collectionCallback is specified", e.getMessage());
assertThat(e.getMessage()).isEqualTo("no query or collectionCallback is specified");
}
}
@@ -148,7 +145,7 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
Object result = gateway.handleRequestMessage(message);
List<Person> persons = getPersonsFromResult(result);
assertEquals(2, persons.size());
assertThat(persons.size()).isEqualTo(2);
}
@Test
@@ -168,7 +165,7 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
Person person = (Person) result;
assertEquals("Xavi", person.getName());
assertThat(person.getName()).isEqualTo("Xavi");
}
@Test
@@ -179,10 +176,10 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
gateway.setMongoConverter(mongoConverter);
try {
gateway.afterPropertiesSet();
Assert.fail("Expected the test case to throw an IllegalStateException");
fail("Expected the test case to throw an IllegalStateException");
}
catch (IllegalStateException e) {
assertEquals("no query or collectionCallback is specified", e.getMessage());
assertThat(e.getMessage()).isEqualTo("no query or collectionCallback is specified");
}
}
@@ -198,7 +195,7 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
Object result = gateway.handleRequestMessage(message);
List<Person> persons = getPersonsFromResult(result);
assertEquals(4, persons.size());
assertThat(persons.size()).isEqualTo(4);
}
@Test
@@ -213,8 +210,8 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
Object result = gateway.handleRequestMessage(message);
List<Person> persons = getPersonsFromResult(result);
assertEquals(1, persons.size());
assertEquals("Xavi", persons.get(0).getName());
assertThat(persons.size()).isEqualTo(1);
assertThat(persons.get(0).getName()).isEqualTo("Xavi");
}
@Test
@@ -230,7 +227,7 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
Object result = gateway.handleRequestMessage(message);
Person person = (Person) result;
assertEquals("Artem", person.getName());
assertThat(person.getName()).isEqualTo("Artem");
}
@Test
@@ -246,7 +243,7 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
Object result = gateway.handleRequestMessage(message);
Person person = (Person) result;
assertEquals("Gary", person.getName());
assertThat(person.getName()).isEqualTo("Gary");
}
@Test
@@ -261,7 +258,7 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
Object result = gateway.handleRequestMessage(message);
Document person = (Document) result;
assertEquals("Xavi", person.get("name"));
assertThat(person.get("name")).isEqualTo("Xavi");
}
@Test
@@ -274,10 +271,10 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
try {
gateway.afterPropertiesSet();
Assert.fail("Expected the test case to throw an IllegalArgumentException");
fail("Expected the test case to throw an IllegalArgumentException");
}
catch (IllegalStateException e) {
assertEquals("no collection name specified", e.getMessage());
assertThat(e.getMessage()).isEqualTo("no collection name specified");
}
}
@@ -293,11 +290,11 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
Object result = gateway.handleRequestMessage(message);
assertNull(result);
assertThat(result).isNull();
LiteralExpression collectionNameExpression =
(LiteralExpression) TestUtils.getPropertyValue(gateway, "collectionNameExpression");
assertNotNull(collectionNameExpression);
assertEquals("anotherCollection", collectionNameExpression.getValue());
assertThat(collectionNameExpression).isNotNull();
assertThat(collectionNameExpression.getValue()).isEqualTo("anotherCollection");
}
@Test
@@ -313,7 +310,7 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
long result = (long) gateway.handleRequestMessage(message);
assertEquals(4, result);
assertThat(result).isEqualTo(4);
}
@Test
@@ -334,8 +331,8 @@ public class MongoDbOutboundGatewayTests extends MongoDbAvailableTests {
gateway.handleRequestMessage(message);
List<Person> persons = this.mongoTemplate.find(new Query(), Person.class, COLLECTION_NAME);
assertEquals(5, persons.size());
assertTrue(persons.stream().anyMatch(p -> p.getName().equals("Mike")));
assertThat(persons.size()).isEqualTo(5);
assertThat(persons.stream().anyMatch(p -> p.getName().equals("Mike"))).isTrue();
}
@SuppressWarnings("unchecked")

18
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/outbound/MongoDbOutboundGatewayXmlTests.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,7 +16,7 @@
package org.springframework.integration.mongodb.outbound;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
@@ -39,7 +39,7 @@ import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit4.SpringRunner;
/**
* @author Xavier Padró
* @author Xavier Padr?
* @since 5.0
*/
@RunWith(SpringRunner.class)
@@ -82,7 +82,7 @@ public class MongoDbOutboundGatewayXmlTests extends MongoDbAvailableTests {
Message<?> result = outChannel.receive(10000);
Person person = getPerson(result);
assertEquals("Xavi", person.getName());
assertThat(person.getName()).isEqualTo("Xavi");
}
@Test
@@ -96,7 +96,7 @@ public class MongoDbOutboundGatewayXmlTests extends MongoDbAvailableTests {
Message<?> result = outChannel.receive(10000);
Person person = getPerson(result);
assertEquals("Xavi", person.getName());
assertThat(person.getName()).isEqualTo("Xavi");
}
@Test
@@ -115,7 +115,7 @@ public class MongoDbOutboundGatewayXmlTests extends MongoDbAvailableTests {
Message<?> result = outChannel.receive(10000);
Person person = getPerson(result);
assertEquals("Gary", person.getName());
assertThat(person.getName()).isEqualTo("Gary");
}
@Test
@@ -134,7 +134,7 @@ public class MongoDbOutboundGatewayXmlTests extends MongoDbAvailableTests {
Message<?> result = outChannel.receive(10000);
List<Person> persons = getPersons(result);
assertEquals(4, persons.size());
assertThat(persons.size()).isEqualTo(4);
}
@Test
@@ -152,7 +152,7 @@ public class MongoDbOutboundGatewayXmlTests extends MongoDbAvailableTests {
Message<?> result = outChannel.receive(10000);
List<Person> persons = getPersons(result);
assertEquals(2, persons.size());
assertThat(persons.size()).isEqualTo(2);
}
@Test
@@ -170,7 +170,7 @@ public class MongoDbOutboundGatewayXmlTests extends MongoDbAvailableTests {
Message<?> result = outChannel.receive(10000);
long personsCount = (Long) result.getPayload();
assertEquals(4, personsCount);
assertThat(personsCount).isEqualTo(4);
}
private Person getPerson(Message<?> message) {

20
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/outbound/MongoDbStoringMessageHandlerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2007-2017 the original author or authors.
* Copyright 2007-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,7 +16,7 @@
package org.springframework.integration.mongodb.outbound;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
@@ -75,8 +75,8 @@ public class MongoDbStoringMessageHandlerTests extends MongoDbAvailableTests {
Query query = new BasicQuery("{'name' : 'Bob'}");
Person person = template.findOne(query, Person.class, "data");
assertEquals("Bob", person.getName());
assertEquals("PA", person.getAddress().getState());
assertThat(person.getName()).isEqualTo("Bob");
assertThat(person.getAddress().getState()).isEqualTo("PA");
}
@Test
@@ -95,8 +95,8 @@ public class MongoDbStoringMessageHandlerTests extends MongoDbAvailableTests {
Query query = new BasicQuery("{'name' : 'Bob'}");
Person person = template.findOne(query, Person.class, "foo");
assertEquals("Bob", person.getName());
assertEquals("PA", person.getAddress().getState());
assertThat(person.getName()).isEqualTo("Bob");
assertThat(person.getAddress().getState()).isEqualTo("PA");
}
@Test
@@ -119,8 +119,8 @@ public class MongoDbStoringMessageHandlerTests extends MongoDbAvailableTests {
Query query = new BasicQuery("{'name' : 'Bob'}");
Person person = template.findOne(query, Person.class, "foo");
assertEquals("Bob", person.getName());
assertEquals("PA", person.getAddress().getState());
assertThat(person.getName()).isEqualTo("Bob");
assertThat(person.getAddress().getState()).isEqualTo("PA");
verify(converter, times(1)).write(Mockito.any(), Mockito.any(Bson.class));
}
@@ -145,8 +145,8 @@ public class MongoDbStoringMessageHandlerTests extends MongoDbAvailableTests {
Query query = new BasicQuery("{'name' : 'Bob'}");
Person person = readingTemplate.findOne(query, Person.class, "foo");
assertEquals("Bob", person.getName());
assertEquals("PA", person.getAddress().getState());
assertThat(person.getName()).isEqualTo("Bob");
assertThat(person.getAddress().getState()).isEqualTo("PA");
verify(converter, times(1)).write(Mockito.any(), Mockito.any(Bson.class));
}
}

210
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/store/AbstractMongoDbMessageGroupStoreTests.java
View File

@@ -16,13 +16,7 @@
package org.springframework.integration.mongodb.store;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
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.ArrayList;
import java.util.Collection;
@@ -82,9 +76,9 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
MessageGroupStore store = getMessageGroupStore();
store.addMessagesToGroup(1, new GenericMessage<Object>("foo"));
MessageGroup messageGroup = store.getMessageGroup(1);
assertNotNull(messageGroup);
assertThat(messageGroup.getClass().getName(), containsString("PersistentMessageGroup"));
assertEquals(1, messageGroup.size());
assertThat(messageGroup).isNotNull();
assertThat(messageGroup.getClass().getName()).contains("PersistentMessageGroup");
assertThat(messageGroup.size()).isEqualTo(1);
}
@Test
@@ -98,13 +92,13 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
Message<?> messageB = new GenericMessage<String>("B");
store.addMessagesToGroup(1, messageA);
messageGroup = store.addMessageToGroup(1, messageB);
assertNotNull(messageGroup);
assertEquals(2, messageGroup.size());
assertThat(messageGroup).isNotNull();
assertThat(messageGroup.size()).isEqualTo(2);
Message<?> retrievedMessage = messageStore.getMessage(messageA.getHeaders().getId());
assertNotNull(retrievedMessage);
assertEquals(retrievedMessage.getHeaders().getId(), messageA.getHeaders().getId());
assertThat(retrievedMessage).isNotNull();
assertThat(messageA.getHeaders().getId()).isEqualTo(retrievedMessage.getHeaders().getId());
// ensure that 'message_group' header that is only used internally is not propagated
assertNull(retrievedMessage.getHeaders().get("message_group"));
assertThat(retrievedMessage.getHeaders().get("message_group")).isNull();
}
@Test
@@ -121,16 +115,16 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
Message<?> messageB = MessageBuilder.withPayload("B").setHeader("foo", uuidB).build();
store.addMessagesToGroup(id, messageA);
messageGroup = store.addMessageToGroup(id, messageB);
assertNotNull(messageGroup);
assertEquals(2, messageGroup.size());
assertThat(messageGroup).isNotNull();
assertThat(messageGroup.size()).isEqualTo(2);
Message<?> retrievedMessage = messageStore.getMessage(messageA.getHeaders().getId());
assertNotNull(retrievedMessage);
assertEquals(retrievedMessage.getHeaders().getId(), messageA.getHeaders().getId());
assertThat(retrievedMessage).isNotNull();
assertThat(messageA.getHeaders().getId()).isEqualTo(retrievedMessage.getHeaders().getId());
// ensure that 'message_group' header that is only used internally is not propagated
assertNull(retrievedMessage.getHeaders().get("message_group"));
assertThat(retrievedMessage.getHeaders().get("message_group")).isNull();
Object fooHeader = retrievedMessage.getHeaders().get("foo");
assertTrue(fooHeader instanceof UUID);
assertEquals(uuidA, fooHeader);
assertThat(fooHeader instanceof UUID).isTrue();
assertThat(fooHeader).isEqualTo(uuidA);
}
@Test
@@ -141,7 +135,7 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
Message<?> messageA = new GenericMessage<String>("A");
Message<?> messageB = new GenericMessage<String>("B");
store.addMessagesToGroup(1, messageA, messageB);
assertEquals(2, store.messageGroupSize(1));
assertThat(store.messageGroupSize(1)).isEqualTo(2);
}
@Test
@@ -154,14 +148,14 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
store.addMessagesToGroup(1, messageA);
Thread.sleep(10);
store.addMessagesToGroup(1, messageB);
assertEquals(2, store.messageGroupSize(1));
assertThat(store.messageGroupSize(1)).isEqualTo(2);
Message<?> out = store.pollMessageFromGroup(1);
assertNotNull(out);
assertEquals("A", out.getPayload());
assertEquals(1, store.messageGroupSize(1));
assertThat(out).isNotNull();
assertThat(out.getPayload()).isEqualTo("A");
assertThat(store.messageGroupSize(1)).isEqualTo(1);
out = store.pollMessageFromGroup(1);
assertEquals("B", out.getPayload());
assertEquals(0, store.messageGroupSize(1));
assertThat(out.getPayload()).isEqualTo("B");
assertThat(store.messageGroupSize(1)).isEqualTo(0);
}
@Test
@@ -174,30 +168,30 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
store.addMessagesToGroup(2, messageA);
store.addMessagesToGroup(3, messageA);
store.addMessagesToGroup(4, messageA);
assertEquals(1, store.messageGroupSize(1));
assertEquals(1, store.messageGroupSize(2));
assertEquals(1, store.messageGroupSize(3));
assertEquals(1, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(1);
assertThat(store.messageGroupSize(2)).isEqualTo(1);
assertThat(store.messageGroupSize(3)).isEqualTo(1);
assertThat(store.messageGroupSize(4)).isEqualTo(1);
store.pollMessageFromGroup(3);
assertEquals(1, store.messageGroupSize(1));
assertEquals(1, store.messageGroupSize(2));
assertEquals(0, store.messageGroupSize(3));
assertEquals(1, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(1);
assertThat(store.messageGroupSize(2)).isEqualTo(1);
assertThat(store.messageGroupSize(3)).isEqualTo(0);
assertThat(store.messageGroupSize(4)).isEqualTo(1);
store.pollMessageFromGroup(4);
assertEquals(1, store.messageGroupSize(1));
assertEquals(1, store.messageGroupSize(2));
assertEquals(0, store.messageGroupSize(3));
assertEquals(0, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(1);
assertThat(store.messageGroupSize(2)).isEqualTo(1);
assertThat(store.messageGroupSize(3)).isEqualTo(0);
assertThat(store.messageGroupSize(4)).isEqualTo(0);
store.pollMessageFromGroup(2);
assertEquals(1, store.messageGroupSize(1));
assertEquals(0, store.messageGroupSize(2));
assertEquals(0, store.messageGroupSize(3));
assertEquals(0, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(1);
assertThat(store.messageGroupSize(2)).isEqualTo(0);
assertThat(store.messageGroupSize(3)).isEqualTo(0);
assertThat(store.messageGroupSize(4)).isEqualTo(0);
store.pollMessageFromGroup(1);
assertEquals(0, store.messageGroupSize(1));
assertEquals(0, store.messageGroupSize(2));
assertEquals(0, store.messageGroupSize(3));
assertEquals(0, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(0);
assertThat(store.messageGroupSize(2)).isEqualTo(0);
assertThat(store.messageGroupSize(3)).isEqualTo(0);
assertThat(store.messageGroupSize(4)).isEqualTo(0);
}
@Test
@@ -211,30 +205,30 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
store.addMessagesToGroup(2, messageA);
store.addMessagesToGroup(3, messageA);
store.addMessagesToGroup(4, messageA);
assertEquals(1, store.messageGroupSize(1));
assertEquals(1, store.messageGroupSize(2));
assertEquals(1, store.messageGroupSize(3));
assertEquals(1, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(1);
assertThat(store.messageGroupSize(2)).isEqualTo(1);
assertThat(store.messageGroupSize(3)).isEqualTo(1);
assertThat(store.messageGroupSize(4)).isEqualTo(1);
store.removeMessagesFromGroup(3, messageA);
assertEquals(1, store.messageGroupSize(1));
assertEquals(1, store.messageGroupSize(2));
assertEquals(0, store.messageGroupSize(3));
assertEquals(1, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(1);
assertThat(store.messageGroupSize(2)).isEqualTo(1);
assertThat(store.messageGroupSize(3)).isEqualTo(0);
assertThat(store.messageGroupSize(4)).isEqualTo(1);
store.removeMessagesFromGroup(4, messageA);
assertEquals(1, store.messageGroupSize(1));
assertEquals(1, store.messageGroupSize(2));
assertEquals(0, store.messageGroupSize(3));
assertEquals(0, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(1);
assertThat(store.messageGroupSize(2)).isEqualTo(1);
assertThat(store.messageGroupSize(3)).isEqualTo(0);
assertThat(store.messageGroupSize(4)).isEqualTo(0);
store.removeMessagesFromGroup(2, messageA);
assertEquals(1, store.messageGroupSize(1));
assertEquals(0, store.messageGroupSize(2));
assertEquals(0, store.messageGroupSize(3));
assertEquals(0, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(1);
assertThat(store.messageGroupSize(2)).isEqualTo(0);
assertThat(store.messageGroupSize(3)).isEqualTo(0);
assertThat(store.messageGroupSize(4)).isEqualTo(0);
store.removeMessagesFromGroup(1, messageA);
assertEquals(0, store.messageGroupSize(1));
assertEquals(0, store.messageGroupSize(2));
assertEquals(0, store.messageGroupSize(3));
assertEquals(0, store.messageGroupSize(4));
assertThat(store.messageGroupSize(1)).isEqualTo(0);
assertThat(store.messageGroupSize(2)).isEqualTo(0);
assertThat(store.messageGroupSize(3)).isEqualTo(0);
assertThat(store.messageGroupSize(4)).isEqualTo(0);
}
@Test
@@ -246,24 +240,24 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
MessageGroup messageGroup = store.getMessageGroup(1);
Message<?> message = new GenericMessage<String>("Hello");
messageGroup = store.addMessageToGroup(1, message);
assertNotNull(messageGroup);
assertEquals(1, messageGroup.size());
assertThat(messageGroup).isNotNull();
assertThat(messageGroup.size()).isEqualTo(1);
long createdTimestamp = messageGroup.getTimestamp();
long updatedTimestamp = messageGroup.getLastModified();
assertEquals(createdTimestamp, updatedTimestamp);
assertThat(updatedTimestamp).isEqualTo(createdTimestamp);
Thread.sleep(10);
message = new GenericMessage<String>("Hello again");
messageGroup = store.addMessageToGroup(1, message);
createdTimestamp = messageGroup.getTimestamp();
updatedTimestamp = messageGroup.getLastModified();
assertTrue(updatedTimestamp > createdTimestamp);
assertEquals(2, messageGroup.size());
assertThat(updatedTimestamp > createdTimestamp).isTrue();
assertThat(messageGroup.size()).isEqualTo(2);
// make sure the store is properly rebuild from MongoDB
store = this.getMessageGroupStore();
messageGroup = store.getMessageGroup(1);
assertEquals(2, messageGroup.size());
assertThat(messageGroup.size()).isEqualTo(2);
}
@Test
@@ -277,18 +271,18 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
Message<?> messageB = new GenericMessage<String>("B");
store.addMessagesToGroup(1, messageA);
messageGroup = store.addMessageToGroup(1, messageB);
assertNotNull(messageGroup);
assertEquals(2, messageGroup.size());
assertThat(messageGroup).isNotNull();
assertThat(messageGroup.size()).isEqualTo(2);
store.removeMessagesFromGroup(1, messageA);
messageGroup = store.getMessageGroup(1);
assertEquals(1, messageGroup.size());
assertThat(messageGroup.size()).isEqualTo(1);
// validate that the updates were propagated to Mongo as well
store = this.getMessageGroupStore();
messageGroup = store.getMessageGroup(1);
assertEquals(1, messageGroup.size());
assertThat(messageGroup.size()).isEqualTo(1);
}
@Test
@@ -302,15 +296,15 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
Message<?> message = new GenericMessage<String>("Hello");
UUID id = message.getHeaders().getId();
messageGroup = store.addMessageToGroup(1, message);
assertNotNull(messageGroup);
assertEquals(1, messageGroup.size());
assertThat(messageGroup).isNotNull();
assertThat(messageGroup.size()).isEqualTo(1);
message = messageStore.getMessage(id);
assertNotNull(message);
assertThat(message).isNotNull();
store.removeMessageGroup(1);
MessageGroup messageGroupA = store.getMessageGroup(1);
assertEquals(0, messageGroupA.size());
assertFalse(messageGroupA.equals(messageGroup));
assertThat(messageGroupA.size()).isEqualTo(0);
assertThat(messageGroupA.equals(messageGroup)).isFalse();
}
@@ -321,12 +315,12 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
MessageGroupStore store = this.getMessageGroupStore();
MessageGroup messageGroup = store.getMessageGroup(1);
assertNotNull(messageGroup);
assertThat(messageGroup).isNotNull();
Message<?> message = new GenericMessage<String>("Hello");
store.addMessagesToGroup(messageGroup.getGroupId(), message);
store.completeGroup(messageGroup.getGroupId());
messageGroup = store.getMessageGroup(1);
assertTrue(messageGroup.isComplete());
assertThat(messageGroup.isComplete()).isTrue();
}
@Test
@@ -336,12 +330,12 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
MessageGroupStore store = this.getMessageGroupStore();
MessageGroup messageGroup = store.getMessageGroup(1);
assertNotNull(messageGroup);
assertThat(messageGroup).isNotNull();
Message<?> message = new GenericMessage<String>("Hello");
store.addMessagesToGroup(messageGroup.getGroupId(), message);
store.setLastReleasedSequenceNumberForGroup(messageGroup.getGroupId(), 5);
messageGroup = store.getMessageGroup(1);
assertEquals(5, messageGroup.getLastReleasedMessageSequenceNumber());
assertThat(messageGroup.getLastReleasedMessageSequenceNumber()).isEqualTo(5);
}
@Test
@@ -354,12 +348,12 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
Message<?> message = new GenericMessage<String>("2");
store.addMessagesToGroup(1, new GenericMessage<String>("1"), message);
messageGroup = store.addMessageToGroup(1, new GenericMessage<String>("3"));
assertNotNull(messageGroup);
assertEquals(3, messageGroup.size());
assertThat(messageGroup).isNotNull();
assertThat(messageGroup.size()).isEqualTo(3);
store.removeMessagesFromGroup(1, message);
messageGroup = store.getMessageGroup(1);
assertEquals(2, messageGroup.size());
assertThat(messageGroup.size()).isEqualTo(2);
}
@Test
@@ -377,13 +371,13 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
MessageGroup messageGroup = store3.getMessageGroup(1);
assertNotNull(messageGroup);
assertEquals(3, messageGroup.size());
assertThat(messageGroup).isNotNull();
assertThat(messageGroup.size()).isEqualTo(3);
store3.removeMessagesFromGroup(1, message);
messageGroup = store2.getMessageGroup(1);
assertEquals(2, messageGroup.size());
assertThat(messageGroup.size()).isEqualTo(2);
}
@Test
@@ -400,13 +394,13 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
MessageGroupStore store3 = this.getMessageGroupStore();
Iterator<MessageGroup> iterator = store3.iterator();
assertNotNull(iterator);
assertThat(iterator).isNotNull();
int counter = 0;
while (iterator.hasNext()) {
iterator.next();
counter++;
}
assertEquals(3, counter);
assertThat(counter).isEqualTo(3);
store2.removeMessagesFromGroup("1", message);
@@ -416,7 +410,7 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
iterator.next();
counter++;
}
assertEquals(2, counter);
assertThat(counter).isEqualTo(2);
}
@Test
@@ -433,10 +427,10 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
messages.add(message);
}
MessageGroup group = messageStore.getMessageGroup(groupId);
assertEquals(25, group.size());
assertThat(group.size()).isEqualTo(25);
messageStore.removeMessagesFromGroup(groupId, messages);
group = messageStore.getMessageGroup(groupId);
assertEquals(0, group.size());
assertThat(group.size()).isEqualTo(0);
}
// @Test
@@ -502,9 +496,9 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
.setCorrelationId(1)
.build();
input.send(m1);
assertNull(output.receive(1000));
assertThat(output.receive(1000)).isNull();
input.send(m2);
assertNull(output.receive(1000));
assertThat(output.receive(1000)).isNull();
for (int i = 3; i < 10; i++) {
input.send(MessageBuilder.withPayload("" + i)
@@ -526,7 +520,7 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
.setCorrelationId(1)
.build();
input.send(m10);
assertNotNull(output.receive(2000));
assertThat(output.receive(2000)).isNotNull();
context.close();
}
@@ -548,17 +542,17 @@ public abstract class AbstractMongoDbMessageGroupStoreTests extends MongoDbAvail
message = MessageHistory.write(message, barChannel);
store.addMessagesToGroup(1, message);
MessageGroup group = store.getMessageGroup(1);
assertNotNull(group);
assertThat(group).isNotNull();
Collection<Message<?>> messages = group.getMessages();
assertTrue(!messages.isEmpty());
assertThat(!messages.isEmpty()).isTrue();
message = messages.iterator().next();
MessageHistory messageHistory = MessageHistory.read(message);
assertNotNull(messageHistory);
assertEquals(2, messageHistory.size());
assertThat(messageHistory).isNotNull();
assertThat(messageHistory.size()).isEqualTo(2);
Properties fooChannelHistory = messageHistory.get(0);
assertEquals("fooChannel", fooChannelHistory.get("name"));
assertEquals("channel", fooChannelHistory.get("type"));
assertThat(fooChannelHistory.get("name")).isEqualTo("fooChannel");
assertThat(fooChannelHistory.get("type")).isEqualTo("channel");
}
protected abstract MessageGroupStore getMessageGroupStore() throws Exception;

125
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/store/AbstractMongoDbMessageStoreTests.java
View File

@@ -16,19 +16,12 @@
package org.springframework.integration.mongodb.store;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.instanceOf;
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.io.Serializable;
import java.util.Properties;
import java.util.UUID;
import org.hamcrest.Matchers;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -83,10 +76,10 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<?> messageToStore = MessageBuilder.withPayload("Hello").build();
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertEquals(messageToStore.getPayload(), retrievedMessage.getPayload());
assertEquals(messageToStore.getHeaders(), retrievedMessage.getHeaders());
assertEquals(messageToStore, retrievedMessage);
assertThat(retrievedMessage).isNotNull();
assertThat(retrievedMessage.getPayload()).isEqualTo(messageToStore.getPayload());
assertThat(retrievedMessage.getHeaders()).isEqualTo(messageToStore.getHeaders());
assertThat(retrievedMessage).isEqualTo(messageToStore);
}
@@ -98,10 +91,10 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<?> messageToStore = MessageBuilder.withPayload("Hello").build();
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertThat(retrievedMessage).isNotNull();
store.removeMessage(retrievedMessage.getHeaders().getId());
retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNull(retrievedMessage);
assertThat(retrievedMessage).isNull();
}
@@ -116,10 +109,10 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<?> messageToStore = MessageBuilder.withPayload(p).build();
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertEquals(messageToStore.getPayload(), retrievedMessage.getPayload());
assertEquals(messageToStore.getHeaders(), retrievedMessage.getHeaders());
assertEquals(messageToStore, retrievedMessage);
assertThat(retrievedMessage).isNotNull();
assertThat(retrievedMessage.getPayload()).isEqualTo(messageToStore.getPayload());
assertThat(retrievedMessage.getHeaders()).isEqualTo(messageToStore.getHeaders());
assertThat(retrievedMessage).isEqualTo(messageToStore);
}
@@ -146,18 +139,18 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
message = MessageHistory.write(message, barChannel);
store.addMessage(message);
message = store.getMessage(message.getHeaders().getId());
assertNotNull(message);
assertTrue(message.getHeaders().get("foo") instanceof Foo);
assertTrue(message.getHeaders().get("bar") instanceof Bar);
assertTrue(message.getHeaders().get("baz") instanceof Baz);
assertTrue(message.getHeaders().get("abc") instanceof Abc);
assertTrue(message.getHeaders().get("xyz") instanceof Xyz);
assertThat(message).isNotNull();
assertThat(message.getHeaders().get("foo") instanceof Foo).isTrue();
assertThat(message.getHeaders().get("bar") instanceof Bar).isTrue();
assertThat(message.getHeaders().get("baz") instanceof Baz).isTrue();
assertThat(message.getHeaders().get("abc") instanceof Abc).isTrue();
assertThat(message.getHeaders().get("xyz") instanceof Xyz).isTrue();
MessageHistory messageHistory = MessageHistory.read(message);
assertNotNull(messageHistory);
assertEquals(2, messageHistory.size());
assertThat(messageHistory).isNotNull();
assertThat(messageHistory.size()).isEqualTo(2);
Properties fooChannelHistory = messageHistory.get(0);
assertEquals("fooChannel", fooChannelHistory.get("name"));
assertEquals("channel", fooChannelHistory.get("type"));
assertThat(fooChannelHistory.get("name")).isEqualTo("fooChannel");
assertThat(fooChannelHistory.get("type")).isEqualTo("channel");
}
@@ -172,10 +165,10 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
.build();
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertEquals(messageToStore.getPayload(), retrievedMessage.getPayload());
assertEquals(messageToStore.getHeaders(), retrievedMessage.getHeaders());
assertEquals(messageToStore, retrievedMessage);
assertThat(retrievedMessage).isNotNull();
assertThat(retrievedMessage.getPayload()).isEqualTo(messageToStore.getPayload());
assertThat(retrievedMessage.getHeaders()).isEqualTo(messageToStore.getHeaders());
assertThat(retrievedMessage).isEqualTo(messageToStore);
}
@Test
@@ -188,12 +181,12 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<?> messageToStore = new GenericMessage<Message<?>>(MessageBuilder.withPayload(p).build());
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertTrue(retrievedMessage.getPayload() instanceof GenericMessage);
assertEquals(messageToStore.getPayload(), retrievedMessage.getPayload());
assertEquals(messageToStore.getHeaders(), retrievedMessage.getHeaders());
assertEquals(((Message<?>) messageToStore.getPayload()).getPayload(), p);
assertEquals(messageToStore, retrievedMessage);
assertThat(retrievedMessage).isNotNull();
assertThat(retrievedMessage.getPayload() instanceof GenericMessage).isTrue();
assertThat(retrievedMessage.getPayload()).isEqualTo(messageToStore.getPayload());
assertThat(retrievedMessage.getHeaders()).isEqualTo(messageToStore.getHeaders());
assertThat(p).isEqualTo(((Message<?>) messageToStore.getPayload()).getPayload());
assertThat(retrievedMessage).isEqualTo(messageToStore);
}
@Test
@@ -207,12 +200,12 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<?> messageToStore = new AdviceMessage<String>("foo", inputMessage);
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertTrue(retrievedMessage instanceof AdviceMessage);
assertEquals(messageToStore.getPayload(), retrievedMessage.getPayload());
assertEquals(messageToStore.getHeaders(), retrievedMessage.getHeaders());
assertEquals(inputMessage, ((AdviceMessage<?>) retrievedMessage).getInputMessage());
assertEquals(messageToStore, retrievedMessage);
assertThat(retrievedMessage).isNotNull();
assertThat(retrievedMessage instanceof AdviceMessage).isTrue();
assertThat(retrievedMessage.getPayload()).isEqualTo(messageToStore.getPayload());
assertThat(retrievedMessage.getHeaders()).isEqualTo(messageToStore.getHeaders());
assertThat(((AdviceMessage<?>) retrievedMessage).getInputMessage()).isEqualTo(inputMessage);
assertThat(retrievedMessage).isEqualTo(messageToStore);
}
@Test
@@ -226,13 +219,13 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<?> messageToStore = new GenericMessage<Message<?>>(new AdviceMessage<String>("foo", inputMessage));
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertTrue(retrievedMessage.getPayload() instanceof AdviceMessage);
assertThat(retrievedMessage).isNotNull();
assertThat(retrievedMessage.getPayload() instanceof AdviceMessage).isTrue();
AdviceMessage<?> adviceMessage = (AdviceMessage<?>) retrievedMessage.getPayload();
assertEquals("foo", adviceMessage.getPayload());
assertEquals(messageToStore.getHeaders(), retrievedMessage.getHeaders());
assertEquals(inputMessage, adviceMessage.getInputMessage());
assertEquals(messageToStore, retrievedMessage);
assertThat(adviceMessage.getPayload()).isEqualTo("foo");
assertThat(retrievedMessage.getHeaders()).isEqualTo(messageToStore.getHeaders());
assertThat(adviceMessage.getInputMessage()).isEqualTo(inputMessage);
assertThat(retrievedMessage).isEqualTo(messageToStore);
}
@Test
@@ -245,12 +238,12 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<?> messageToStore = new GenericMessage<Message<?>>(MutableMessageBuilder.withPayload(p).build());
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertThat(retrievedMessage.getPayload(), instanceOf(MutableMessage.class));
assertEquals(messageToStore.getPayload(), retrievedMessage.getPayload());
assertEquals(messageToStore.getHeaders(), retrievedMessage.getHeaders());
assertEquals(((Message<?>) messageToStore.getPayload()).getPayload(), p);
assertEquals(messageToStore, retrievedMessage);
assertThat(retrievedMessage).isNotNull();
assertThat(retrievedMessage.getPayload()).isInstanceOf(MutableMessage.class);
assertThat(retrievedMessage.getPayload()).isEqualTo(messageToStore.getPayload());
assertThat(retrievedMessage.getHeaders()).isEqualTo(messageToStore.getHeaders());
assertThat(p).isEqualTo(((Message<?>) messageToStore.getPayload()).getPayload());
assertThat(retrievedMessage).isEqualTo(messageToStore);
}
@Test
@@ -271,13 +264,13 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<?> messageToStore = new ErrorMessage(messagingException);
store.addMessage(messageToStore);
Message<?> retrievedMessage = store.getMessage(messageToStore.getHeaders().getId());
assertNotNull(retrievedMessage);
assertTrue(retrievedMessage instanceof ErrorMessage);
assertThat(retrievedMessage.getPayload(), Matchers.instanceOf(MessagingException.class));
assertThat(((MessagingException) retrievedMessage.getPayload()).getMessage(),
containsString("intentional MessagingException"));
assertEquals(failedMessage, ((MessagingException) retrievedMessage.getPayload()).getFailedMessage());
assertEquals(messageToStore.getHeaders(), retrievedMessage.getHeaders());
assertThat(retrievedMessage).isNotNull();
assertThat(retrievedMessage instanceof ErrorMessage).isTrue();
assertThat(retrievedMessage.getPayload()).isInstanceOf(MessagingException.class);
assertThat(((MessagingException) retrievedMessage.getPayload()).getMessage())
.contains("intentional MessagingException");
assertThat(((MessagingException) retrievedMessage.getPayload()).getFailedMessage()).isEqualTo(failedMessage);
assertThat(retrievedMessage.getHeaders()).isEqualTo(messageToStore.getHeaders());
}
@Test
@@ -287,7 +280,7 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
Message<String> message = MessageBuilder.withPayload("foo").build();
message = messageStore.addMessage(message);
Message<String> result = messageStore.addMessage(message);
assertEquals(message, result);
assertThat(result).isEqualTo(message);
}
public static class Foo implements Serializable {
@@ -306,6 +299,7 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
public void setName(String name) {
this.name = name;
}
}
public static class Bar implements Serializable {
@@ -324,6 +318,7 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
public String getName() {
return name;
}
}
public static class Baz implements Serializable {
@@ -454,7 +449,9 @@ public abstract class AbstractMongoDbMessageStoreTests extends MongoDbAvailableT
}
return true;
}
}
protected abstract MessageStore getMessageStore() throws Exception;
}

39
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/store/ConfigurableMongoDbMessageGroupStoreTests.java
View File

@@ -16,14 +16,11 @@
package org.springframework.integration.mongodb.store;
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 java.util.Map;
import org.bson.Document;
import org.hamcrest.Matchers;
import org.junit.Ignore;
import org.junit.Test;
@@ -107,7 +104,7 @@ public class ConfigurableMongoDbMessageGroupStoreTests extends AbstractMongoDbMe
.build());
}
assertNotNull(output.receive(20000));
assertThat(output.receive(20000)).isNotNull();
watch.stop();
@@ -124,7 +121,7 @@ public class ConfigurableMongoDbMessageGroupStoreTests extends AbstractMongoDbMe
TestGateway gateway = context.getBean(TestGateway.class);
String result = gateway.service("foo");
assertEquals("FOO", result);
assertThat(result).isEqualTo("FOO");
context.close();
}
@@ -137,7 +134,7 @@ public class ConfigurableMongoDbMessageGroupStoreTests extends AbstractMongoDbMe
context.refresh();
Object priorityChannel = context.getBean("priorityChannel");
assertThat(priorityChannel, Matchers.instanceOf(PriorityChannel.class));
assertThat(priorityChannel).isInstanceOf(PriorityChannel.class);
QueueChannel channel = (QueueChannel) priorityChannel;
@@ -157,32 +154,32 @@ public class ConfigurableMongoDbMessageGroupStoreTests extends AbstractMongoDbMe
channel.send(message);
Message<?> receive = channel.receive(1000);
assertNotNull(receive);
assertEquals("3", receive.getPayload());
assertThat(receive).isNotNull();
assertThat(receive.getPayload()).isEqualTo("3");
receive = channel.receive(1000);
assertNotNull(receive);
assertEquals("31", receive.getPayload());
assertThat(receive).isNotNull();
assertThat(receive.getPayload()).isEqualTo("31");
receive = channel.receive(1000);
assertNotNull(receive);
assertEquals("2", receive.getPayload());
assertThat(receive).isNotNull();
assertThat(receive.getPayload()).isEqualTo("2");
receive = channel.receive(1000);
assertNotNull(receive);
assertEquals("1", receive.getPayload());
assertThat(receive).isNotNull();
assertThat(receive.getPayload()).isEqualTo("1");
receive = channel.receive(1000);
assertNotNull(receive);
assertEquals("0", receive.getPayload());
assertThat(receive).isNotNull();
assertThat(receive.getPayload()).isEqualTo("0");
receive = channel.receive(1000);
assertNotNull(receive);
assertEquals("-1", receive.getPayload());
assertThat(receive).isNotNull();
assertThat(receive.getPayload()).isEqualTo("-1");
receive = channel.receive(1000);
assertNotNull(receive);
assertEquals("none", receive.getPayload());
assertThat(receive).isNotNull();
assertThat(receive.getPayload()).isEqualTo("none");
context.close();
}

23
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/store/DelayerHandlerRescheduleIntegrationTests.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,16 +16,11 @@
package org.springframework.integration.mongodb.store;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Iterator;
import java.util.concurrent.TimeUnit;
import org.hamcrest.Matchers;
import org.junit.Rule;
import org.junit.Test;
@@ -89,7 +84,7 @@ public class DelayerHandlerRescheduleIntegrationTests extends MongoDbAvailableTe
taskScheduler.shutdown();
taskScheduler.getScheduledExecutor().awaitTermination(10, TimeUnit.SECONDS);
assertEquals(2, messageStore.messageGroupSize(delayerMessageGroupId));
assertThat(messageStore.messageGroupSize(delayerMessageGroupId)).isEqualTo(2);
MessageGroup messageGroup = messageStore.getMessageGroup(delayerMessageGroupId);
Iterator<Message<?>> iterator = messageGroup.getMessages().iterator();
@@ -97,13 +92,13 @@ public class DelayerHandlerRescheduleIntegrationTests extends MongoDbAvailableTe
Object payload = messageInStore.getPayload();
// INT-3049
assertTrue(payload instanceof DelayHandler.DelayedMessageWrapper);
assertThat(payload instanceof DelayHandler.DelayedMessageWrapper).isTrue();
Message<String> original1 = (Message<String>) ((DelayHandler.DelayedMessageWrapper) payload).getOriginal();
messageInStore = iterator.next();
Message<String> original2 = (Message<String>) ((DelayHandler.DelayedMessageWrapper) messageInStore.getPayload())
.getOriginal();
assertThat(message1, Matchers.anyOf(Matchers.is(original1), Matchers.is(original2)));
assertThat(message1).isIn(original1, original2);
context.close();
@@ -112,18 +107,18 @@ public class DelayerHandlerRescheduleIntegrationTests extends MongoDbAvailableTe
PollableChannel output = context.getBean("output", PollableChannel.class);
Message<?> message = output.receive(20000);
assertNotNull(message);
assertThat(message).isNotNull();
Object payload1 = message.getPayload();
message = output.receive(20000);
assertNotNull(message);
assertThat(message).isNotNull();
Object payload2 = message.getPayload();
assertNotSame(payload1, payload2);
assertThat(payload2).isNotSameAs(payload1);
messageStore = context.getBean("messageStore", MessageGroupStore.class);
assertEquals(0, messageStore.messageGroupSize(delayerMessageGroupId));
assertThat(messageStore.messageGroupSize(delayerMessageGroupId)).isEqualTo(0);
context.close();
}

34
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/store/MongoDbMessageStoreClaimCheckIntegrationTests.java
View File

@@ -16,7 +16,7 @@
package org.springframework.integration.mongodb.store;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.Serializable;
@@ -65,11 +65,11 @@ public class MongoDbMessageStoreClaimCheckIntegrationTests extends MongoDbAvaila
ClaimCheckOutTransformer checkout = new ClaimCheckOutTransformer(messageStore);
Message<?> originalMessage = MessageBuilder.withPayload("test1").build();
Message<?> claimCheckMessage = checkin.transform(originalMessage);
assertEquals(originalMessage.getHeaders().getId(), claimCheckMessage.getPayload());
assertThat(claimCheckMessage.getPayload()).isEqualTo(originalMessage.getHeaders().getId());
Message<?> checkedOutMessage = checkout.transform(claimCheckMessage);
assertEquals(claimCheckMessage.getPayload(), checkedOutMessage.getHeaders().getId());
assertEquals(originalMessage.getPayload(), checkedOutMessage.getPayload());
assertEquals(originalMessage, checkedOutMessage);
assertThat(checkedOutMessage.getHeaders().getId()).isEqualTo(claimCheckMessage.getPayload());
assertThat(checkedOutMessage.getPayload()).isEqualTo(originalMessage.getPayload());
assertThat(checkedOutMessage).isEqualTo(originalMessage);
}
@Test
@@ -86,11 +86,11 @@ public class MongoDbMessageStoreClaimCheckIntegrationTests extends MongoDbAvaila
payload.setIced(false);
Message<?> originalMessage = MessageBuilder.withPayload(payload).build();
Message<?> claimCheckMessage = checkin.transform(originalMessage);
assertEquals(originalMessage.getHeaders().getId(), claimCheckMessage.getPayload());
assertThat(claimCheckMessage.getPayload()).isEqualTo(originalMessage.getHeaders().getId());
Message<?> checkedOutMessage = checkout.transform(claimCheckMessage);
assertEquals(originalMessage.getPayload(), checkedOutMessage.getPayload());
assertEquals(claimCheckMessage.getPayload(), checkedOutMessage.getHeaders().getId());
assertEquals(originalMessage, checkedOutMessage);
assertThat(checkedOutMessage.getPayload()).isEqualTo(originalMessage.getPayload());
assertThat(checkedOutMessage.getHeaders().getId()).isEqualTo(claimCheckMessage.getPayload());
assertThat(checkedOutMessage).isEqualTo(originalMessage);
}
@Test
@@ -104,11 +104,11 @@ public class MongoDbMessageStoreClaimCheckIntegrationTests extends MongoDbAvaila
ClaimCheckOutTransformer checkout = new ClaimCheckOutTransformer(messageStore);
Message<?> originalMessage = MessageBuilder.withPayload("test1").build();
Message<?> claimCheckMessage = checkin.transform(originalMessage);
assertEquals(originalMessage.getHeaders().getId(), claimCheckMessage.getPayload());
assertThat(claimCheckMessage.getPayload()).isEqualTo(originalMessage.getHeaders().getId());
Message<?> checkedOutMessage = checkout.transform(claimCheckMessage);
assertEquals(claimCheckMessage.getPayload(), checkedOutMessage.getHeaders().getId());
assertEquals(originalMessage.getPayload(), checkedOutMessage.getPayload());
assertEquals(originalMessage, checkedOutMessage);
assertThat(checkedOutMessage.getHeaders().getId()).isEqualTo(claimCheckMessage.getPayload());
assertThat(checkedOutMessage.getPayload()).isEqualTo(originalMessage.getPayload());
assertThat(checkedOutMessage).isEqualTo(originalMessage);
}
@Test
@@ -126,11 +126,11 @@ public class MongoDbMessageStoreClaimCheckIntegrationTests extends MongoDbAvaila
payload.setIced(false);
Message<?> originalMessage = MessageBuilder.withPayload(payload).build();
Message<?> claimCheckMessage = checkin.transform(originalMessage);
assertEquals(originalMessage.getHeaders().getId(), claimCheckMessage.getPayload());
assertThat(claimCheckMessage.getPayload()).isEqualTo(originalMessage.getHeaders().getId());
Message<?> checkedOutMessage = checkout.transform(claimCheckMessage);
assertEquals(originalMessage.getPayload(), checkedOutMessage.getPayload());
assertEquals(claimCheckMessage.getPayload(), checkedOutMessage.getHeaders().getId());
assertEquals(originalMessage, checkedOutMessage);
assertThat(checkedOutMessage.getPayload()).isEqualTo(originalMessage.getPayload());
assertThat(checkedOutMessage.getHeaders().getId()).isEqualTo(claimCheckMessage.getPayload());
assertThat(checkedOutMessage).isEqualTo(originalMessage);
}
@SuppressWarnings("serial")

5
spring-integration-mongodb/src/test/java/org/springframework/integration/mongodb/store/MongoDbMessageStoreTests.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.
@@ -31,7 +31,8 @@ public class MongoDbMessageStoreTests extends AbstractMongoDbMessageStoreTests {
@Override
protected MessageStore getMessageStore() throws Exception {
MongoDbMessageStore mongoDbMessageStore = new MongoDbMessageStore(new SimpleMongoDbFactory(new MongoClient(), "test"));
MongoDbMessageStore mongoDbMessageStore =
new MongoDbMessageStore(new SimpleMongoDbFactory(new MongoClient(), "test"));
mongoDbMessageStore.afterPropertiesSet();
return mongoDbMessageStore;
}