From fad18341fab717f3ea5f2ed401d6dcb50fc91065 Mon Sep 17 00:00:00 2001 From: Mark Paluch Date: Thu, 11 Jul 2019 11:07:15 +0200 Subject: [PATCH] DATAMONGO-2321 - Migrate tests to AssertJ. --- .../mongodb/MongoDatabaseUtilsUnitTests.java | 18 +- .../MongoTransactionManagerUnitTests.java | 6 +- ...ctiveMongoTransactionManagerUnitTests.java | 7 +- .../config/AbstractIntegrationTests.java | 6 +- .../AbstractMongoConfigurationUnitTests.java | 30 +- ...ctReactiveMongoConfigurationUnitTests.java | 30 +- .../config/AuditingIntegrationTests.java | 12 +- ...uditingViaJavaConfigRepositoriesTests.java | 11 +- .../GeoJsonConfigurationIntegrationTests.java | 6 +- ...gMongoConverterParserIntegrationTests.java | 16 +- ...erterParserValidationIntegrationTests.java | 10 +- .../MongoDbFactoryNoDatabaseRunningTests.java | 6 +- .../config/MongoNamespaceReplicaSetTests.java | 35 +- .../mongodb/config/MongoNamespaceTests.java | 102 ++- .../config/MongoParserIntegrationTests.java | 10 +- ...ReadPreferencePropertyEditorUnitTests.java | 7 +- .../ServerAddressPropertyEditorUnitTests.java | 16 +- .../core/DefaultScriptOperationsTests.java | 29 +- .../DefaultScriptOperationsUnitTests.java | 6 +- .../core/GeoCommandStatisticsUnitTests.java | 9 +- ...entOptionsFactoryBeanIntegrationTests.java | 6 +- .../MongoExceptionTranslatorUnitTests.java | 18 +- .../data/mongodb/core/MongoTemplateTests.java | 854 +++++++++--------- .../data/mongodb/core/NoExplicitIdTests.java | 10 +- .../ReactiveMongoTemplateExecuteTests.java | 13 +- .../core/ReactiveMongoTemplateUnitTests.java | 75 +- .../core/SimpleMongoDbFactoryUnitTests.java | 11 +- ...ReactiveMongoDatabaseFactoryUnitTests.java | 5 +- ...nwrapAndReadDocumentCallbackUnitTests.java | 22 +- .../core/aggregation/AggregationTests.java | 20 +- .../BucketAutoOperationUnitTests.java | 28 +- .../aggregation/BucketOperationUnitTests.java | 52 +- .../aggregation/CondExpressionUnitTests.java | 15 +- .../aggregation/CountOperationUnitTests.java | 12 +- .../aggregation/ExposedFieldsUnitTests.java | 8 +- .../aggregation/FacetOperationUnitTests.java | 7 +- .../core/aggregation/FieldsUnitTests.java | 27 +- .../FilterExpressionUnitTests.java | 12 +- .../aggregation/GroupOperationUnitTests.java | 54 +- .../aggregation/LookupOperationUnitTests.java | 35 +- .../ReplaceRootOperationUnitTests.java | 21 +- .../aggregation/SampleOperationUnitTests.java | 9 +- .../aggregation/SkipOperationUnitTests.java | 5 +- .../aggregation/SortOperationUnitTests.java | 12 +- ...ExpressionTransformerIntegrationTests.java | 10 +- .../SpelExpressionTransformerUnitTests.java | 438 ++++----- ...dAggregationOperationContextUnitTests.java | 75 +- .../aggregation/UnwindOperationUnitTests.java | 34 +- .../convert/CustomConvertersUnitTests.java | 6 +- .../core/convert/DataMongo273Tests.java | 21 +- .../DbRefMappingMongoConverterUnitTests.java | 113 ++- .../DefaultMongoTypeMapperUnitTests.java | 36 +- .../convert/DocumentAccessorUnitTests.java | 22 +- .../core/convert/GeoConvertersUnitTests.java | 60 +- .../convert/GeoJsonConverterUnitTests.java | 49 +- .../core/convert/LazyLoadingTestUtils.java | 13 +- .../MappingMongoConverterUnitTests.java | 502 +++++----- .../convert/MongoExampleMapperUnitTests.java | 172 ++-- .../NamedMongoScriptConvertsUnitTests.java | 22 +- ...mberToNumberConverterFactoryUnitTests.java | 7 +- .../TermToStringConverterUnitTests.java | 6 +- .../core/geo/GeoJsonModuleUnitTests.java | 42 +- .../core/geo/GeoSpatial2DSphereTests.java | 22 +- .../mongodb/core/geo/GeoSpatial2DTests.java | 18 +- ...entEntityIndexCreatorIntegrationTests.java | 18 +- .../mongodb/core/index/PathUnitTests.java | 18 +- ...BasicMongoPersistentPropertyUnitTests.java | 37 +- .../core/mapping/GenericMappingTests.java | 16 +- .../mongodb/core/mapping/MappingTests.java | 126 +-- ...PersistentPropertyComparatorUnitTests.java | 16 +- .../AbstractMongoEventListenerUnitTests.java | 32 +- .../event/ApplicationContextEventTests.java | 8 +- .../AuditingEntityCallbackUnitTests.java | 9 +- .../event/AuditingEventListenerUnitTests.java | 10 +- .../event/LoggingEventListenerTests.java | 17 +- .../ValidatingMongoEventListenerTests.java | 14 +- .../mongodb/core/mapreduce/GroupByTests.java | 28 +- .../mapreduce/MapReduceCountsUnitTests.java | 15 +- .../core/mapreduce/MapReduceOptionsTests.java | 7 +- .../mapreduce/MapReduceResultsUnitTests.java | 7 +- .../core/query/BasicQueryUnitTests.java | 31 +- .../mongodb/core/query/CriteriaUnitTests.java | 90 +- .../mongodb/core/query/FieldUnitTests.java | 11 +- .../mongodb/core/query/IndexUnitTests.java | 30 +- .../data/mongodb/core/query/IsQuery.java | 151 ---- .../data/mongodb/core/query/IsTextQuery.java | 141 --- .../core/query/MetricConversionUnitTests.java | 13 +- .../core/query/NearQueryUnitTests.java | 71 +- .../data/mongodb/core/query/QueryTests.java | 6 +- .../data/mongodb/core/query/SortTests.java | 10 +- .../core/query/TextCriteriaUnitTests.java | 36 +- .../mongodb/core/query/TextQueryTests.java | 60 +- .../core/query/TextQueryUnitTests.java | 34 +- .../query/UntypedExampleMatcherUnitTests.java | 5 +- .../ExecutableMongoScriptUnitTests.java | 9 +- .../script/NamedMongoScriptUnitTests.java | 5 +- .../core/spel/ExpressionNodeUnitTests.java | 6 +- .../data/mongodb/gridfs/AntPathUnitTests.java | 9 +- .../monitor/MongoMonitorIntegrationTests.java | 8 +- ...tractPersonRepositoryIntegrationTests.java | 445 +++++---- .../ComplexIdRepositoryIntegrationTests.java | 21 +- ...onvertingReactiveMongoRepositoryTests.java | 12 +- ...oRepositoryTextSearchIntegrationTests.java | 41 +- ...RepositoryLazyLoadingIntegrationTests.java | 14 +- .../RedeclaringRepositoryMethodsTests.java | 10 +- ...positoryIndexCreationIntegrationTests.java | 5 +- .../SimpleReactiveMongoRepositoryTests.java | 42 +- .../cdi/CdiExtensionIntegrationTests.java | 12 +- .../MongoNamespaceIntegrationTests.java | 10 +- ...sitoryConfigurationExtensionUnitTests.java | 3 +- ...sitoryConfigurationExtensionUnitTests.java | 3 +- ...ongoRepositoriesRepositoryConfigTests.java | 6 +- ...estedMongoRepositoriesJavaConfigTests.java | 6 +- ...ReactiveRepositoryImplementationTests.java | 10 +- .../CustomRepositoryImplementationTests.java | 10 +- .../ConvertingParameterAccessorUnitTests.java | 22 +- ...appingMongoEntityInformationUnitTests.java | 10 +- .../query/MongoQueryMethodUnitTests.java | 86 +- .../query/PartTreeMongoQueryUnitTests.java | 47 +- .../ReactiveMongoQueryExecutionUnitTests.java | 20 +- .../ReactiveMongoQueryMethodUnitTests.java | 44 +- ...eactiveStringBasedMongoQueryUnitTests.java | 37 +- .../MongoRepositoryFactoryBeanUnitTests.java | 10 +- .../MongoRepositoryFactoryUnitTests.java | 8 +- .../QuerydslRepositorySupportTests.java | 34 +- .../data/mongodb/test/util/IsBsonObject.java | 217 ----- 126 files changed, 2502 insertions(+), 3158 deletions(-) delete mode 100644 spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IsQuery.java delete mode 100644 spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IsTextQuery.java delete mode 100644 spring-data-mongodb/src/test/java/org/springframework/data/mongodb/test/util/IsBsonObject.java diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoDatabaseUtilsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoDatabaseUtilsUnitTests.java index 8969b3891..0ddfc8650 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoDatabaseUtilsUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoDatabaseUtilsUnitTests.java @@ -15,9 +15,8 @@ */ package org.springframework.data.mongodb; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.*; -import static org.mockito.ArgumentMatchers.any; +import static org.assertj.core.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; import javax.transaction.Status; @@ -29,6 +28,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.jta.JtaTransactionManager; import org.springframework.transaction.support.TransactionCallbackWithoutResult; @@ -70,12 +70,12 @@ public class MongoDatabaseUtilsUnitTests { @After public void verifyTransactionSynchronizationManagerState() { - assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty()); - assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); - assertNull(TransactionSynchronizationManager.getCurrentTransactionName()); - assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly()); - assertNull(TransactionSynchronizationManager.getCurrentTransactionIsolationLevel()); - assertFalse(TransactionSynchronizationManager.isActualTransactionActive()); + assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); + assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.getCurrentTransactionIsolationLevel()).isNull(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); } @Test // DATAMONGO-2130 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoTransactionManagerUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoTransactionManagerUnitTests.java index eddb98c06..e5bd71134 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoTransactionManagerUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoTransactionManagerUnitTests.java @@ -16,7 +16,6 @@ package org.springframework.data.mongodb; import static org.assertj.core.api.Assertions.*; -import static org.junit.Assert.*; import static org.mockito.Mockito.*; import org.junit.After; @@ -25,6 +24,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.TransactionStatus; @@ -72,8 +72,8 @@ public class MongoTransactionManagerUnitTests { @After public void verifyTransactionSynchronizationManager() { - assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty()); - assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); + assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); } @Test // DATAMONGO-1920 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/ReactiveMongoTransactionManagerUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/ReactiveMongoTransactionManagerUnitTests.java index b8f2ec152..6acc3f046 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/ReactiveMongoTransactionManagerUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/ReactiveMongoTransactionManagerUnitTests.java @@ -15,7 +15,7 @@ */ package org.springframework.data.mongodb; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import reactor.core.publisher.Mono; @@ -27,6 +27,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.core.ReactiveMongoTemplate; import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.reactive.TransactionalOperator; @@ -72,8 +73,8 @@ public class ReactiveMongoTransactionManagerUnitTests { @After public void verifyTransactionSynchronizationManager() { - assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty()); - assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); + assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); } @Test // DATAMONGO-2265 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractIntegrationTests.java index ba84cc2cf..f8042e218 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractIntegrationTests.java @@ -15,13 +15,13 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import org.bson.Document; import org.junit.After; import org.junit.Before; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.dao.DataAccessException; @@ -68,7 +68,7 @@ public abstract class AbstractIntegrationTests { @Override public Void doInCollection(MongoCollection collection) throws MongoException, DataAccessException { collection.deleteMany(new Document()); - assertThat(collection.find().iterator().hasNext(), is(false)); + assertThat(collection.find().iterator().hasNext()).isFalse(); return null; } }); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractMongoConfigurationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractMongoConfigurationUnitTests.java index eb9b7d22e..c0cf35297 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractMongoConfigurationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractMongoConfigurationUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import example.first.First; import example.second.Second; @@ -29,6 +28,7 @@ import java.util.Set; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; + import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; @@ -61,9 +61,9 @@ public class AbstractMongoConfigurationUnitTests { public void usesConfigClassPackageAsBaseMappingPackage() throws ClassNotFoundException { AbstractMongoConfiguration configuration = new SampleMongoConfiguration(); - assertThat(configuration.getMappingBasePackage(), is(SampleMongoConfiguration.class.getPackage().getName())); - assertThat(configuration.getInitialEntitySet(), hasSize(2)); - assertThat(configuration.getInitialEntitySet(), hasItem(Entity.class)); + assertThat(configuration.getMappingBasePackage()).isEqualTo(SampleMongoConfiguration.class.getPackage().getName()); + assertThat(configuration.getInitialEntitySet()).hasSize(2); + assertThat(configuration.getInitialEntitySet()).contains(Entity.class); } @Test // DATAMONGO-496 @@ -83,7 +83,7 @@ public class AbstractMongoConfigurationUnitTests { AbstractApplicationContext context = new AnnotationConfigApplicationContext(SampleMongoConfiguration.class); - assertThat(context.getBean(MongoDbFactory.class), is(notNullValue())); + assertThat(context.getBean(MongoDbFactory.class)).isNotNull(); exception.expect(NoSuchBeanDefinitionException.class); context.getBean(MongoClient.class); @@ -96,9 +96,9 @@ public class AbstractMongoConfigurationUnitTests { SampleMongoConfiguration configuration = new SampleMongoConfiguration(); MongoMappingContext context = configuration.mongoMappingContext(); - assertThat(context.getPersistentEntities(), is(emptyIterable())); + assertThat(context.getPersistentEntities()).isEmpty(); context.initialize(); - assertThat(context.getPersistentEntities(), is(not(emptyIterable()))); + assertThat(context.getPersistentEntities()).isNotEmpty(); } @Test // DATAMONGO-717 @@ -110,7 +110,7 @@ public class AbstractMongoConfigurationUnitTests { EvaluationContextProvider provider = (EvaluationContextProvider) ReflectionTestUtils.getField(entity, "evaluationContextProvider"); - assertThat(provider, is(instanceOf(ExtensionAwareEvaluationContextProvider.class))); + assertThat(provider).isInstanceOf(ExtensionAwareEvaluationContextProvider.class); context.close(); } @@ -121,8 +121,8 @@ public class AbstractMongoConfigurationUnitTests { MongoTypeMapper typeMapper = context.getBean(CustomMongoTypeMapper.class); MappingMongoConverter mmc = context.getBean(MappingMongoConverter.class); - assertThat(mmc, is(notNullValue())); - assertThat(mmc.getTypeMapper(), is(typeMapper)); + assertThat(mmc).isNotNull(); + assertThat(mmc.getTypeMapper()).isEqualTo(typeMapper); context.close(); } @@ -133,8 +133,8 @@ public class AbstractMongoConfigurationUnitTests { ConfigurationWithMultipleBasePackages config = new ConfigurationWithMultipleBasePackages(); Set> entities = config.getInitialEntitySet(); - assertThat(entities, hasSize(2)); - assertThat(entities, hasItems(First.class, Second.class)); + assertThat(entities).hasSize(2); + assertThat(entities).contains(First.class, Second.class); } private static void assertScanningDisabled(final String value) throws ClassNotFoundException { @@ -146,8 +146,8 @@ public class AbstractMongoConfigurationUnitTests { } }; - assertThat(configuration.getMappingBasePackages(), hasItem(value)); - assertThat(configuration.getInitialEntitySet(), hasSize(0)); + assertThat(configuration.getMappingBasePackages()).contains(value); + assertThat(configuration.getInitialEntitySet()).hasSize(0); } @Configuration diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractReactiveMongoConfigurationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractReactiveMongoConfigurationUnitTests.java index 9fd5664b3..c7aea7618 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractReactiveMongoConfigurationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AbstractReactiveMongoConfigurationUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import example.first.First; import example.second.Second; @@ -29,6 +28,7 @@ import java.util.Set; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; + import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; @@ -61,9 +61,9 @@ public class AbstractReactiveMongoConfigurationUnitTests { public void usesConfigClassPackageAsBaseMappingPackage() throws ClassNotFoundException { AbstractReactiveMongoConfiguration configuration = new SampleMongoConfiguration(); - assertThat(configuration.getMappingBasePackages(), hasItem(SampleMongoConfiguration.class.getPackage().getName())); - assertThat(configuration.getInitialEntitySet(), hasSize(2)); - assertThat(configuration.getInitialEntitySet(), hasItem(Entity.class)); + assertThat(configuration.getMappingBasePackages()).contains(SampleMongoConfiguration.class.getPackage().getName()); + assertThat(configuration.getInitialEntitySet()).hasSize(2); + assertThat(configuration.getInitialEntitySet()).contains(Entity.class); } @Test // DATAMONGO-1444 @@ -83,7 +83,7 @@ public class AbstractReactiveMongoConfigurationUnitTests { AbstractApplicationContext context = new AnnotationConfigApplicationContext(SampleMongoConfiguration.class); - assertThat(context.getBean(SimpleReactiveMongoDatabaseFactory.class), is(notNullValue())); + assertThat(context.getBean(SimpleReactiveMongoDatabaseFactory.class)).isNotNull(); exception.expect(NoSuchBeanDefinitionException.class); @@ -100,9 +100,9 @@ public class AbstractReactiveMongoConfigurationUnitTests { SampleMongoConfiguration configuration = new SampleMongoConfiguration(); MongoMappingContext context = configuration.mongoMappingContext(); - assertThat(context.getPersistentEntities(), is(emptyIterable())); + assertThat(context.getPersistentEntities()).isEmpty(); context.initialize(); - assertThat(context.getPersistentEntities(), is(not(emptyIterable()))); + assertThat(context.getPersistentEntities()).isNotEmpty(); } @Test // DATAMONGO-1444 @@ -114,7 +114,7 @@ public class AbstractReactiveMongoConfigurationUnitTests { EvaluationContextProvider provider = (EvaluationContextProvider) ReflectionTestUtils.getField(entity, "evaluationContextProvider"); - assertThat(provider, is(instanceOf(ExtensionAwareEvaluationContextProvider.class))); + assertThat(provider).isInstanceOf(ExtensionAwareEvaluationContextProvider.class); context.close(); } @@ -125,8 +125,8 @@ public class AbstractReactiveMongoConfigurationUnitTests { MongoTypeMapper typeMapper = context.getBean(CustomMongoTypeMapper.class); MappingMongoConverter mmc = context.getBean(MappingMongoConverter.class); - assertThat(mmc, is(notNullValue())); - assertThat(mmc.getTypeMapper(), is(typeMapper)); + assertThat(mmc).isNotNull(); + assertThat(mmc.getTypeMapper()).isEqualTo(typeMapper); context.close(); } @@ -137,8 +137,8 @@ public class AbstractReactiveMongoConfigurationUnitTests { ConfigurationWithMultipleBasePackages config = new ConfigurationWithMultipleBasePackages(); Set> entities = config.getInitialEntitySet(); - assertThat(entities, hasSize(2)); - assertThat(entities, hasItems(First.class, Second.class)); + assertThat(entities).hasSize(2); + assertThat(entities).contains(First.class, Second.class); } private static void assertScanningDisabled(final String value) throws ClassNotFoundException { @@ -150,8 +150,8 @@ public class AbstractReactiveMongoConfigurationUnitTests { } }; - assertThat(configuration.getMappingBasePackages(), hasItem(value)); - assertThat(configuration.getInitialEntitySet(), hasSize(0)); + assertThat(configuration.getMappingBasePackages()).contains(value); + assertThat(configuration.getInitialEntitySet()).hasSize(0); } @Configuration diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingIntegrationTests.java index c9a9787cb..9e047d682 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingIntegrationTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.joda.time.DateTime; import org.junit.Test; + import org.springframework.context.support.AbstractApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.data.annotation.CreatedDate; @@ -50,16 +50,16 @@ public class AuditingIntegrationTests { Entity entity = new Entity(); entity = callbacks.callback(BeforeConvertCallback.class, entity, "collection-1"); - assertThat(entity.created, is(notNullValue())); - assertThat(entity.modified, is(entity.created)); + assertThat(entity.created).isNotNull(); + assertThat(entity.modified).isEqualTo(entity.created); Thread.sleep(10); entity.id = 1L; entity = callbacks.callback(BeforeConvertCallback.class, entity, "collection-1"); - assertThat(entity.created, is(notNullValue())); - assertThat(entity.modified, is(not(entity.created))); + assertThat(entity.created).isNotNull(); + assertThat(entity.modified).isNotEqualTo(entity.created); context.close(); } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingViaJavaConfigRepositoriesTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingViaJavaConfigRepositoriesTests.java index ba5db77c8..77a95a22e 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingViaJavaConfigRepositoriesTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingViaJavaConfigRepositoriesTests.java @@ -15,9 +15,7 @@ */ package org.springframework.data.mongodb.config; -import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.assertThat; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import java.util.Collections; @@ -27,6 +25,7 @@ import java.util.function.Function; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; @@ -100,9 +99,9 @@ public class AuditingViaJavaConfigRepositoriesTests { AuditablePerson createdBy = savedUser.getCreatedBy(); - assertThat(createdBy, is(notNullValue())); - assertThat(createdBy.getFirstname(), is(this.auditor.getFirstname())); - assertThat(savedUser.getCreatedAt(), is(notNullValue())); + assertThat(createdBy).isNotNull(); + assertThat(createdBy.getFirstname()).isEqualTo(this.auditor.getFirstname()); + assertThat(savedUser.getCreatedAt()).isNotNull(); } @Test // DATAMONGO-843 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/GeoJsonConfigurationIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/GeoJsonConfigurationIntegrationTests.java index 45048fbda..1ace05694 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/GeoJsonConfigurationIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/GeoJsonConfigurationIntegrationTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.data.mongodb.core.geo.GeoJsonModule; @@ -44,6 +44,6 @@ public class GeoJsonConfigurationIntegrationTests { @Test // DATAMONGO-1181 public void picksUpGeoJsonModuleConfigurationByDefault() { - assertThat(geoJsonModule, is(notNullValue())); + assertThat(geoJsonModule).isNotNull(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserIntegrationTests.java index fe6760802..52e3beb61 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserIntegrationTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Collections; import java.util.Set; @@ -25,6 +24,7 @@ import org.bson.Document; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; + import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.config.BeanReference; import org.springframework.beans.factory.parsing.BeanDefinitionParsingException; @@ -72,7 +72,7 @@ public class MappingMongoConverterParserIntegrationTests { MappingMongoConverter converter = factory.getBean("converter", MappingMongoConverter.class); MongoTypeMapper customMongoTypeMapper = factory.getBean(CustomMongoTypeMapper.class); - assertThat(converter.getTypeMapper(), is(customMongoTypeMapper)); + assertThat(converter.getTypeMapper()).isEqualTo(customMongoTypeMapper); } @Test // DATAMONGO-301 @@ -80,8 +80,8 @@ public class MappingMongoConverterParserIntegrationTests { loadValidConfiguration(); CustomConversions conversions = factory.getBean(CustomConversions.class); - assertThat(conversions.hasCustomWriteTarget(Person.class), is(true)); - assertThat(conversions.hasCustomWriteTarget(Account.class), is(true)); + assertThat(conversions.hasCustomWriteTarget(Person.class)).isTrue(); + assertThat(conversions.hasCustomWriteTarget(Account.class)).isTrue(); } @Test // DATAMONGO-607 @@ -91,9 +91,9 @@ public class MappingMongoConverterParserIntegrationTests { BeanDefinition definition = factory.getBeanDefinition("abbreviatingConverter.mongoMappingContext"); Object value = definition.getPropertyValues().getPropertyValue("fieldNamingStrategy").getValue(); - assertThat(value, is(instanceOf(BeanDefinition.class))); + assertThat(value).isInstanceOf(BeanDefinition.class); BeanDefinition strategy = (BeanDefinition) value; - assertThat(strategy.getBeanClassName(), is(CamelCaseAbbreviatingFieldNamingStrategy.class.getName())); + assertThat(strategy.getBeanClassName()).isEqualTo(CamelCaseAbbreviatingFieldNamingStrategy.class.getName()); } @Test // DATAMONGO-866 @@ -151,7 +151,7 @@ public class MappingMongoConverterParserIntegrationTests { BeanReference value = (BeanReference) definition.getPropertyValues().getPropertyValue("fieldNamingStrategy") .getValue(); - assertThat(value.getBeanName(), is("customFieldNamingStrategy")); + assertThat(value.getBeanName()).isEqualTo("customFieldNamingStrategy"); } @Component diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserValidationIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserValidationIntegrationTests.java index ec971b055..a54f16f2d 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserValidationIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserValidationIntegrationTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Before; import org.junit.Test; + import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.beans.factory.support.BeanDefinitionReader; import org.springframework.beans.factory.support.DefaultListableBeanFactory; @@ -50,14 +50,14 @@ public class MappingMongoConverterParserValidationIntegrationTests { public void validatingEventListenerCreatedWithDefaultConfig() { reader.loadBeanDefinitions(new ClassPathResource("namespace/converter-default.xml")); - assertThat(factory.getBean(BeanNames.VALIDATING_EVENT_LISTENER_BEAN_NAME), is(not(nullValue()))); + assertThat(factory.getBean(BeanNames.VALIDATING_EVENT_LISTENER_BEAN_NAME)).isNotNull(); } @Test // DATAMONGO-36 public void validatingEventListenerCreatedWhenValidationEnabled() { reader.loadBeanDefinitions(new ClassPathResource("namespace/converter-validation-enabled.xml")); - assertThat(factory.getBean(BeanNames.VALIDATING_EVENT_LISTENER_BEAN_NAME), is(not(nullValue()))); + assertThat(factory.getBean(BeanNames.VALIDATING_EVENT_LISTENER_BEAN_NAME)).isNotNull(); } @Test(expected = NoSuchBeanDefinitionException.class) // DATAMONGO-36 @@ -71,6 +71,6 @@ public class MappingMongoConverterParserValidationIntegrationTests { public void validatingEventListenerCreatedWithCustomTypeMapperConfig() { reader.loadBeanDefinitions(new ClassPathResource("namespace/converter-custom-typeMapper.xml")); - assertThat(factory.getBean(BeanNames.VALIDATING_EVENT_LISTENER_BEAN_NAME), is(not(nullValue()))); + assertThat(factory.getBean(BeanNames.VALIDATING_EVENT_LISTENER_BEAN_NAME)).isNotNull(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoDbFactoryNoDatabaseRunningTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoDbFactoryNoDatabaseRunningTests.java index 03b0cd0ee..e0eee057d 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoDbFactoryNoDatabaseRunningTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoDbFactoryNoDatabaseRunningTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessResourceFailureException; import org.springframework.data.mongodb.MongoDbFactory; @@ -41,7 +41,7 @@ public class MongoDbFactoryNoDatabaseRunningTests { @Test // DATAMONGO-139 public void startsUpWithoutADatabaseRunning() { - assertThat(mongoTemplate.getClass().getName(), is("org.springframework.data.mongodb.core.MongoTemplate")); + assertThat(mongoTemplate.getClass().getName()).isEqualTo("org.springframework.data.mongodb.core.MongoTemplate"); } @Test(expected = DataAccessResourceFailureException.class) diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoNamespaceReplicaSetTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoNamespaceReplicaSetTests.java index 51e1a2adc..172f6309f 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoNamespaceReplicaSetTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoNamespaceReplicaSetTests.java @@ -16,18 +16,17 @@ package org.springframework.data.mongodb.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.net.InetAddress; import java.util.ArrayList; import java.util.List; -import com.mongodb.MongoClient; import org.bson.Document; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationContext; import org.springframework.data.mongodb.core.MongoClientFactoryBean; @@ -36,7 +35,7 @@ import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.util.ReflectionTestUtils; -import com.mongodb.Mongo; +import com.mongodb.MongoClient; import com.mongodb.ServerAddress; /** @@ -56,34 +55,34 @@ public class MongoNamespaceReplicaSetTests { @SuppressWarnings("unchecked") public void testParsingMongoWithReplicaSets() throws Exception { - assertTrue(ctx.containsBean("replicaSetMongo")); + assertThat(ctx.containsBean("replicaSetMongo")).isTrue(); MongoClientFactoryBean mfb = (MongoClientFactoryBean) ctx.getBean("&replicaSetMongo"); List replicaSetSeeds = (List) ReflectionTestUtils.getField(mfb, "replicaSetSeeds"); - assertThat(replicaSetSeeds, is(notNullValue())); - assertThat(replicaSetSeeds, hasItems(new ServerAddress(InetAddress.getByName("127.0.0.1"), 10001), - new ServerAddress(InetAddress.getByName("localhost"), 10002))); + assertThat(replicaSetSeeds).isNotNull(); + assertThat(replicaSetSeeds).contains(new ServerAddress(InetAddress.getByName("127.0.0.1"), 10001), + new ServerAddress(InetAddress.getByName("localhost"), 10002)); } @Test @SuppressWarnings("unchecked") public void testParsingWithPropertyPlaceHolder() throws Exception { - assertTrue(ctx.containsBean("manyReplicaSetMongo")); + assertThat(ctx.containsBean("manyReplicaSetMongo")).isTrue(); MongoClientFactoryBean mfb = (MongoClientFactoryBean) ctx.getBean("&manyReplicaSetMongo"); List replicaSetSeeds = (List) ReflectionTestUtils.getField(mfb, "replicaSetSeeds"); - assertThat(replicaSetSeeds, is(notNullValue())); - assertThat(replicaSetSeeds, hasSize(3)); + assertThat(replicaSetSeeds).isNotNull(); + assertThat(replicaSetSeeds).hasSize(3); List ports = new ArrayList(); for (ServerAddress replicaSetSeed : replicaSetSeeds) { ports.add(replicaSetSeed.getPort()); } - assertThat(ports, hasItems(27017, 27018, 27019)); + assertThat(ports).contains(27017, 27018, 27019); } @Test @@ -91,15 +90,15 @@ public class MongoNamespaceReplicaSetTests { public void testMongoWithReplicaSets() { MongoClient mongo = ctx.getBean(MongoClient.class); - assertEquals(2, mongo.getAllAddress().size()); + assertThat(mongo.getAllAddress().size()).isEqualTo(2); List servers = mongo.getAllAddress(); - assertEquals("127.0.0.1", servers.get(0).getHost()); - assertEquals("localhost", servers.get(1).getHost()); - assertEquals(10001, servers.get(0).getPort()); - assertEquals(10002, servers.get(1).getPort()); + assertThat(servers.get(0).getHost()).isEqualTo("127.0.0.1"); + assertThat(servers.get(1).getHost()).isEqualTo("localhost"); + assertThat(servers.get(0).getPort()).isEqualTo(10001); + assertThat(servers.get(1).getPort()).isEqualTo(10002); MongoTemplate template = new MongoTemplate(mongo, "admin"); Document result = template.executeCommand("{replSetGetStatus : 1}"); - assertEquals("blort", result.get("set").toString()); + assertThat(result.get("set").toString()).isEqualTo("blort"); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoNamespaceTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoNamespaceTests.java index add0eaa86..835409c4b 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoNamespaceTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoNamespaceTests.java @@ -15,13 +15,14 @@ */ package org.springframework.data.mongodb.config; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.test.util.ReflectionTestUtils.*; import javax.net.ssl.SSLSocketFactory; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationContext; import org.springframework.data.mongodb.MongoDbFactory; @@ -54,177 +55,180 @@ public class MongoNamespaceTests { @Test public void testMongoSingleton() throws Exception { - assertTrue(ctx.containsBean("noAttrMongo")); + assertThat(ctx.containsBean("noAttrMongo")).isTrue(); MongoClientFactoryBean mfb = (MongoClientFactoryBean) ctx.getBean("&noAttrMongo"); - assertNull(getField(mfb, "host")); - assertNull(getField(mfb, "port")); + assertThat(getField(mfb, "host")).isNull(); + assertThat(getField(mfb, "port")).isNull(); } @Test public void testMongoSingletonWithAttributes() throws Exception { - assertTrue(ctx.containsBean("defaultMongo")); + assertThat(ctx.containsBean("defaultMongo")).isTrue(); MongoClientFactoryBean mfb = (MongoClientFactoryBean) ctx.getBean("&defaultMongo"); String host = (String) getField(mfb, "host"); Integer port = (Integer) getField(mfb, "port"); - assertEquals("localhost", host); - assertEquals(new Integer(27017), port); + assertThat(host).isEqualTo("localhost"); + assertThat(port).isEqualTo(new Integer(27017)); MongoClientOptions options = (MongoClientOptions) getField(mfb, "mongoClientOptions"); - assertFalse("By default socketFactory should not be a SSLSocketFactory", - options.getSocketFactory() instanceof SSLSocketFactory); + assertThat(options.getSocketFactory() instanceof SSLSocketFactory) + .as("By default socketFactory should not be a SSLSocketFactory").isFalse(); } @Test // DATAMONGO-764 public void testMongoSingletonWithSslEnabled() throws Exception { - assertTrue(ctx.containsBean("mongoSsl")); + assertThat(ctx.containsBean("mongoSsl")).isTrue(); MongoClientFactoryBean mfb = (MongoClientFactoryBean) ctx.getBean("&mongoSsl"); MongoClientOptions options = (MongoClientOptions) getField(mfb, "mongoClientOptions"); - assertTrue("socketFactory should be a SSLSocketFactory", options.getSocketFactory() instanceof SSLSocketFactory); + assertThat(options.getSocketFactory() instanceof SSLSocketFactory).as("socketFactory should be a SSLSocketFactory") + .isTrue(); } @Test // DATAMONGO-1490 public void testMongoClientSingletonWithSslEnabled() { - assertTrue(ctx.containsBean("mongoClientSsl")); + assertThat(ctx.containsBean("mongoClientSsl")).isTrue(); MongoClientFactoryBean mfb = (MongoClientFactoryBean) ctx.getBean("&mongoClientSsl"); MongoClientOptions options = (MongoClientOptions) getField(mfb, "mongoClientOptions"); - assertTrue("socketFactory should be a SSLSocketFactory", options.getSocketFactory() instanceof SSLSocketFactory); + assertThat(options.getSocketFactory() instanceof SSLSocketFactory).as("socketFactory should be a SSLSocketFactory") + .isTrue(); } @Test // DATAMONGO-764 public void testMongoSingletonWithSslEnabledAndCustomSslSocketFactory() throws Exception { - assertTrue(ctx.containsBean("mongoSslWithCustomSslFactory")); + assertThat(ctx.containsBean("mongoSslWithCustomSslFactory")).isTrue(); MongoClientFactoryBean mfb = (MongoClientFactoryBean) ctx.getBean("&mongoSslWithCustomSslFactory"); SSLSocketFactory customSslSocketFactory = ctx.getBean("customSslSocketFactory", SSLSocketFactory.class); MongoClientOptions options = (MongoClientOptions) getField(mfb, "mongoClientOptions"); - assertTrue("socketFactory should be a SSLSocketFactory", options.getSocketFactory() instanceof SSLSocketFactory); - assertSame(customSslSocketFactory, options.getSocketFactory()); + assertThat(options.getSocketFactory() instanceof SSLSocketFactory).as("socketFactory should be a SSLSocketFactory") + .isTrue(); + assertThat(options.getSocketFactory()).isSameAs(customSslSocketFactory); } @Test public void testSecondMongoDbFactory() { - assertTrue(ctx.containsBean("secondMongoDbFactory")); + assertThat(ctx.containsBean("secondMongoDbFactory")).isTrue(); MongoDbFactory dbf = (MongoDbFactory) ctx.getBean("secondMongoDbFactory"); MongoClient mongo = (MongoClient) getField(dbf, "mongoClient"); - assertEquals("127.0.0.1", mongo.getAddress().getHost()); - assertEquals(27017, mongo.getAddress().getPort()); - assertEquals("database", getField(dbf, "databaseName")); + assertThat(mongo.getAddress().getHost()).isEqualTo("127.0.0.1"); + assertThat(mongo.getAddress().getPort()).isEqualTo(27017); + assertThat(getField(dbf, "databaseName")).isEqualTo("database"); } @Test // DATAMONGO-789 public void testThirdMongoDbFactory() { - assertTrue(ctx.containsBean("thirdMongoDbFactory")); + assertThat(ctx.containsBean("thirdMongoDbFactory")).isTrue(); MongoDbFactory dbf = (MongoDbFactory) ctx.getBean("thirdMongoDbFactory"); MongoClient mongo = (MongoClient) getField(dbf, "mongoClient"); - assertEquals("127.0.0.1", mongo.getAddress().getHost()); - assertEquals(27017, mongo.getAddress().getPort()); - assertEquals("database", getField(dbf, "databaseName")); + assertThat(mongo.getAddress().getHost()).isEqualTo("127.0.0.1"); + assertThat(mongo.getAddress().getPort()).isEqualTo(27017); + assertThat(getField(dbf, "databaseName")).isEqualTo("database"); } @Test // DATAMONGO-140 public void testMongoTemplateFactory() { - assertTrue(ctx.containsBean("mongoTemplate")); + assertThat(ctx.containsBean("mongoTemplate")).isTrue(); MongoOperations operations = (MongoOperations) ctx.getBean("mongoTemplate"); MongoDbFactory dbf = (MongoDbFactory) getField(operations, "mongoDbFactory"); - assertEquals("database", getField(dbf, "databaseName")); + assertThat(getField(dbf, "databaseName")).isEqualTo("database"); MongoConverter converter = (MongoConverter) getField(operations, "mongoConverter"); - assertNotNull(converter); + assertThat(converter).isNotNull(); } @Test // DATAMONGO-140 public void testSecondMongoTemplateFactory() { - assertTrue(ctx.containsBean("anotherMongoTemplate")); + assertThat(ctx.containsBean("anotherMongoTemplate")).isTrue(); MongoOperations operations = (MongoOperations) ctx.getBean("anotherMongoTemplate"); MongoDbFactory dbf = (MongoDbFactory) getField(operations, "mongoDbFactory"); - assertEquals("database", getField(dbf, "databaseName")); + assertThat(getField(dbf, "databaseName")).isEqualTo("database"); WriteConcern writeConcern = (WriteConcern) getField(operations, "writeConcern"); - assertEquals(WriteConcern.SAFE, writeConcern); + assertThat(writeConcern).isEqualTo(WriteConcern.SAFE); } @Test // DATAMONGO-628 public void testGridFsTemplateFactory() { - assertTrue(ctx.containsBean("gridFsTemplate")); + assertThat(ctx.containsBean("gridFsTemplate")).isTrue(); GridFsOperations operations = (GridFsOperations) ctx.getBean("gridFsTemplate"); MongoDbFactory dbf = (MongoDbFactory) getField(operations, "dbFactory"); - assertEquals("database", getField(dbf, "databaseName")); + assertThat(getField(dbf, "databaseName")).isEqualTo("database"); MongoConverter converter = (MongoConverter) getField(operations, "converter"); - assertNotNull(converter); + assertThat(converter).isNotNull(); } @Test // DATAMONGO-628 public void testSecondGridFsTemplateFactory() { - assertTrue(ctx.containsBean("secondGridFsTemplate")); + assertThat(ctx.containsBean("secondGridFsTemplate")).isTrue(); GridFsOperations operations = (GridFsOperations) ctx.getBean("secondGridFsTemplate"); MongoDbFactory dbf = (MongoDbFactory) getField(operations, "dbFactory"); - assertEquals("database", getField(dbf, "databaseName")); - assertEquals(null, getField(operations, "bucket")); + assertThat(getField(dbf, "databaseName")).isEqualTo("database"); + assertThat(getField(operations, "bucket")).isEqualTo(null); MongoConverter converter = (MongoConverter) getField(operations, "converter"); - assertNotNull(converter); + assertThat(converter).isNotNull(); } @Test // DATAMONGO-823 public void testThirdGridFsTemplateFactory() { - assertTrue(ctx.containsBean("thirdGridFsTemplate")); + assertThat(ctx.containsBean("thirdGridFsTemplate")).isTrue(); GridFsOperations operations = (GridFsOperations) ctx.getBean("thirdGridFsTemplate"); MongoDbFactory dbf = (MongoDbFactory) getField(operations, "dbFactory"); - assertEquals("database", getField(dbf, "databaseName")); - assertEquals("bucketString", getField(operations, "bucket")); + assertThat(getField(dbf, "databaseName")).isEqualTo("database"); + assertThat(getField(operations, "bucket")).isEqualTo("bucketString"); MongoConverter converter = (MongoConverter) getField(operations, "converter"); - assertNotNull(converter); + assertThat(converter).isNotNull(); } @Test @SuppressWarnings("deprecation") public void testMongoSingletonWithPropertyPlaceHolders() throws Exception { - assertTrue(ctx.containsBean("mongoClient")); + assertThat(ctx.containsBean("mongoClient")).isTrue(); MongoClientFactoryBean mfb = (MongoClientFactoryBean) ctx.getBean("&mongoClient"); String host = (String) getField(mfb, "host"); Integer port = (Integer) getField(mfb, "port"); - assertEquals("127.0.0.1", host); - assertEquals(new Integer(27017), port); + assertThat(host).isEqualTo("127.0.0.1"); + assertThat(port).isEqualTo(new Integer(27017)); MongoClient mongo = mfb.getObject(); MongoClientOptions mongoOpts = mongo.getMongoClientOptions(); - assertEquals(8, mongoOpts.getConnectionsPerHost()); - assertEquals(1000, mongoOpts.getConnectTimeout()); - assertEquals(1500, mongoOpts.getMaxWaitTime()); + assertThat(mongoOpts.getConnectionsPerHost()).isEqualTo(8); + assertThat(mongoOpts.getConnectTimeout()).isEqualTo(1000); + assertThat(mongoOpts.getMaxWaitTime()).isEqualTo(1500); - assertEquals(1500, mongoOpts.getSocketTimeout()); - assertEquals(4, mongoOpts.getThreadsAllowedToBlockForConnectionMultiplier()); + assertThat(mongoOpts.getSocketTimeout()).isEqualTo(1500); + assertThat(mongoOpts.getThreadsAllowedToBlockForConnectionMultiplier()).isEqualTo(4); // TODO: check the damned defaults // assertEquals("w", mongoOpts.getWriteConcern().getW()); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoParserIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoParserIntegrationTests.java index f5043adde..e0f16b949 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoParserIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoParserIntegrationTests.java @@ -15,13 +15,13 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.List; import org.junit.Before; import org.junit.Test; + import org.springframework.beans.PropertyValue; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionReader; @@ -58,10 +58,10 @@ public class MongoParserIntegrationTests { List values = definition.getPropertyValues().getPropertyValueList(); - assertThat(values.get(2).getValue(), instanceOf(BeanDefinition.class)); + assertThat(values.get(2).getValue()).isInstanceOf(BeanDefinition.class); BeanDefinition x = (BeanDefinition) values.get(2).getValue(); - assertThat(x.getPropertyValues().getPropertyValueList(), hasItem(new PropertyValue("writeConcern", "SAFE"))); + assertThat(x.getPropertyValues().getPropertyValueList()).contains(new PropertyValue("writeConcern", "SAFE")); factory.getBean("mongoClient"); } @@ -74,7 +74,7 @@ public class MongoParserIntegrationTests { AbstractApplicationContext context = new GenericApplicationContext(factory); context.refresh(); - assertThat(context.getBean("mongo2", Mongo.class), is(notNullValue())); + assertThat(context.getBean("mongo2", Mongo.class)).isNotNull(); context.close(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/ReadPreferencePropertyEditorUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/ReadPreferencePropertyEditorUnitTests.java index 257b80da1..f10ab6458 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/ReadPreferencePropertyEditorUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/ReadPreferencePropertyEditorUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Before; import org.junit.Rule; @@ -56,7 +55,7 @@ public class ReadPreferencePropertyEditorUnitTests { editor.setAsText("secondary"); - assertThat(editor.getValue(), is((Object) ReadPreference.secondary())); + assertThat(editor.getValue()).isEqualTo((Object) ReadPreference.secondary()); } @Test // DATAMONGO-1158 @@ -64,6 +63,6 @@ public class ReadPreferencePropertyEditorUnitTests { editor.setAsText("NEAREST"); - assertThat(editor.getValue(), is((Object) ReadPreference.nearest())); + assertThat(editor.getValue()).isEqualTo((Object) ReadPreference.nearest()); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/ServerAddressPropertyEditorUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/ServerAddressPropertyEditorUnitTests.java index 9f57f9a21..21276e599 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/ServerAddressPropertyEditorUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/ServerAddressPropertyEditorUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.io.IOException; import java.net.InetAddress; @@ -24,7 +23,6 @@ import java.net.UnknownHostException; import java.util.Arrays; import java.util.Collection; -import org.junit.Assert; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -78,7 +76,7 @@ public class ServerAddressPropertyEditorUnitTests { public void interpretEmptyStringAsNull() { editor.setAsText(""); - assertNull(editor.getValue()); + assertThat(editor.getValue()).isNull(); } @Test // DATAMONGO-808 @@ -161,13 +159,13 @@ public class ServerAddressPropertyEditorUnitTests { private static void assertSingleAddressWithPort(String hostAddress, Integer port, Object result) throws UnknownHostException { - assertThat(result, is(instanceOf(ServerAddress[].class))); + assertThat(result).isInstanceOf(ServerAddress[].class); Collection addresses = Arrays.asList((ServerAddress[]) result); - assertThat(addresses, hasSize(1)); + assertThat(addresses).hasSize(1); if (port == null) { - assertThat(addresses, hasItem(new ServerAddress(InetAddress.getByName(hostAddress)))); + assertThat(addresses).contains(new ServerAddress(InetAddress.getByName(hostAddress))); } else { - assertThat(addresses, hasItem(new ServerAddress(InetAddress.getByName(hostAddress), port))); + assertThat(addresses).contains(new ServerAddress(InetAddress.getByName(hostAddress), port)); } } @@ -176,7 +174,7 @@ public class ServerAddressPropertyEditorUnitTests { for (String hostname : hostnames) { try { InetAddress.getByName(hostname).isReachable(1500); - Assert.fail("Supposedly unresolveable hostname '" + hostname + "' can be resolved."); + fail("Supposedly unresolveable hostname '" + hostname + "' can be resolved."); } catch (IOException expected) { // ok } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultScriptOperationsTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultScriptOperationsTests.java index b6af070e6..8d557996e 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultScriptOperationsTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultScriptOperationsTests.java @@ -15,9 +15,7 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; -import static org.junit.Assume.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.query.Criteria.*; import static org.springframework.data.mongodb.core.query.Query.*; @@ -26,6 +24,7 @@ import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @@ -88,18 +87,18 @@ public class DefaultScriptOperationsTests { @Test // DATAMONGO-479 public void executeShouldDirectlyRunExecutableMongoScript() { - assertThat(scriptOps.execute(EXECUTABLE_SCRIPT, 10), is((Object) 10D)); + assertThat(scriptOps.execute(EXECUTABLE_SCRIPT, 10)).isEqualTo((Object) 10D); } @Test // DATAMONGO-479 public void saveShouldStoreCallableScriptCorrectly() { Query query = query(where("_id").is(SCRIPT_NAME)); - assumeThat(template.exists(query, JAVASCRIPT_COLLECTION_NAME), is(false)); + assertThat(template.exists(query, JAVASCRIPT_COLLECTION_NAME)).isFalse(); scriptOps.register(CALLABLE_SCRIPT); - assumeThat(template.exists(query, JAVASCRIPT_COLLECTION_NAME), is(true)); + assertThat(template.exists(query, JAVASCRIPT_COLLECTION_NAME)).isTrue(); } @Test // DATAMONGO-479 @@ -108,7 +107,7 @@ public class DefaultScriptOperationsTests { NamedMongoScript script = scriptOps.register(EXECUTABLE_SCRIPT); Query query = query(where("_id").is(script.getName())); - assumeThat(template.exists(query, JAVASCRIPT_COLLECTION_NAME), is(true)); + assertThat(template.exists(query, JAVASCRIPT_COLLECTION_NAME)).isTrue(); } @Test // DATAMONGO-479 @@ -117,11 +116,11 @@ public class DefaultScriptOperationsTests { scriptOps.register(CALLABLE_SCRIPT); Query query = query(where("_id").is(SCRIPT_NAME)); - assumeThat(template.exists(query, JAVASCRIPT_COLLECTION_NAME), is(true)); + assertThat(template.exists(query, JAVASCRIPT_COLLECTION_NAME)).isTrue(); Object result = scriptOps.call(CALLABLE_SCRIPT.getName(), 10); - assertThat(result, is((Object) 10D)); + assertThat(result).isEqualTo(10D); } @Test // DATAMONGO-479 @@ -129,12 +128,12 @@ public class DefaultScriptOperationsTests { scriptOps.register(CALLABLE_SCRIPT); - assertThat(scriptOps.exists(SCRIPT_NAME), is(true)); + assertThat(scriptOps.exists(SCRIPT_NAME)).isTrue(); } @Test // DATAMONGO-479 public void existsShouldReturnFalseIfScriptNotAvailableOnServer() { - assertThat(scriptOps.exists(SCRIPT_NAME), is(false)); + assertThat(scriptOps.exists(SCRIPT_NAME)).isFalse(); } @Test // DATAMONGO-479 @@ -144,7 +143,7 @@ public class DefaultScriptOperationsTests { Object result = scriptOps.call(SCRIPT_NAME, 10); - assertThat(result, is((Object) 10D)); + assertThat(result).isEqualTo((Object) 10D); } @Test(expected = UncategorizedDataAccessException.class) // DATAMONGO-479 @@ -157,16 +156,16 @@ public class DefaultScriptOperationsTests { scriptOps.register(CALLABLE_SCRIPT); - assertThat(scriptOps.getScriptNames(), hasItems("echo")); + assertThat(scriptOps.getScriptNames()).contains("echo"); } @Test // DATAMONGO-479 public void scriptNamesShouldReturnEmptySetWhenNoScriptRegistered() { - assertThat(scriptOps.getScriptNames(), is(empty())); + assertThat(scriptOps.getScriptNames()).isEmpty(); } @Test // DATAMONGO-1465 public void executeShouldNotQuoteStrings() { - assertThat(scriptOps.execute(EXECUTABLE_SCRIPT, "spring-data"), is((Object) "spring-data")); + assertThat(scriptOps.execute(EXECUTABLE_SCRIPT, "spring-data")).isEqualTo((Object) "spring-data"); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultScriptOperationsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultScriptOperationsUnitTests.java index 6ace6a8f4..d3cf7a66c 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultScriptOperationsUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultScriptOperationsUnitTests.java @@ -15,16 +15,16 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.core.IsNull.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; -import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.core.script.ExecutableMongoScript; import org.springframework.data.mongodb.core.script.NamedMongoScript; @@ -72,7 +72,7 @@ public class DefaultScriptOperationsUnitTests { ArgumentCaptor captor = ArgumentCaptor.forClass(NamedMongoScript.class); verify(mongoOperations, times(1)).save(captor.capture(), eq("system.js")); - Assert.assertThat(captor.getValue().getName(), notNullValue()); + assertThat(captor.getValue().getName()).isNotNull(); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-479 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/GeoCommandStatisticsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/GeoCommandStatisticsUnitTests.java index 31f3604c8..9590fd245 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/GeoCommandStatisticsUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/GeoCommandStatisticsUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; @@ -38,10 +37,10 @@ public class GeoCommandStatisticsUnitTests { public void fallsBackToNanIfNoAverageDistanceIsAvailable() { GeoCommandStatistics statistics = GeoCommandStatistics.from(new Document("stats", null)); - assertThat(statistics.getAverageDistance(), is(Double.NaN)); + assertThat(statistics.getAverageDistance()).isEqualTo(Double.NaN); statistics = GeoCommandStatistics.from(new Document("stats", new Document())); - assertThat(statistics.getAverageDistance(), is(Double.NaN)); + assertThat(statistics.getAverageDistance()).isEqualTo(Double.NaN); } @Test // DATAMONGO-1361 @@ -50,6 +49,6 @@ public class GeoCommandStatisticsUnitTests { GeoCommandStatistics statistics = GeoCommandStatistics .from(new Document("stats", new Document("avgDistance", 1.5))); - assertThat(statistics.getAverageDistance(), is(1.5)); + assertThat(statistics.getAverageDistance()).isEqualTo(1.5); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoClientOptionsFactoryBeanIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoClientOptionsFactoryBeanIntegrationTests.java index f6c296d25..b4a473485 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoClientOptionsFactoryBeanIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoClientOptionsFactoryBeanIntegrationTests.java @@ -15,10 +15,10 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; + import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.beans.factory.support.RootBeanDefinition; import org.springframework.data.mongodb.config.ReadPreferencePropertyEditor; @@ -45,6 +45,6 @@ public class MongoClientOptionsFactoryBeanIntegrationTests { factory.registerBeanDefinition("factory", definition); MongoClientOptionsFactoryBean bean = factory.getBean("&factory", MongoClientOptionsFactoryBean.class); - assertThat(ReflectionTestUtils.getField(bean, "readPreference"), is((Object) ReadPreference.nearest())); + assertThat(ReflectionTestUtils.getField(bean, "readPreference")).isEqualTo((Object) ReadPreference.nearest()); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoExceptionTranslatorUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoExceptionTranslatorUnitTests.java index 3dd0b31ee..1a469bb2c 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoExceptionTranslatorUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoExceptionTranslatorUnitTests.java @@ -15,14 +15,14 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.net.UnknownHostException; import org.bson.BsonDocument; import org.junit.Before; import org.junit.Test; + import org.springframework.core.NestedRuntimeException; import org.springframework.dao.DataAccessException; import org.springframework.dao.DataAccessResourceFailureException; @@ -127,7 +127,7 @@ public class MongoExceptionTranslatorUnitTests { public void translateUnsupportedException() { RuntimeException exception = new RuntimeException(); - assertThat(translator.translateExceptionIfPossible(exception), is(nullValue())); + assertThat(translator.translateExceptionIfPossible(exception)).isNull(); } @Test // DATAMONGO-2045 @@ -156,11 +156,11 @@ public class MongoExceptionTranslatorUnitTests { DataAccessException translated = translator.translateExceptionIfPossible(new MongoException(code, "")); - assertThat("Expected exception of type " + clazz.getName() + "!", translated, is(not(nullValue()))); + assertThat(translated).as("Expected exception of type " + clazz.getName() + "!").isNotNull(); Throwable cause = translated.getRootCause(); - assertThat(cause, is(instanceOf(MongoException.class))); - assertThat(((MongoException) cause).getCode(), is(code)); + assertThat(cause).isInstanceOf(MongoException.class); + assertThat(((MongoException) cause).getCode()).isEqualTo(code); } private static void expectExceptionWithCauseMessage(NestedRuntimeException e, @@ -171,11 +171,11 @@ public class MongoExceptionTranslatorUnitTests { private static void expectExceptionWithCauseMessage(NestedRuntimeException e, Class type, String message) { - assertThat(e, is(instanceOf(type))); + assertThat(e).isInstanceOf(type); if (message != null) { - assertThat(e.getRootCause(), is(notNullValue())); - assertThat(e.getRootCause().getMessage(), containsString(message)); + assertThat(e.getRootCause()).isNotNull(); + assertThat(e.getRootCause().getMessage()).contains(message); } } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateTests.java index f4e8f4cff..7466d0722 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateTests.java @@ -15,19 +15,11 @@ */ package org.springframework.data.mongodb.core; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.fail; -import static org.hamcrest.Matchers.*; -import static org.hamcrest.Matchers.not; -import static org.junit.Assert.*; -import static org.junit.Assert.assertThat; -import static org.junit.Assume.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.query.Criteria.*; import static org.springframework.data.mongodb.core.query.Query.*; import static org.springframework.data.mongodb.core.query.Update.*; -import com.mongodb.MongoClient; -import com.mongodb.client.model.IndexOptions; import lombok.AllArgsConstructor; import lombok.Data; import lombok.EqualsAndHashCode; @@ -45,10 +37,7 @@ import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; import java.util.stream.IntStream; -import org.assertj.core.api.Assertions; -import org.bson.Document; import org.bson.types.ObjectId; -import org.hamcrest.collection.IsMapContaining; import org.joda.time.DateTime; import org.junit.After; import org.junit.Before; @@ -56,6 +45,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.core.convert.converter.Converter; @@ -111,6 +101,7 @@ import org.springframework.util.StringUtils; import com.mongodb.BasicDBObject; import com.mongodb.DBObject; import com.mongodb.DBRef; +import com.mongodb.MongoClient; import com.mongodb.MongoException; import com.mongodb.ReadPreference; import com.mongodb.WriteConcern; @@ -119,6 +110,7 @@ import com.mongodb.client.ListIndexesIterable; import com.mongodb.client.MongoCollection; import com.mongodb.client.MongoCursor; import com.mongodb.client.model.Filters; +import com.mongodb.client.model.IndexOptions; import com.mongodb.client.result.DeleteResult; import com.mongodb.client.result.UpdateResult; @@ -251,8 +243,8 @@ public class MongoTemplateTests { template.insert(person); List result = template.find(new Query(Criteria.where("_id").is(person.getId())), Person.class); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(person)); + assertThat(result.size()).isEqualTo(1); + assertThat(result).contains(person); } @Test @@ -285,7 +277,7 @@ public class MongoTemplateTests { template.insert(person); fail("Expected DataIntegrityViolationException!"); } catch (DataIntegrityViolationException e) { - assertThat(e.getMessage(), containsString("E11000 duplicate key error")); + assertThat(e.getMessage()).contains("E11000 duplicate key error"); } } @@ -330,7 +322,7 @@ public class MongoTemplateTests { template.save(person); fail("Expected DataIntegrityViolationException!"); } catch (DataIntegrityViolationException e) { - assertThat(e.getMessage(), containsString("E11000 duplicate key error")); + assertThat(e.getMessage()).contains("E11000 duplicate key error"); } } @@ -361,7 +353,7 @@ public class MongoTemplateTests { org.bson.Document collectionOptions = getCollectionInfo(template.getCollectionName(Person.class)).get("options", org.bson.Document.class); - assertThat(collectionOptions.get("capped"), is(true)); + assertThat(collectionOptions.get("capped")).isEqualTo(true); } private org.bson.Document getCollectionInfo(String collectionName) { @@ -390,7 +382,7 @@ public class MongoTemplateTests { List indexInfo = new ArrayList(); coll.listIndexes().into(indexInfo); - assertThat(indexInfo.size(), is(2)); + assertThat(indexInfo.size()).isEqualTo(2); Object indexKey = null; boolean unique = false; for (org.bson.Document ix : indexInfo) { @@ -398,23 +390,23 @@ public class MongoTemplateTests { if ("age_-1".equals(ix.get("name"))) { indexKey = ix.get("key"); unique = (Boolean) ix.get("unique"); - assertThat(ix.get("dropDups"), is(nullValue())); + assertThat(ix.get("dropDups")).isNull(); } } - assertThat(((org.bson.Document) indexKey), IsMapContaining. hasEntry("age", -1)); - assertThat(unique, is(true)); + assertThat(((org.bson.Document) indexKey)).containsEntry("age", -1); + assertThat(unique).isTrue(); List indexInfoList = template.indexOps(Person.class).getIndexInfo(); - assertThat(indexInfoList.size(), is(2)); + assertThat(indexInfoList.size()).isEqualTo(2); IndexInfo ii = indexInfoList.get(1); - assertThat(ii.isUnique(), is(true)); - assertThat(ii.isSparse(), is(false)); + assertThat(ii.isUnique()).isTrue(); + assertThat(ii.isSparse()).isFalse(); List indexFields = ii.getIndexFields(); IndexField field = indexFields.get(0); - assertThat(field, is(IndexField.create("age", Direction.DESC))); + assertThat(field).isEqualTo(IndexField.create("age", Direction.DESC)); } @Test // DATAMONGO-746, DATAMONGO-2264 @@ -422,7 +414,7 @@ public class MongoTemplateTests { template.indexOps(Person.class).dropAllIndexes(); - assertThat(template.indexOps(Person.class).getIndexInfo().isEmpty(), is(true)); + assertThat(template.indexOps(Person.class).getIndexInfo().isEmpty()).isTrue(); factory.getDb().getCollection(template.getCollectionName(Person.class)) .createIndex(new org.bson.Document("age", -1), new IndexOptions().name("age_-1").unique(true).sparse(true)); @@ -444,17 +436,17 @@ public class MongoTemplateTests { } } - assertThat(indexKey, IsMapContaining. hasEntry("age", -1)); - assertThat(unique, is(true)); + assertThat(indexKey).containsEntry("age", -1); + assertThat(unique).isTrue(); IndexInfo info = template.indexOps(Person.class).getIndexInfo().get(1); - assertThat(info.isUnique(), is(true)); - assertThat(info.isSparse(), is(true)); + assertThat(info.isUnique()).isTrue(); + assertThat(info.isSparse()).isTrue(); List indexFields = info.getIndexFields(); IndexField field = indexFields.get(0); - assertThat(field, is(IndexField.create("age", Direction.DESC))); + assertThat(field).isEqualTo(IndexField.create("age", Direction.DESC)); } @Test @@ -472,11 +464,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p1); // also try save mongoTemplate.save(p1); - assertThat(p1.getId(), notNullValue()); + assertThat(p1.getId()).isNotNull(); PersonWithIdPropertyOfTypeString p1q = mongoTemplate.findOne(new Query(where("id").is(p1.getId())), PersonWithIdPropertyOfTypeString.class); - assertThat(p1q, notNullValue()); - assertThat(p1q.getId(), is(p1.getId())); + assertThat(p1q).isNotNull(); + assertThat(p1q.getId()).isEqualTo(p1.getId()); checkCollectionContents(PersonWithIdPropertyOfTypeString.class, 1); // String id - provided @@ -488,11 +480,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p2); // also try save mongoTemplate.save(p2); - assertThat(p2.getId(), notNullValue()); + assertThat(p2.getId()).isNotNull(); PersonWithIdPropertyOfTypeString p2q = mongoTemplate.findOne(new Query(where("id").is(p2.getId())), PersonWithIdPropertyOfTypeString.class); - assertThat(p2q, notNullValue()); - assertThat(p2q.getId(), is(p2.getId())); + assertThat(p2q).isNotNull(); + assertThat(p2q.getId()).isEqualTo(p2.getId()); checkCollectionContents(PersonWithIdPropertyOfTypeString.class, 2); // String _id - generated @@ -503,11 +495,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p3); // also try save mongoTemplate.save(p3); - assertThat(p3.get_id(), notNullValue()); + assertThat(p3.get_id()).isNotNull(); PersonWith_idPropertyOfTypeString p3q = mongoTemplate.findOne(new Query(where("_id").is(p3.get_id())), PersonWith_idPropertyOfTypeString.class); - assertThat(p3q, notNullValue()); - assertThat(p3q.get_id(), is(p3.get_id())); + assertThat(p3q).isNotNull(); + assertThat(p3q.get_id()).isEqualTo(p3.get_id()); checkCollectionContents(PersonWith_idPropertyOfTypeString.class, 1); // String _id - provided @@ -519,11 +511,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p4); // also try save mongoTemplate.save(p4); - assertThat(p4.get_id(), notNullValue()); + assertThat(p4.get_id()).isNotNull(); PersonWith_idPropertyOfTypeString p4q = mongoTemplate.findOne(new Query(where("_id").is(p4.get_id())), PersonWith_idPropertyOfTypeString.class); - assertThat(p4q, notNullValue()); - assertThat(p4q.get_id(), is(p4.get_id())); + assertThat(p4q).isNotNull(); + assertThat(p4q.get_id()).isEqualTo(p4.get_id()); checkCollectionContents(PersonWith_idPropertyOfTypeString.class, 2); // ObjectId id - generated @@ -534,11 +526,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p5); // also try save mongoTemplate.save(p5); - assertThat(p5.getId(), notNullValue()); + assertThat(p5.getId()).isNotNull(); PersonWithIdPropertyOfTypeObjectId p5q = mongoTemplate.findOne(new Query(where("id").is(p5.getId())), PersonWithIdPropertyOfTypeObjectId.class); - assertThat(p5q, notNullValue()); - assertThat(p5q.getId(), is(p5.getId())); + assertThat(p5q).isNotNull(); + assertThat(p5q.getId()).isEqualTo(p5.getId()); checkCollectionContents(PersonWithIdPropertyOfTypeObjectId.class, 1); // ObjectId id - provided @@ -550,11 +542,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p6); // also try save mongoTemplate.save(p6); - assertThat(p6.getId(), notNullValue()); + assertThat(p6.getId()).isNotNull(); PersonWithIdPropertyOfTypeObjectId p6q = mongoTemplate.findOne(new Query(where("id").is(p6.getId())), PersonWithIdPropertyOfTypeObjectId.class); - assertThat(p6q, notNullValue()); - assertThat(p6q.getId(), is(p6.getId())); + assertThat(p6q).isNotNull(); + assertThat(p6q.getId()).isEqualTo(p6.getId()); checkCollectionContents(PersonWithIdPropertyOfTypeObjectId.class, 2); // ObjectId _id - generated @@ -565,11 +557,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p7); // also try save mongoTemplate.save(p7); - assertThat(p7.get_id(), notNullValue()); + assertThat(p7.get_id()).isNotNull(); PersonWith_idPropertyOfTypeObjectId p7q = mongoTemplate.findOne(new Query(where("_id").is(p7.get_id())), PersonWith_idPropertyOfTypeObjectId.class); - assertThat(p7q, notNullValue()); - assertThat(p7q.get_id(), is(p7.get_id())); + assertThat(p7q).isNotNull(); + assertThat(p7q.get_id()).isEqualTo(p7.get_id()); checkCollectionContents(PersonWith_idPropertyOfTypeObjectId.class, 1); // ObjectId _id - provided @@ -581,11 +573,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p8); // also try save mongoTemplate.save(p8); - assertThat(p8.get_id(), notNullValue()); + assertThat(p8.get_id()).isNotNull(); PersonWith_idPropertyOfTypeObjectId p8q = mongoTemplate.findOne(new Query(where("_id").is(p8.get_id())), PersonWith_idPropertyOfTypeObjectId.class); - assertThat(p8q, notNullValue()); - assertThat(p8q.get_id(), is(p8.get_id())); + assertThat(p8q).isNotNull(); + assertThat(p8q.get_id()).isEqualTo(p8.get_id()); checkCollectionContents(PersonWith_idPropertyOfTypeObjectId.class, 2); // Integer id - provided @@ -597,11 +589,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p9); // also try save mongoTemplate.save(p9); - assertThat(p9.getId(), notNullValue()); + assertThat(p9.getId()).isNotNull(); PersonWithIdPropertyOfTypeInteger p9q = mongoTemplate.findOne(new Query(where("id").in(p9.getId())), PersonWithIdPropertyOfTypeInteger.class); - assertThat(p9q, notNullValue()); - assertThat(p9q.getId(), is(p9.getId())); + assertThat(p9q).isNotNull(); + assertThat(p9q.getId()).isEqualTo(p9.getId()); checkCollectionContents(PersonWithIdPropertyOfTypeInteger.class, 1); // DATAMONGO-602 @@ -614,11 +606,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p9bi); // also try save mongoTemplate.save(p9bi); - assertThat(p9bi.getId(), notNullValue()); + assertThat(p9bi.getId()).isNotNull(); PersonWithIdPropertyOfTypeBigInteger p9qbi = mongoTemplate.findOne(new Query(where("id").in(p9bi.getId())), PersonWithIdPropertyOfTypeBigInteger.class); - assertThat(p9qbi, notNullValue()); - assertThat(p9qbi.getId(), is(p9bi.getId())); + assertThat(p9qbi).isNotNull(); + assertThat(p9qbi.getId()).isEqualTo(p9bi.getId()); checkCollectionContents(PersonWithIdPropertyOfTypeBigInteger.class, 1); // int id - provided @@ -630,11 +622,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p10); // also try save mongoTemplate.save(p10); - assertThat(p10.getId(), notNullValue()); + assertThat(p10.getId()).isNotNull(); PersonWithIdPropertyOfPrimitiveInt p10q = mongoTemplate.findOne(new Query(where("id").in(p10.getId())), PersonWithIdPropertyOfPrimitiveInt.class); - assertThat(p10q, notNullValue()); - assertThat(p10q.getId(), is(p10.getId())); + assertThat(p10q).isNotNull(); + assertThat(p10q.getId()).isEqualTo(p10.getId()); checkCollectionContents(PersonWithIdPropertyOfPrimitiveInt.class, 1); // Long id - provided @@ -646,11 +638,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p11); // also try save mongoTemplate.save(p11); - assertThat(p11.getId(), notNullValue()); + assertThat(p11.getId()).isNotNull(); PersonWithIdPropertyOfTypeLong p11q = mongoTemplate.findOne(new Query(where("id").in(p11.getId())), PersonWithIdPropertyOfTypeLong.class); - assertThat(p11q, notNullValue()); - assertThat(p11q.getId(), is(p11.getId())); + assertThat(p11q).isNotNull(); + assertThat(p11q.getId()).isEqualTo(p11.getId()); checkCollectionContents(PersonWithIdPropertyOfTypeLong.class, 1); // long id - provided @@ -662,11 +654,11 @@ public class MongoTemplateTests { mongoTemplate.insert(p12); // also try save mongoTemplate.save(p12); - assertThat(p12.getId(), notNullValue()); + assertThat(p12.getId()).isNotNull(); PersonWithIdPropertyOfPrimitiveLong p12q = mongoTemplate.findOne(new Query(where("id").in(p12.getId())), PersonWithIdPropertyOfPrimitiveLong.class); - assertThat(p12q, notNullValue()); - assertThat(p12q.getId(), is(p12.getId())); + assertThat(p12q).isNotNull(); + assertThat(p12q.getId()).isEqualTo(p12.getId()); checkCollectionContents(PersonWithIdPropertyOfPrimitiveLong.class, 1); // DATAMONGO-1617 @@ -678,16 +670,16 @@ public class MongoTemplateTests { mongoTemplate.insert(p13); // also try save mongoTemplate.save(p13); - assertThat(p13.getId(), notNullValue()); + assertThat(p13.getId()).isNotNull(); PersonWithIdPropertyOfTypeUUID p13q = mongoTemplate.findOne(new Query(where("id").in(p13.getId())), PersonWithIdPropertyOfTypeUUID.class); - assertThat(p13q, notNullValue()); - assertThat(p13q.getId(), is(p13.getId())); + assertThat(p13q).isNotNull(); + assertThat(p13q.getId()).isEqualTo(p13.getId()); checkCollectionContents(PersonWithIdPropertyOfTypeUUID.class, 1); } private void checkCollectionContents(Class entityClass, int count) { - assertThat(template.findAll(entityClass).size(), is(count)); + assertThat(template.findAll(entityClass).size()).isEqualTo(count); } @Test // DATAMONGO-234 @@ -700,28 +692,28 @@ public class MongoTemplateTests { Query query = new Query(Criteria.where("firstName").is("Harry")); Update update = new Update().inc("age", 1); Person p = template.findAndModify(query, update, Person.class); // return old - assertThat(p.getFirstName(), is("Harry")); - assertThat(p.getAge(), is(23)); + assertThat(p.getFirstName()).isEqualTo("Harry"); + assertThat(p.getAge()).isEqualTo(23); p = template.findOne(query, Person.class); - assertThat(p.getAge(), is(24)); + assertThat(p.getAge()).isEqualTo(24); p = template.findAndModify(query, update, Person.class, "person"); - assertThat(p.getAge(), is(24)); + assertThat(p.getAge()).isEqualTo(24); p = template.findOne(query, Person.class); - assertThat(p.getAge(), is(25)); + assertThat(p.getAge()).isEqualTo(25); p = template.findAndModify(query, update, new FindAndModifyOptions().returnNew(true), Person.class); - assertThat(p.getAge(), is(26)); + assertThat(p.getAge()).isEqualTo(26); p = template.findAndModify(query, update, new FindAndModifyOptions(), Person.class, "person"); - assertThat(p.getAge(), is(26)); + assertThat(p.getAge()).isEqualTo(26); p = template.findOne(query, Person.class); - assertThat(p.getAge(), is(27)); + assertThat(p.getAge()).isEqualTo(27); Query query2 = new Query(Criteria.where("firstName").is("Mary")); p = template.findAndModify(query2, update, new FindAndModifyOptions().returnNew(true).upsert(true), Person.class); - assertThat(p.getFirstName(), is("Mary")); - assertThat(p.getAge(), is(1)); + assertThat(p.getFirstName()).isEqualTo("Mary"); + assertThat(p.getAge()).isEqualTo(1); } @@ -733,8 +725,8 @@ public class MongoTemplateTests { Update update = new Update().set("age", 23); Person p = template.findAndModify(query, update, new FindAndModifyOptions().upsert(true).returnNew(true), Person.class); - assertThat(p.getFirstName(), is("Harry")); - assertThat(p.getAge(), is(23)); + assertThat(p.getFirstName()).isEqualTo("Harry"); + assertThat(p.getAge()).isEqualTo(23); } @Test @@ -750,9 +742,9 @@ public class MongoTemplateTests { Message found2 = template.findAndRemove(q, Message.class); Message notFound = template.findAndRemove(q, Message.class); - assertThat(found1, notNullValue()); - assertThat(found2, notNullValue()); - assertThat(notFound, nullValue()); + assertThat(found1).isNotNull(); + assertThat(found2).isNotNull(); + assertThat(notFound).isNull(); } @Test // DATAMONGO-1761 @@ -791,8 +783,7 @@ public class MongoTemplateTests { template.insert(new Person("garvin")); - assertThat(template.findDistinct("firstName", Person.class, Object.class)) - .allSatisfy(val -> instanceOf(String.class)); + assertThat(template.findDistinct("firstName", Person.class, Object.class)).allSatisfy(String.class::isInstance); } @Test // DATAMONGO-1761 @@ -852,9 +843,9 @@ public class MongoTemplateTests { List results2 = template.find(q2, PersonWithIdPropertyOfTypeObjectId.class); Query q3 = new Query(Criteria.where("id").in(p3.getId())); List results3 = template.find(q3, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(results1.size(), is(3)); - assertThat(results2.size(), is(2)); - assertThat(results3.size(), is(1)); + assertThat(results1.size()).isEqualTo(3); + assertThat(results2.size()).isEqualTo(2); + assertThat(results3.size()).isEqualTo(1); } @Test @@ -885,9 +876,9 @@ public class MongoTemplateTests { List results2 = template.find(q2, PersonWithIdPropertyOfTypeString.class); Query q3 = new Query(Criteria.where("id").in(p3.getId(), p4.getId())); List results3 = template.find(q3, PersonWithIdPropertyOfTypeString.class); - assertThat(results1.size(), is(3)); - assertThat(results2.size(), is(2)); - assertThat(results3.size(), is(2)); + assertThat(results1.size()).isEqualTo(3); + assertThat(results2.size()).isEqualTo(2); + assertThat(results3.size()).isEqualTo(2); } @Test @@ -922,9 +913,9 @@ public class MongoTemplateTests { List results2 = template.find(q2, PersonWithIdPropertyOfTypeLong.class); Query q3 = new Query(Criteria.where("id").in(1001L, 1004L)); List results3 = template.find(q3, PersonWithIdPropertyOfTypeLong.class); - assertThat(results1.size(), is(3)); - assertThat(results2.size(), is(2)); - assertThat(results3.size(), is(2)); + assertThat(results1.size()).isEqualTo(3); + assertThat(results2.size()).isEqualTo(2); + assertThat(results3.size()).isEqualTo(2); } @Test // DATAMONGO-602 @@ -960,9 +951,9 @@ public class MongoTemplateTests { Query q3 = new Query(Criteria.where("id").in(new BigInteger("2666666666666666665069473312490162649510603601"), new BigInteger("2666666666666666665069473312490162649510603604"))); List results3 = template.find(q3, PersonWithIdPropertyOfTypeBigInteger.class); - assertThat(results1.size(), is(3)); - assertThat(results2.size(), is(2)); - assertThat(results3.size(), is(2)); + assertThat(results1.size()).isEqualTo(3); + assertThat(results2.size()).isEqualTo(2); + assertThat(results3.size()).isEqualTo(2); } @Test @@ -997,9 +988,9 @@ public class MongoTemplateTests { List results2 = template.find(q2, PersonWithIdPropertyOfPrimitiveInt.class); Query q3 = new Query(Criteria.where("id").in(1001, 1003)); List results3 = template.find(q3, PersonWithIdPropertyOfPrimitiveInt.class); - assertThat(results1.size(), is(3)); - assertThat(results2.size(), is(2)); - assertThat(results3.size(), is(2)); + assertThat(results1.size()).isEqualTo(3); + assertThat(results2.size()).isEqualTo(2); + assertThat(results3.size()).isEqualTo(2); } @Test @@ -1032,8 +1023,8 @@ public class MongoTemplateTests { List results1 = template.find(q1, PersonWithIdPropertyOfTypeObjectId.class); Query q2 = new Query(Criteria.where("age").in(l1.toArray())); List results2 = template.find(q2, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(results1.size(), is(3)); - assertThat(results2.size(), is(3)); + assertThat(results1.size()).isEqualTo(3); + assertThat(results2.size()).isEqualTo(3); try { List l2 = new ArrayList(); l2.add(31); @@ -1069,8 +1060,8 @@ public class MongoTemplateTests { List results1 = template.find(q1, PersonWithIdPropertyOfTypeObjectId.class); Query q2 = new Query(Criteria.where("firstName").regex("S.*", "i")); List results2 = template.find(q2, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(results1.size(), is(1)); - assertThat(results2.size(), is(2)); + assertThat(results1.size()).isEqualTo(1); + assertThat(results2.size()).isEqualTo(2); } @Test @@ -1097,9 +1088,9 @@ public class MongoTemplateTests { Query orQuery = new Query(new Criteria().orOperator(where("age").in(11, 21), where("age").is(31))); List results = template.find(orQuery, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(results.size(), is(3)); + assertThat(results.size()).isEqualTo(3); for (PersonWithIdPropertyOfTypeObjectId p : results) { - assertThat(p.getAge(), isOneOf(11, 21, 31)); + assertThat(p.getAge()).isIn(11, 21, 31); } } @@ -1122,18 +1113,18 @@ public class MongoTemplateTests { UpdateResult wr = template.updateMulti(new Query(), u, PersonWithIdPropertyOfTypeObjectId.class); if (wr.wasAcknowledged()) { - assertThat(wr.getModifiedCount(), is(2L)); + assertThat(wr.getModifiedCount()).isEqualTo(2L); } Query q1 = new Query(Criteria.where("age").in(11, 21)); List r1 = template.find(q1, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(r1.size(), is(0)); + assertThat(r1.size()).isEqualTo(0); Query q2 = new Query(Criteria.where("age").is(10)); List r2 = template.find(q2, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(r2.size(), is(2)); + assertThat(r2.size()).isEqualTo(2); for (PersonWithIdPropertyOfTypeObjectId p : r2) { - assertThat(p.getAge(), is(10)); - assertThat(p.getFirstName(), is("Bob")); + assertThat(p.getAge()).isEqualTo(10); + assertThat(p.getFirstName()).isEqualTo("Bob"); } } @@ -1147,11 +1138,11 @@ public class MongoTemplateTests { Query q1 = new Query(Criteria.where("id").is(p1.getId())); PersonWithIdPropertyOfTypeObjectId found1 = template.findOne(q1, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(found1, notNullValue()); + assertThat(found1).isNotNull(); Query _q = new Query(Criteria.where("_id").is(p1.getId())); template.remove(_q, PersonWithIdPropertyOfTypeObjectId.class); PersonWithIdPropertyOfTypeObjectId notFound1 = template.findOne(q1, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(notFound1, nullValue()); + assertThat(notFound1).isNull(); PersonWithIdPropertyOfTypeObjectId p2 = new PersonWithIdPropertyOfTypeObjectId(); p2.setFirstName("Bubba_to_be_removed"); @@ -1160,10 +1151,10 @@ public class MongoTemplateTests { Query q2 = new Query(Criteria.where("id").is(p2.getId())); PersonWithIdPropertyOfTypeObjectId found2 = template.findOne(q2, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(found2, notNullValue()); + assertThat(found2).isNotNull(); template.remove(q2, PersonWithIdPropertyOfTypeObjectId.class); PersonWithIdPropertyOfTypeObjectId notFound2 = template.findOne(q2, PersonWithIdPropertyOfTypeObjectId.class); - assertThat(notFound2, nullValue()); + assertThat(notFound2).isNull(); } @Test @@ -1175,16 +1166,16 @@ public class MongoTemplateTests { Query q1 = new Query(Criteria.where("id").is(p.getId())); PersonWithAList p2 = template.findOne(q1, PersonWithAList.class); - assertThat(p2, notNullValue()); - assertThat(p2.getWishList().size(), is(0)); + assertThat(p2).isNotNull(); + assertThat(p2.getWishList().size()).isEqualTo(0); p2.addToWishList("please work!"); template.save(p2); PersonWithAList p3 = template.findOne(q1, PersonWithAList.class); - assertThat(p3, notNullValue()); - assertThat(p3.getWishList().size(), is(1)); + assertThat(p3).isNotNull(); + assertThat(p3.getWishList().size()).isEqualTo(1); Friend f = new Friend(); p.setFirstName("Erik"); @@ -1194,9 +1185,9 @@ public class MongoTemplateTests { template.save(p3); PersonWithAList p4 = template.findOne(q1, PersonWithAList.class); - assertThat(p4, notNullValue()); - assertThat(p4.getWishList().size(), is(1)); - assertThat(p4.getFriends().size(), is(1)); + assertThat(p4).isNotNull(); + assertThat(p4.getWishList().size()).isEqualTo(1); + assertThat(p4.getFriends().size()).isEqualTo(1); } @@ -1221,7 +1212,7 @@ public class MongoTemplateTests { Query q2 = new Query(Criteria.where("age").gt(10)); q2.with(Sort.by(Direction.DESC, "age")); PersonWithAList p5 = template.findOne(q2, PersonWithAList.class); - assertThat(p5.getFirstName(), is("Mark")); + assertThat(p5.getFirstName()).isEqualTo("Mark"); } @Test @@ -1240,7 +1231,7 @@ public class MongoTemplateTests { slaveTemplate.execute("readPref", new CollectionCallback() { public Object doInCollection(MongoCollection collection) throws MongoException, DataAccessException { - assertThat(collection.getReadPreference(), is(ReadPreference.secondary())); + assertThat(collection.getReadPreference()).isEqualTo(ReadPreference.secondary()); // assertThat(collection.getDB().getOptions(), is(0)); return null; } @@ -1265,9 +1256,9 @@ public class MongoTemplateTests { PersonWithIdPropertyOfTypeObjectId result = template.findById(person.getId(), PersonWithIdPropertyOfTypeObjectId.class); - assertThat(result, is(notNullValue())); - assertThat(result.getId(), is(person.getId())); - assertThat(result.getFirstName(), is("Carter")); + assertThat(result).isNotNull(); + assertThat(result.getId()).isEqualTo(person.getId()); + assertThat(result.getFirstName()).isEqualTo("Carter"); } @Test @@ -1289,12 +1280,13 @@ public class MongoTemplateTests { template.updateFirst(q, u, PersonWithIdPropertyOfTypeObjectId.class); MongoAction lastMongoAction = resolver.getMongoAction(); - assertThat(lastMongoAction.getCollectionName(), is("personWithIdPropertyOfTypeObjectId")); - assertThat(lastMongoAction.getDefaultWriteConcern(), equalTo(WriteConcern.UNACKNOWLEDGED)); - assertThat(lastMongoAction.getDocument(), notNullValue()); - assertThat(lastMongoAction.getEntityType().toString(), is(PersonWithIdPropertyOfTypeObjectId.class.toString())); - assertThat(lastMongoAction.getMongoActionOperation(), is(MongoActionOperation.UPDATE)); - assertThat(lastMongoAction.getQuery(), equalTo(q.getQueryObject())); + assertThat(lastMongoAction.getCollectionName()).isEqualTo("personWithIdPropertyOfTypeObjectId"); + assertThat(lastMongoAction.getDefaultWriteConcern()).isEqualTo(WriteConcern.UNACKNOWLEDGED); + assertThat(lastMongoAction.getDocument()).isNotNull(); + assertThat(lastMongoAction.getEntityType().toString()) + .isEqualTo(PersonWithIdPropertyOfTypeObjectId.class.toString()); + assertThat(lastMongoAction.getMongoActionOperation()).isEqualTo(MongoActionOperation.UPDATE); + assertThat(lastMongoAction.getQuery()).isEqualTo(q.getQueryObject()); } private class FsyncSafeWriteConcernResolver implements WriteConcernResolver { @@ -1338,7 +1330,7 @@ public class MongoTemplateTests { } } }); - assertEquals(3, names.size()); + assertThat(names.size()).isEqualTo(3); // template.remove(new Query(), Person.class); } @@ -1363,14 +1355,14 @@ public class MongoTemplateTests { } }); - assertEquals(1, names.size()); + assertThat(names.size()).isEqualTo(1); template.remove(new Query(), Person.class); } @Test // DATADOC-183 public void countsDocumentsCorrectly() { - assertThat(template.count(new Query(), Person.class), is(0L)); + assertThat(template.count(new Query(), Person.class)).isEqualTo(0L); Person dave = new Person("Dave"); Person carter = new Person("Carter"); @@ -1378,8 +1370,8 @@ public class MongoTemplateTests { template.save(dave); template.save(carter); - assertThat(template.count(new Query(), Person.class), is(2L)); - assertThat(template.count(query(where("firstName").is("Carter")), Person.class), is(1L)); + assertThat(template.count(new Query(), Person.class)).isEqualTo(2L); + assertThat(template.count(query(where("firstName").is("Carter")), Person.class)).isEqualTo(1L); } @Test(expected = IllegalArgumentException.class) // DATADOC-183 @@ -1406,8 +1398,8 @@ public class MongoTemplateTests { List testClassList = mappingTemplate.find(new Query(Criteria.where("myDate").is(dateTime.toDate())), TestClass.class); - assertThat(testClassList.size(), is(1)); - assertThat(testClassList.get(0).myDate, is(testClass.myDate)); + assertThat(testClassList.size()).isEqualTo(1); + assertThat(testClassList.get(0).myDate).isEqualTo(testClass.myDate); } @Test // DATADOC-230 @@ -1418,10 +1410,10 @@ public class MongoTemplateTests { Person person = new Person("Dave"); template.save(person, "mycollection"); - assertThat(template.findAll(TestClass.class, "mycollection").size(), is(1)); + assertThat(template.findAll(TestClass.class, "mycollection").size()).isEqualTo(1); template.remove(person, "mycollection"); - assertThat(template.findAll(Person.class, "mycollection").isEmpty(), is(true)); + assertThat(template.findAll(Person.class, "mycollection").isEmpty()).isTrue(); } @Test // DATADOC-349 @@ -1434,10 +1426,10 @@ public class MongoTemplateTests { template.save(sample); - assertThat(template.findOne(query(where("id").is(id)), Sample.class).id, is(id)); + assertThat(template.findOne(query(where("id").is(id)), Sample.class).id).isEqualTo(id); template.remove(sample); - assertThat(template.findOne(query(where("id").is(id)), Sample.class), is(nullValue())); + assertThat(template.findOne(query(where("id").is(id)), Sample.class)).isNull(); } @Test // DATAMONGO-423 @@ -1455,8 +1447,8 @@ public class MongoTemplateTests { Query query = query(where("field").not().regex("Matthews")); List result = template.find(query, Sample.class); - assertThat(result.size(), is(1)); - assertThat(result.get(0).field, is("Beauford")); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).field).isEqualTo("Beauford"); } @Test // DATAMONGO-447 @@ -1489,14 +1481,14 @@ public class MongoTemplateTests { Query query = new BasicQuery("{'name' : 'Oleg'}"); List result = template.find(query, MyPerson.class); - assertThat(result, hasSize(1)); - assertThat(result.get(0), hasProperty("name", is("Oleg"))); + assertThat(result).hasSize(1); + assertThat(result.get(0).getName()).isEqualTo("Oleg"); query = new BasicQuery("{'address.state' : 'PA' }"); result = template.find(query, MyPerson.class); - assertThat(result, hasSize(1)); - assertThat(result.get(0), hasProperty("name", is("Oleg"))); + assertThat(result).hasSize(1); + assertThat(result.get(0).getName()).isEqualTo("Oleg"); } @Test(expected = OptimisticLockingFailureException.class) // DATAMONGO-279 @@ -1511,8 +1503,8 @@ public class MongoTemplateTests { List result = template .findAll(PersonWithVersionPropertyOfTypeInteger.class); - assertThat(result, hasSize(1)); - assertThat(result.get(0).version, is(0)); + assertThat(result).hasSize(1); + assertThat(result.get(0).version).isEqualTo(0); // Version change person = result.get(0); @@ -1520,12 +1512,12 @@ public class MongoTemplateTests { template.save(person); - assertThat(person.version, is(1)); + assertThat(person.version).isEqualTo(1); result = mappingTemplate.findAll(PersonWithVersionPropertyOfTypeInteger.class); - assertThat(result, hasSize(1)); - assertThat(result.get(0).version, is(1)); + assertThat(result).hasSize(1); + assertThat(result.get(0).version).isEqualTo(1); // Optimistic lock exception person.version = 0; @@ -1561,7 +1553,7 @@ public class MongoTemplateTests { person.setAge(33); template.insert(person); - assertThat(person.getId(), is(notNullValue())); + assertThat(person.getId()).isNotNull(); } @Test // DATAMONGO-539 @@ -1573,10 +1565,10 @@ public class MongoTemplateTests { PersonWithConvertedId person = new PersonWithConvertedId(); person.name = "Dave"; template.save(person, collectionName); - assertThat(template.findAll(PersonWithConvertedId.class, collectionName).isEmpty(), is(false)); + assertThat(template.findAll(PersonWithConvertedId.class, collectionName).isEmpty()).isFalse(); template.remove(person, collectionName); - assertThat(template.findAll(PersonWithConvertedId.class, collectionName).isEmpty(), is(true)); + assertThat(template.findAll(PersonWithConvertedId.class, collectionName).isEmpty()).isTrue(); } // DATAMONGO-549 @@ -1604,7 +1596,7 @@ public class MongoTemplateTests { org.bson.Document document = new org.bson.Document("foo", "bar"); template.save(document, "collection"); - assertThat(document.containsKey("_id"), is(true)); + assertThat(document.containsKey("_id")).isTrue(); } @Test(expected = MappingException.class) // DATAMONGO-550, DATAMONGO-1730 @@ -1623,8 +1615,8 @@ public class MongoTemplateTests { template.save(document, "collection"); org.bson.Document result = template.findById(document.get("_id"), org.bson.Document.class, "collection"); - assertThat(result.get("foo"), is(document.get("foo"))); - assertThat(result.get("_id"), is(document.get("_id"))); + assertThat(result.get("foo")).isEqualTo(document.get("foo")); + assertThat(result.get("_id")).isEqualTo(document.get("_id")); } @Test // DATAMONGO-551 @@ -1645,7 +1637,7 @@ public class MongoTemplateTests { template.insert(person); - assertThat(person.version, is(0)); + assertThat(person.version).isEqualTo(0); } @Test // DATAMONGO-2195 @@ -1655,7 +1647,7 @@ public class MongoTemplateTests { person.firstName = "Dave"; template.insert(person); - assertThat(person.version, is(0)); + assertThat(person.version).isEqualTo(0); template.update(PersonWithVersionPropertyOfTypeInteger.class).matching(query(where("id").is(person.id))) .apply(new Update().set("firstName", "Walter")).first(); @@ -1674,7 +1666,7 @@ public class MongoTemplateTests { template.insertAll(Arrays.asList(person)); - assertThat(person.version, is(0)); + assertThat(person.version).isEqualTo(0); } @Test // DATAMONGO-1992 @@ -1684,12 +1676,12 @@ public class MongoTemplateTests { ImmutableVersioned saved = template.insert(versioned); - assertThat(saved, is(not(sameInstance(versioned)))); - assertThat(versioned.id, is(nullValue())); - assertThat(versioned.version, is(nullValue())); + assertThat(saved).isNotSameAs(versioned); + assertThat(versioned.id).isNull(); + assertThat(versioned.version).isNull(); - assertThat(saved.id, is(notNullValue())); - assertThat(saved.version, is(0L)); + assertThat(saved.id).isNotNull(); + assertThat(saved.version).isEqualTo(0L); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-568, DATAMONGO-1762 @@ -1704,10 +1696,10 @@ public class MongoTemplateTests { person.firstName = "Dave"; template.save(person, "personX"); - assertThat(person.version, is(0)); + assertThat(person.version).isEqualTo(0); template.save(person, "personX"); - assertThat(person.version, is(1)); + assertThat(person.version).isEqualTo(1); } @Test // DATAMONGO-621 @@ -1717,7 +1709,7 @@ public class MongoTemplateTests { person.firstName = "Dave"; template.save(person); - assertThat(person.version, is(0L)); + assertThat(person.version).isEqualTo(0L); } @Test(expected = DuplicateKeyException.class) // DATAMONGO-622 @@ -1729,7 +1721,7 @@ public class MongoTemplateTests { person.firstName = "Dave"; template.save(person); - assertThat(person.version, is(0)); + assertThat(person.version).isEqualTo(0); person.version = null; template.save(person); @@ -1744,8 +1736,8 @@ public class MongoTemplateTests { Query query = query(where("_id").is(person.getId())); String collectionName = template.getCollectionName(Person.class); - assertThat(template.find(query, HashMap.class, collectionName), hasSize(1)); - assertThat(template.count(query, collectionName), is(1L)); + assertThat(template.find(query, HashMap.class, collectionName)).hasSize(1); + assertThat(template.count(query, collectionName)).isEqualTo(1L); } @Test // DATAMONGO-571 @@ -1756,13 +1748,13 @@ public class MongoTemplateTests { person.lastname = "Matthews"; template.save(person); - assertThat(person.id, is(notNullValue())); + assertThat(person.id).isNotNull(); person.lastname = null; template.save(person); person = template.findOne(query(where("id").is(person.id)), VersionedPerson.class); - assertThat(person.lastname, is(nullValue())); + assertThat(person.lastname).isNull(); } @Test // DATAMONGO-571 @@ -1775,7 +1767,7 @@ public class MongoTemplateTests { template.save(person); person = template.findOne(query(where("id").is(person.getId())), Person.class); - assertThat(person.getFirstName(), is(nullValue())); + assertThat(person.getFirstName()).isNull(); } @Test // DATAMONGO-679 @@ -1786,8 +1778,8 @@ public class MongoTemplateTests { template.save(document, "collection"); List result = template.findAll(org.bson.Document.class, "collection"); - assertThat(result.size(), is(1)); - assertThat(result.get(0).containsKey("first"), is(true)); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).containsKey("first")).isTrue(); } @Test @@ -1798,9 +1790,9 @@ public class MongoTemplateTests { Query query = query(where("id").is(sample.id)); - assertThat(template.exists(query, Sample.class), is(true)); - assertThat(template.exists(query(where("_id").is(sample.id)), template.getCollectionName(Sample.class)), is(true)); - assertThat(template.exists(query, Sample.class, template.getCollectionName(Sample.class)), is(true)); + assertThat(template.exists(query, Sample.class)).isTrue(); + assertThat(template.exists(query(where("_id").is(sample.id)), template.getCollectionName(Sample.class))).isTrue(); + assertThat(template.exists(query, Sample.class, template.getCollectionName(Sample.class))).isTrue(); } @Test // DATAMONGO-675 @@ -1816,7 +1808,7 @@ public class MongoTemplateTests { FindAndModifyOptions options = new FindAndModifyOptions().returnNew(true); TypeWithFieldAnnotation result = template.findAndModify(query, update, options, TypeWithFieldAnnotation.class); - assertThat(result.emailAddress, is("new")); + assertThat(result.emailAddress).isEqualTo("new"); } @Test // DATAMONGO-671 @@ -1829,8 +1821,8 @@ public class MongoTemplateTests { Query query = query(where("date").lt(new Date())); List result = template.find(query, TypeWithDate.class); - assertThat(result, hasSize(1)); - assertThat(result.get(0).date, is(notNullValue())); + assertThat(result).hasSize(1); + assertThat(result.get(0).date).isNotNull(); } @Test // DATAMONGO-540 @@ -1845,9 +1837,9 @@ public class MongoTemplateTests { template.upsert(query, update, Sample.class); Sample result = template.findOne(query, Sample.class); - assertThat(result, is(notNullValue())); - assertThat(result.field, is(fieldValue)); - assertThat(result.id, is(idValue)); + assertThat(result).isNotNull(); + assertThat(result.field).isEqualTo(fieldValue); + assertThat(result.id).isEqualTo(idValue); } @Test // DATAMONGO-392 @@ -1865,10 +1857,10 @@ public class MongoTemplateTests { Document result = template.findOne(query, Document.class); - assertThat(result, is(notNullValue())); - assertThat(result.id, is(doc.id)); - assertThat(result.model, is(notNullValue())); - assertThat(result.model.value(), is(newModelValue)); + assertThat(result).isNotNull(); + assertThat(result.id).isEqualTo(doc.id); + assertThat(result.model).isNotNull(); + assertThat(result.model.value()).isEqualTo(newModelValue); } @Test // DATAMONGO-702 @@ -1889,10 +1881,10 @@ public class MongoTemplateTests { ObjectWith3AliasedFields result = template.findOne(query, ObjectWith3AliasedFields.class); - assertThat(result.id, is(obj.id)); - assertThat(result.property1, is(nullValue())); - assertThat(result.property2, is(obj.property2)); - assertThat(result.property3, is(obj.property3)); + assertThat(result.id).isEqualTo(obj.id); + assertThat(result.property1).isNull(); + assertThat(result.property2).isEqualTo(obj.property2); + assertThat(result.property3).isEqualTo(obj.property3); } @Test // DATAMONGO-702 @@ -1913,10 +1905,10 @@ public class MongoTemplateTests { ObjectWith3AliasedFields result = template.findOne(query, ObjectWith3AliasedFields.class); - assertThat(result.id, is(obj.id)); - assertThat(result.property1, is(obj.property1)); - assertThat(result.property2, is(nullValue())); - assertThat(result.property3, is(nullValue())); + assertThat(result.id).isEqualTo(obj.id); + assertThat(result.property1).isEqualTo(obj.property1); + assertThat(result.property2).isNull(); + assertThat(result.property3).isNull(); } @Test // DATAMONGO-702 @@ -1943,22 +1935,22 @@ public class MongoTemplateTests { List results = template.find(query, ObjectWith3AliasedFields.class); - assertThat(results, is(notNullValue())); - assertThat(results.size(), is(2)); + assertThat(results).isNotNull(); + assertThat(results.size()).isEqualTo(2); ObjectWith3AliasedFields result0 = results.get(0); - assertThat(result0, is(notNullValue())); - assertThat(result0.id, is(obj0.id)); - assertThat(result0.property1, is(obj0.property1)); - assertThat(result0.property2, is(nullValue())); - assertThat(result0.property3, is(nullValue())); + assertThat(result0).isNotNull(); + assertThat(result0.id).isEqualTo(obj0.id); + assertThat(result0.property1).isEqualTo(obj0.property1); + assertThat(result0.property2).isNull(); + assertThat(result0.property3).isNull(); ObjectWith3AliasedFields result1 = results.get(1); - assertThat(result1, is(notNullValue())); - assertThat(result1.id, is(obj1.id)); - assertThat(result1.property1, is(obj1.property1)); - assertThat(result1.property2, is(nullValue())); - assertThat(result1.property3, is(nullValue())); + assertThat(result1).isNotNull(); + assertThat(result1.id).isEqualTo(obj1.id); + assertThat(result1.property1).isEqualTo(obj1.property1); + assertThat(result1.property2).isNull(); + assertThat(result1.property3).isNull(); } @Test // DATAMONGO-702 @@ -1985,13 +1977,13 @@ public class MongoTemplateTests { ObjectWith3AliasedFieldsAndNestedAddress result = template.findOne(query, ObjectWith3AliasedFieldsAndNestedAddress.class); - assertThat(result.id, is(obj.id)); - assertThat(result.property1, is(nullValue())); - assertThat(result.property2, is(obj.property2)); - assertThat(result.property3, is(nullValue())); - assertThat(result.address, is(notNullValue())); - assertThat(result.address.city, is(nullValue())); - assertThat(result.address.state, is(stateValue)); + assertThat(result.id).isEqualTo(obj.id); + assertThat(result.property1).isNull(); + assertThat(result.property2).isEqualTo(obj.property2); + assertThat(result.property3).isNull(); + assertThat(result.address).isNotNull(); + assertThat(result.address.city).isNull(); + assertThat(result.address.state).isEqualTo(stateValue); } @Test // DATAMONGO-709 @@ -2015,9 +2007,9 @@ public class MongoTemplateTests { Query query = Query.query(where("value").is("foo")).restrict(SpecialDoc.class); List result = template.find(query, BaseDoc.class); - assertThat(result, is(notNullValue())); - assertThat(result.size(), is(1)); - assertThat(result.get(0), is(instanceOf(SpecialDoc.class))); + assertThat(result).isNotNull(); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0)).isInstanceOf(SpecialDoc.class); } @Test // DATAMONGO-709 @@ -2041,10 +2033,10 @@ public class MongoTemplateTests { Query query = Query.query(where("value").is("foo")).restrict(BaseDoc.class, VerySpecialDoc.class); List result = template.find(query, BaseDoc.class); - assertThat(result, is(notNullValue())); - assertThat(result.size(), is(2)); - assertThat(result.get(0).getClass(), is((Object) BaseDoc.class)); - assertThat(result.get(1).getClass(), is((Object) VerySpecialDoc.class)); + assertThat(result).isNotNull(); + assertThat(result.size()).isEqualTo(2); + assertThat(result.get(0).getClass()).isEqualTo((Object) BaseDoc.class); + assertThat(result.get(1).getClass()).isEqualTo((Object) VerySpecialDoc.class); } @Test // DATAMONGO-709 @@ -2068,11 +2060,11 @@ public class MongoTemplateTests { Query query = Query.query(where("value").is("foo")); List result = template.find(query, BaseDoc.class); - assertThat(result, is(notNullValue())); - assertThat(result.size(), is(3)); - assertThat(result.get(0).getClass(), is((Object) BaseDoc.class)); - assertThat(result.get(1).getClass(), is((Object) SpecialDoc.class)); - assertThat(result.get(2).getClass(), is((Object) VerySpecialDoc.class)); + assertThat(result).isNotNull(); + assertThat(result.size()).isEqualTo(3); + assertThat(result.get(0).getClass()).isEqualTo((Object) BaseDoc.class); + assertThat(result.get(1).getClass()).isEqualTo((Object) SpecialDoc.class); + assertThat(result.get(2).getClass()).isEqualTo((Object) VerySpecialDoc.class); } @Test // DATAMONGO-771 @@ -2085,9 +2077,9 @@ public class MongoTemplateTests { template.insert(json, "sample"); List result = template.findAll(Sample.class); - assertThat(result.size(), is(1)); - assertThat(result.get(0).id, is(id)); - assertThat(result.get(0).field, is(value)); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).id).isEqualTo(id); + assertThat(result.get(0).field).isEqualTo(value); } @Test // DATAMONGO-2028 @@ -2097,9 +2089,9 @@ public class MongoTemplateTests { template.insert(dbObject, "sample"); List result = template.findAll(org.bson.Document.class, "sample"); - assertThat(result.size(), is(1)); - assertThat(result.get(0).getString("_id"), is("foo")); - assertThat(result.get(0).getString("duration"), is("PT1M40S")); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).getString("_id")).isEqualTo("foo"); + assertThat(result.get(0).getString("duration")).isEqualTo("PT1M40S"); } @Test // DATAMONGO-816 @@ -2117,11 +2109,11 @@ public class MongoTemplateTests { @Override public void processDocument(org.bson.Document document) throws MongoException, DataAccessException { - assertThat(document, is(notNullValue())); + assertThat(document).isNotNull(); ObjectWithEnumValue result = template.getConverter().read(ObjectWithEnumValue.class, document); - assertThat(result.value, is(EnumValue.VALUE2)); + assertThat(result.value).isEqualTo(EnumValue.VALUE2); } }); } @@ -2133,17 +2125,17 @@ public class MongoTemplateTests { person.firstname = "Dave"; person.lastname = "Matthews"; template.save(person); - assertThat(person.id, is(notNullValue())); + assertThat(person.id).isNotNull(); Query qry = query(where("id").is(person.id)); VersionedPerson personAfterFirstSave = template.findOne(qry, VersionedPerson.class); - assertThat(personAfterFirstSave.version, is(0L)); + assertThat(personAfterFirstSave.version).isEqualTo(0L); template.updateFirst(qry, Update.update("lastname", "Bubu"), VersionedPerson.class); VersionedPerson personAfterUpdateFirst = template.findOne(qry, VersionedPerson.class); - assertThat(personAfterUpdateFirst.version, is(1L)); - assertThat(personAfterUpdateFirst.lastname, is("Bubu")); + assertThat(personAfterUpdateFirst.version).isEqualTo(1L); + assertThat(personAfterUpdateFirst.lastname).isEqualTo("Bubu"); } @Test // DATAMONGO-811 @@ -2163,9 +2155,9 @@ public class MongoTemplateTests { for (VersionedPerson p : template.find(q, VersionedPerson.class)) { if ("Metthews".equals(p.lastname)) { - assertThat(p.version, equalTo(Long.valueOf(1))); + assertThat(p.version).isEqualTo(Long.valueOf(1)); } else { - assertThat(p.version, equalTo(Long.valueOf(0))); + assertThat(p.version).isEqualTo(Long.valueOf(0)); } } } @@ -2186,7 +2178,7 @@ public class MongoTemplateTests { template.updateMulti(q, Update.update("lastname", "Metthews"), VersionedPerson.class); for (VersionedPerson p : template.find(q, VersionedPerson.class)) { - assertThat(p.version, equalTo(Long.valueOf(1))); + assertThat(p.version).isEqualTo(Long.valueOf(1)); } } @@ -2202,12 +2194,12 @@ public class MongoTemplateTests { Query query = new Query(); query.addCriteria(where("_id").in("42", "43")); - assertThat(template.count(query, Sample.class), is(1L)); + assertThat(template.count(query, Sample.class)).isEqualTo(1L); query.with(PageRequest.of(0, 10)); query.with(Sort.by("field")); - assertThat(template.find(query, Sample.class), is(not(empty()))); + assertThat(template.find(query, Sample.class)).isNotEmpty(); } @Test // DATAMONGO-807 @@ -2223,8 +2215,8 @@ public class MongoTemplateTests { template.findAndModify(query, update, Document.class); Document retrieved = template.findOne(query, Document.class); - assertThat(retrieved.model, instanceOf(ModelA.class)); - assertThat(retrieved.model.value(), equalTo("value2")); + assertThat(retrieved.model).isInstanceOf(ModelA.class); + assertThat(retrieved.model.value()).isEqualTo("value2"); } @Test // DATAMONGO-1210 @@ -2243,22 +2235,22 @@ public class MongoTemplateTests { Query query = query(where("id").is(doc.id)); Update update = Update.update("models", Collections.singletonList(entry)); - assertThat(template.findOne(query, DocumentWithNestedCollection.class), notNullValue()); + assertThat(template.findOne(query, DocumentWithNestedCollection.class)).isNotNull(); template.findAndModify(query, update, DocumentWithNestedCollection.class); DocumentWithNestedCollection retrieved = template.findOne(query, DocumentWithNestedCollection.class); - assertThat(retrieved, is(notNullValue())); - assertThat(retrieved.id, is(doc.id)); + assertThat(retrieved).isNotNull(); + assertThat(retrieved.id).isEqualTo(doc.id); - assertThat(retrieved.models.get(0).entrySet(), hasSize(2)); + assertThat(retrieved.models.get(0).entrySet()).hasSize(2); - assertThat(retrieved.models.get(0).get("key1"), instanceOf(ModelA.class)); - assertThat(retrieved.models.get(0).get("key1").value(), equalTo("value1")); + assertThat(retrieved.models.get(0).get("key1")).isInstanceOf(ModelA.class); + assertThat(retrieved.models.get(0).get("key1").value()).isEqualTo("value1"); - assertThat(retrieved.models.get(0).get("key2"), instanceOf(ModelA.class)); - assertThat(retrieved.models.get(0).get("key2").value(), equalTo("value2")); + assertThat(retrieved.models.get(0).get("key2")).isInstanceOf(ModelA.class); + assertThat(retrieved.models.get(0).get("key2").value()).isEqualTo("value2"); } @Test // DATAMONGO-1210 @@ -2277,22 +2269,22 @@ public class MongoTemplateTests { Query query = query(where("id").is(doc.id)); Update update = Update.update("models.0", entry); - assertThat(template.findOne(query, DocumentWithNestedCollection.class), notNullValue()); + assertThat(template.findOne(query, DocumentWithNestedCollection.class)).isNotNull(); template.findAndModify(query, update, DocumentWithNestedCollection.class); DocumentWithNestedCollection retrieved = template.findOne(query, DocumentWithNestedCollection.class); - assertThat(retrieved, is(notNullValue())); - assertThat(retrieved.id, is(doc.id)); + assertThat(retrieved).isNotNull(); + assertThat(retrieved.id).isEqualTo(doc.id); - assertThat(retrieved.models.get(0).entrySet(), hasSize(2)); + assertThat(retrieved.models.get(0).entrySet()).hasSize(2); - assertThat(retrieved.models.get(0).get("key1"), instanceOf(ModelA.class)); - assertThat(retrieved.models.get(0).get("key1").value(), equalTo("value1")); + assertThat(retrieved.models.get(0).get("key1")).isInstanceOf(ModelA.class); + assertThat(retrieved.models.get(0).get("key1").value()).isEqualTo("value1"); - assertThat(retrieved.models.get(0).get("key2"), instanceOf(ModelA.class)); - assertThat(retrieved.models.get(0).get("key2").value(), equalTo("value2")); + assertThat(retrieved.models.get(0).get("key2")).isInstanceOf(ModelA.class); + assertThat(retrieved.models.get(0).get("key2").value()).isEqualTo("value2"); } @Test // DATAMONGO-1210 @@ -2309,23 +2301,23 @@ public class MongoTemplateTests { Query query = query(where("id").is(doc.id)); Update update = Update.update("models.1", Collections.singletonMap("key2", new ModelA("value2"))); - assertThat(template.findOne(query, DocumentWithNestedCollection.class), notNullValue()); + assertThat(template.findOne(query, DocumentWithNestedCollection.class)).isNotNull(); template.findAndModify(query, update, DocumentWithNestedCollection.class); DocumentWithNestedCollection retrieved = template.findOne(query, DocumentWithNestedCollection.class); - assertThat(retrieved, is(notNullValue())); - assertThat(retrieved.id, is(doc.id)); + assertThat(retrieved).isNotNull(); + assertThat(retrieved.id).isEqualTo(doc.id); - assertThat(retrieved.models.get(0).entrySet(), hasSize(1)); - assertThat(retrieved.models.get(1).entrySet(), hasSize(1)); + assertThat(retrieved.models.get(0).entrySet()).hasSize(1); + assertThat(retrieved.models.get(1).entrySet()).hasSize(1); - assertThat(retrieved.models.get(0).get("key1"), instanceOf(ModelA.class)); - assertThat(retrieved.models.get(0).get("key1").value(), equalTo("value1")); + assertThat(retrieved.models.get(0).get("key1")).isInstanceOf(ModelA.class); + assertThat(retrieved.models.get(0).get("key1").value()).isEqualTo("value1"); - assertThat(retrieved.models.get(1).get("key2"), instanceOf(ModelA.class)); - assertThat(retrieved.models.get(1).get("key2").value(), equalTo("value2")); + assertThat(retrieved.models.get(1).get("key2")).isInstanceOf(ModelA.class); + assertThat(retrieved.models.get(1).get("key2").value()).isEqualTo("value2"); } @Test // DATAMONGO-1210 @@ -2343,16 +2335,16 @@ public class MongoTemplateTests { Query query = query(where("id").is(doc.id)); Update update = Update.update("embeddedDocument.models.0", new ModelA("value2")); - assertThat(template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class), notNullValue()); + assertThat(template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class)).isNotNull(); template.findAndModify(query, update, DocumentWithEmbeddedDocumentWithCollection.class); DocumentWithEmbeddedDocumentWithCollection retrieved = template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class); - assertThat(retrieved, notNullValue()); - assertThat(retrieved.embeddedDocument.models, hasSize(1)); - assertThat(retrieved.embeddedDocument.models.get(0).value(), is("value2")); + assertThat(retrieved).isNotNull(); + assertThat(retrieved.embeddedDocument.models).hasSize(1); + assertThat(retrieved.embeddedDocument.models.get(0).value()).isEqualTo("value2"); } @Test // DATAMONGO-1210 @@ -2370,17 +2362,17 @@ public class MongoTemplateTests { Query query = query(where("id").is(doc.id)); Update update = Update.update("embeddedDocument.models.1", new ModelA("value2")); - assertThat(template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class), notNullValue()); + assertThat(template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class)).isNotNull(); template.findAndModify(query, update, DocumentWithEmbeddedDocumentWithCollection.class); DocumentWithEmbeddedDocumentWithCollection retrieved = template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class); - assertThat(retrieved, notNullValue()); - assertThat(retrieved.embeddedDocument.models, hasSize(2)); - assertThat(retrieved.embeddedDocument.models.get(0).value(), is("value1")); - assertThat(retrieved.embeddedDocument.models.get(1).value(), is("value2")); + assertThat(retrieved).isNotNull(); + assertThat(retrieved.embeddedDocument.models).hasSize(2); + assertThat(retrieved.embeddedDocument.models.get(0).value()).isEqualTo("value1"); + assertThat(retrieved.embeddedDocument.models.get(1).value()).isEqualTo("value2"); } @Test // DATAMONGO-1210 @@ -2398,16 +2390,16 @@ public class MongoTemplateTests { Update update = Update.update("embeddedDocument", new DocumentWithCollection(Arrays. asList(new ModelA("value2")))); - assertThat(template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class), notNullValue()); + assertThat(template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class)).isNotNull(); template.findAndModify(query, update, DocumentWithEmbeddedDocumentWithCollection.class); DocumentWithEmbeddedDocumentWithCollection retrieved = template.findOne(query, DocumentWithEmbeddedDocumentWithCollection.class); - assertThat(retrieved, notNullValue()); - assertThat(retrieved.embeddedDocument.models, hasSize(1)); - assertThat(retrieved.embeddedDocument.models.get(0).value(), is("value2")); + assertThat(retrieved).isNotNull(); + assertThat(retrieved.embeddedDocument.models).hasSize(1); + assertThat(retrieved.embeddedDocument.models.get(0).value()).isEqualTo("value2"); } @Test // DATAMONGO-1210 @@ -2423,7 +2415,7 @@ public class MongoTemplateTests { Query query = query(where("id").is(doc.id)); - assertThat(template.findOne(query, DocumentWithNestedList.class), notNullValue()); + assertThat(template.findOne(query, DocumentWithNestedList.class)).isNotNull(); Update update = Update.update("models.0.1", new ModelA("value2")); @@ -2431,16 +2423,16 @@ public class MongoTemplateTests { DocumentWithNestedList retrieved = template.findOne(query, DocumentWithNestedList.class); - assertThat(retrieved, is(notNullValue())); - assertThat(retrieved.id, is(doc.id)); + assertThat(retrieved).isNotNull(); + assertThat(retrieved.id).isEqualTo(doc.id); - assertThat(retrieved.models.get(0), hasSize(2)); + assertThat(retrieved.models.get(0)).hasSize(2); - assertThat(retrieved.models.get(0).get(0), instanceOf(ModelA.class)); - assertThat(retrieved.models.get(0).get(0).value(), equalTo("value1")); + assertThat(retrieved.models.get(0).get(0)).isInstanceOf(ModelA.class); + assertThat(retrieved.models.get(0).get(0).value()).isEqualTo("value1"); - assertThat(retrieved.models.get(0).get(1), instanceOf(ModelA.class)); - assertThat(retrieved.models.get(0).get(1).value(), equalTo("value2")); + assertThat(retrieved.models.get(0).get(1)).isInstanceOf(ModelA.class); + assertThat(retrieved.models.get(0).get(1).value()).isEqualTo("value2"); } @Test // DATAMONGO-1827 @@ -2592,11 +2584,11 @@ public class MongoTemplateTests { Query findQuery = new Query(Criteria.where("id").is(doc.id)); DocumentWithCollection result = template.findOne(findQuery, DocumentWithCollection.class); - assertThat(result, is(notNullValue())); - assertThat(result.id, is(doc.id)); - assertThat(result.models, is(notNullValue())); - assertThat(result.models, hasSize(1)); - assertThat(result.models.get(0).value(), is(newModelValue)); + assertThat(result).isNotNull(); + assertThat(result.id).isEqualTo(doc.id); + assertThat(result.models).isNotNull(); + assertThat(result.models).hasSize(1); + assertThat(result.models.get(0).value()).isEqualTo(newModelValue); } @Test // DATAMONGO-812 @@ -2606,12 +2598,12 @@ public class MongoTemplateTests { DocumentWithCollection document = new DocumentWithCollection(Collections. emptyList()); template.save(document); Query query = query(where("id").is(document.id)); - assumeThat(template.findOne(query, DocumentWithCollection.class).models, hasSize(1)); + assertThat(template.findOne(query, DocumentWithCollection.class).models).isEmpty(); Update update = new Update().push("models").each(new ModelA("model-b"), new ModelA("model-c")); template.updateMulti(query, update, DocumentWithCollection.class); - assertThat(template.findOne(query, DocumentWithCollection.class).models, hasSize(3)); + assertThat(template.findOne(query, DocumentWithCollection.class).models).hasSize(2); } @Test // DATAMONGO-812 @@ -2623,12 +2615,12 @@ public class MongoTemplateTests { template.save(document); Query query = query(where("id").is(document.id)); - assumeThat(template.findOne(query, DocumentWithCollectionOfSimpleType.class).values, hasSize(1)); + assertThat(template.findOne(query, DocumentWithCollectionOfSimpleType.class).values).hasSize(1); Update update = new Update().push("values").each("data", "mongodb"); template.updateMulti(query, update, DocumentWithCollectionOfSimpleType.class); - assertThat(template.findOne(query, DocumentWithCollectionOfSimpleType.class).values, hasSize(3)); + assertThat(template.findOne(query, DocumentWithCollectionOfSimpleType.class).values).hasSize(3); } @Test // DATAMONOGO-828 @@ -2637,7 +2629,7 @@ public class MongoTemplateTests { Query q = query(where("id").is(Long.MIN_VALUE)); template.updateFirst(q, Update.update("lastname", "supercalifragilisticexpialidocious"), VersionedPerson.class); - assertThat(template.findOne(q, VersionedPerson.class), nullValue()); + assertThat(template.findOne(q, VersionedPerson.class)).isNull(); } @Test // DATAMONGO-354, DATAMONGO-1824 @@ -2659,8 +2651,8 @@ public class MongoTemplateTests { template.updateFirst(findQuery, update, DocumentWithMultipleCollections.class); DocumentWithMultipleCollections result = template.findOne(findQuery, DocumentWithMultipleCollections.class); - assertThat(result.string1, hasItems("spring", "data", "mongodb")); - assertThat(result.string2, hasItems("one", "two", "three")); + assertThat(result.string1).contains("spring", "data", "mongodb"); + assertThat(result.string2).contains("one", "two", "three"); } @@ -2687,10 +2679,10 @@ public class MongoTemplateTests { DocumentWithDBRefCollection result = template.findOne(qry, DocumentWithDBRefCollection.class); - assertThat(result, is(notNullValue())); - assertThat(result.dbRefAnnotatedList, hasSize(1)); - assertThat(result.dbRefAnnotatedList.get(0), is(notNullValue())); - assertThat(result.dbRefAnnotatedList.get(0).id, is((Object) "1")); + assertThat(result).isNotNull(); + assertThat(result.dbRefAnnotatedList).hasSize(1); + assertThat(result.dbRefAnnotatedList.get(0)).isNotNull(); + assertThat(result.dbRefAnnotatedList.get(0).id).isEqualTo((Object) "1"); } @Test // DATAMONGO-404 @@ -2716,10 +2708,10 @@ public class MongoTemplateTests { DocumentWithDBRefCollection result = template.findOne(qry, DocumentWithDBRefCollection.class); - assertThat(result, is(notNullValue())); - assertThat(result.dbRefAnnotatedList, hasSize(1)); - assertThat(result.dbRefAnnotatedList.get(0), is(notNullValue())); - assertThat(result.dbRefAnnotatedList.get(0).id, is((Object) "1")); + assertThat(result).isNotNull(); + assertThat(result.dbRefAnnotatedList).hasSize(1); + assertThat(result.dbRefAnnotatedList.get(0)).isNotNull(); + assertThat(result.dbRefAnnotatedList.get(0).id).isEqualTo((Object) "1"); } @Test // DATAMONGO-852 @@ -2729,17 +2721,17 @@ public class MongoTemplateTests { person.firstname = "Dave"; person.lastname = "Matthews"; template.save(person); - assertThat(person.id, is(notNullValue())); + assertThat(person.id).isNotNull(); Query qry = query(where("id").is(person.id)); VersionedPerson personAfterFirstSave = template.findOne(qry, VersionedPerson.class); - assertThat(personAfterFirstSave.version, is(0L)); + assertThat(personAfterFirstSave.version).isEqualTo(0L); template.updateFirst(qry, Update.update("lastname", "Bubu").set("version", 100L), VersionedPerson.class); VersionedPerson personAfterUpdateFirst = template.findOne(qry, VersionedPerson.class); - assertThat(personAfterUpdateFirst.version, is(100L)); - assertThat(personAfterUpdateFirst.lastname, is("Bubu")); + assertThat(personAfterUpdateFirst.version).isEqualTo(100L); + assertThat(personAfterUpdateFirst.lastname).isEqualTo("Bubu"); } @Test // DATAMONGO-468 @@ -2762,10 +2754,10 @@ public class MongoTemplateTests { DocumentWithDBRefCollection updatedDoc = template.findOne(qry, DocumentWithDBRefCollection.class); - assertThat(updatedDoc, is(notNullValue())); - assertThat(updatedDoc.dbRefProperty, is(notNullValue())); - assertThat(updatedDoc.dbRefProperty.id, is(sample2.id)); - assertThat(updatedDoc.dbRefProperty.field, is(sample2.field)); + assertThat(updatedDoc).isNotNull(); + assertThat(updatedDoc.dbRefProperty).isNotNull(); + assertThat(updatedDoc.dbRefProperty.id).isEqualTo(sample2.id); + assertThat(updatedDoc.dbRefProperty.field).isEqualTo(sample2.field); } @Test // DATAMONGO-862 @@ -2781,7 +2773,7 @@ public class MongoTemplateTests { template.findAndModify(query, update, DocumentWithCollection.class); DocumentWithCollection result = template.findOne(query(where("id").is(document.id)), DocumentWithCollection.class); - assertThat(result.models.get(0).value(), is("mongodb")); + assertThat(result.models.get(0).value()).isEqualTo("mongodb"); } @Test // DATAMONGO-773 @@ -2801,11 +2793,11 @@ public class MongoTemplateTests { List result = template.find(qry, DocumentWithDBRefCollection.class); - assertThat(result, is(notNullValue())); - assertThat(result, hasSize(1)); - assertThat(result.get(0), is(notNullValue())); - assertThat(result.get(0).dbRefProperty, is(notNullValue())); - assertThat(result.get(0).dbRefProperty.field, is(sample.field)); + assertThat(result).isNotNull(); + assertThat(result).hasSize(1); + assertThat(result.get(0)).isNotNull(); + assertThat(result.get(0).dbRefProperty).isNotNull(); + assertThat(result.get(0).dbRefProperty.field).isEqualTo(sample.field); } @Test // DATAMONGO-566 @@ -2819,11 +2811,13 @@ public class MongoTemplateTests { Query qry = query(where("field").in("spring", "mongodb")); List result = template.findAllAndRemove(qry, Sample.class); - assertThat(result, hasSize(2)); + assertThat(result).hasSize(2); assertThat(template.getDb().getCollection("sample").countDocuments( - new org.bson.Document("field", new org.bson.Document("$in", Arrays.asList("spring", "mongodb")))), is(0L)); - assertThat(template.getDb().getCollection("sample").countDocuments(new org.bson.Document("field", "data")), is(1L)); + new org.bson.Document("field", new org.bson.Document("$in", Arrays.asList("spring", "mongodb"))))) + .isEqualTo(0L); + assertThat(template.getDb().getCollection("sample").countDocuments(new org.bson.Document("field", "data"))) + .isEqualTo(1L); } @Test // DATAMONGO-1001 @@ -2850,7 +2844,7 @@ public class MongoTemplateTests { loadedContent.setText("data"); template.save(loadedContent); - assertThat(template.findById(content.id, SomeContent.class).getText(), is("data")); + assertThat(template.findById(content.id, SomeContent.class).getText()).isEqualTo("data"); } @@ -2883,8 +2877,8 @@ public class MongoTemplateTests { SomeMessage savedMessage = template.findById(message.id, SomeMessage.class); - assertThat(savedMessage.dbrefContent.text, is(content.text)); - assertThat(savedMessage.normalContent.text, is(content.text)); + assertThat(savedMessage.dbrefContent.text).isEqualTo(content.text); + assertThat(savedMessage.normalContent.text).isEqualTo(content.text); } @Test // DATAMONGO-884 @@ -2908,9 +2902,9 @@ public class MongoTemplateTests { template.remove(content); - assertThat(savedTmpl.getContent().toString(), is("someContent:C1$LazyLoadingProxy")); - assertThat(savedTmpl.getContent(), is(instanceOf(LazyLoadingProxy.class))); - assertThat(savedTmpl.getContent().getText(), is(nullValue())); + assertThat(savedTmpl.getContent().toString()).isEqualTo("someContent:C1$LazyLoadingProxy"); + assertThat(savedTmpl.getContent()).isInstanceOf(LazyLoadingProxy.class); + assertThat(savedTmpl.getContent().getText()).isNull(); } @Test // DATAMONGO-471 @@ -2921,12 +2915,12 @@ public class MongoTemplateTests { template.save(document); Query query = query(where("id").is(document.id)); - assumeThat(template.findOne(query, DocumentWithCollectionOfSimpleType.class).values, hasSize(1)); + assertThat(template.findOne(query, DocumentWithCollectionOfSimpleType.class).values).hasSize(1); Update update = new Update().addToSet("values").each("data", "mongodb"); template.updateMulti(query, update, DocumentWithCollectionOfSimpleType.class); - assertThat(template.findOne(query, DocumentWithCollectionOfSimpleType.class).values, hasSize(3)); + assertThat(template.findOne(query, DocumentWithCollectionOfSimpleType.class).values).hasSize(3); } @Test // DATAMONGO-1210 @@ -2939,7 +2933,7 @@ public class MongoTemplateTests { Query query = query(where("id").is(doc.id)); - assertThat(template.findOne(query, DocumentWithCollectionOfSamples.class), notNullValue()); + assertThat(template.findOne(query, DocumentWithCollectionOfSamples.class)).isNotNull(); Update update = new Update().addToSet("samples").each(new Sample(null, "sample2"), new Sample(null, "sample1")); @@ -2947,10 +2941,10 @@ public class MongoTemplateTests { DocumentWithCollectionOfSamples retrieved = template.findOne(query, DocumentWithCollectionOfSamples.class); - assertThat(retrieved, notNullValue()); - assertThat(retrieved.samples, hasSize(2)); - assertThat(retrieved.samples.get(0).field, is("sample1")); - assertThat(retrieved.samples.get(1).field, is("sample2")); + assertThat(retrieved).isNotNull(); + assertThat(retrieved.samples).hasSize(2); + assertThat(retrieved.samples.get(0).field).isEqualTo("sample1"); + assertThat(retrieved.samples.get(1).field).isEqualTo("sample2"); } @Test // DATAMONGO-888 @@ -2968,7 +2962,7 @@ public class MongoTemplateTests { template.save(two); Query query = query(where("_id").in("1", "2")).with(Sort.by(Direction.DESC, "someIdKey")); - assertThat(template.find(query, DoucmentWithNamedIdField.class), contains(two, one)); + assertThat(template.find(query, DoucmentWithNamedIdField.class)).containsExactly(two, one); } @Test // DATAMONGO-888 @@ -2986,7 +2980,7 @@ public class MongoTemplateTests { template.save(two); Query query = query(where("_id").in("1", "2")).with(Sort.by(Direction.DESC, "value")); - assertThat(template.find(query, DoucmentWithNamedIdField.class), contains(two, one)); + assertThat(template.find(query, DoucmentWithNamedIdField.class)).containsExactly(two, one); } @Test // DATAMONGO-913 @@ -3007,11 +3001,11 @@ public class MongoTemplateTests { SomeTemplate result = template.findOne(query(where("content").is(tmpl.getContent())), SomeTemplate.class); - assertThat(result, is(notNullValue())); - assertThat(result.getContent(), is(notNullValue())); - assertThat(result.getContent().getId(), is(notNullValue())); - assertThat(result.getContent().getName(), is(notNullValue())); - assertThat(result.getContent().getText(), is(content.getText())); + assertThat(result).isNotNull(); + assertThat(result.getContent()).isNotNull(); + assertThat(result.getContent().getId()).isNotNull(); + assertThat(result.getContent().getName()).isNotNull(); + assertThat(result.getContent().getText()).isEqualTo(content.getText()); } @Test // DATAMONGO-913 @@ -3035,8 +3029,8 @@ public class MongoTemplateTests { // Use lazy-loading-proxy in query result = template.findOne(query(where("content").is(result.getContent())), SomeTemplate.class); - assertNotNull(result.getContent().getName()); - assertThat(result.getContent().getName(), is(content.getName())); + assertThat(result.getContent().getName()).isNotNull(); + assertThat(result.getContent().getName()).isEqualTo(content.getName()); } @Test // DATAMONGO-970 @@ -3045,11 +3039,11 @@ public class MongoTemplateTests { org.bson.Document object = new org.bson.Document("key", "value"); template.insert(object, "collection"); - assertThat(object.get("_id"), is(notNullValue())); - assertThat(template.findAll(Document.class, "collection"), hasSize(1)); + assertThat(object.get("_id")).isNotNull(); + assertThat(template.findAll(Document.class, "collection")).hasSize(1); template.remove(object, "collection"); - assertThat(template.findAll(Document.class, "collection"), hasSize(0)); + assertThat(template.findAll(Document.class, "collection")).hasSize(0); } @Test // DATAMONGO-1207 @@ -3062,8 +3056,8 @@ public class MongoTemplateTests { List
result = template.findAll(Address.class); - assertThat(result, hasSize(2)); - assertThat(result, hasItems(newYork, washington)); + assertThat(result).hasSize(2); + assertThat(result).contains(newYork, washington); } @Test // DATAMONGO-1176 @@ -3076,9 +3070,9 @@ public class MongoTemplateTests { List result = template.findAll(Person.class); - assertThat(result, hasSize(2)); - assertThat(walter.getId(), is(notNullValue())); - assertThat(jesse.getId(), is(notNullValue())); + assertThat(result).hasSize(2); + assertThat(walter.getId()).isNotNull(); + assertThat(jesse.getId()).isNotNull(); } @Test // DATAMONGO-1208 @@ -3093,8 +3087,8 @@ public class MongoTemplateTests { q.with(Sort.by(Direction.ASC, "age")); CloseableIterator stream = template.stream(q, Person.class); - assertThat(stream.next().getAge(), is(youngestPerson.getAge())); - assertThat(stream.next().getAge(), is(oldestPerson.getAge())); + assertThat(stream.next().getAge()).isEqualTo(youngestPerson.getAge()); + assertThat(stream.next().getAge()).isEqualTo(oldestPerson.getAge()); } @Test // DATAMONGO-1208 @@ -3109,8 +3103,8 @@ public class MongoTemplateTests { q.with(PageRequest.of(0, 1, Sort.by(Direction.ASC, "age"))); CloseableIterator stream = template.stream(q, Person.class); - assertThat(stream.next().getAge(), is(youngestPerson.getAge())); - assertThat(stream.hasNext(), is(false)); + assertThat(stream.next().getAge()).isEqualTo(youngestPerson.getAge()); + assertThat(stream.hasNext()).isFalse(); } @Test // DATAMONGO-1204 @@ -3131,8 +3125,8 @@ public class MongoTemplateTests { SomeMessage messageLoaded = template.findOne(query(where("id").is(message.id)), SomeMessage.class); SomeContent contentLoaded = template.findOne(query(where("id").is(content.id)), SomeContent.class); - assertThat(messageLoaded.dbrefContent.id, is(contentLoaded.id)); - assertThat(contentLoaded.dbrefMessage.id, is(messageLoaded.id)); + assertThat(messageLoaded.dbrefContent.id).isEqualTo(contentLoaded.id); + assertThat(contentLoaded.dbrefMessage.id).isEqualTo(messageLoaded.id); } @Test // DATAMONGO-1287, DATAMONGO-2004 @@ -3149,8 +3143,8 @@ public class MongoTemplateTests { DocumentWithLazyDBrefUsedInPresistenceConstructor loaded = template.findOne(query(where("id").is(source.id)), DocumentWithLazyDBrefUsedInPresistenceConstructor.class); - assertThat(loaded.refToDocUsedInCtor, instanceOf(LazyLoadingProxy.class)); - assertThat(loaded.refToDocNotUsedInCtor, nullValue()); + assertThat(loaded.refToDocUsedInCtor).isInstanceOf(LazyLoadingProxy.class); + assertThat(loaded.refToDocNotUsedInCtor).isNull(); } @Test // DATAMONGO-1287 @@ -3168,8 +3162,8 @@ public class MongoTemplateTests { DocumentWithLazyDBrefUsedInPresistenceConstructor loaded = template.findOne(query(where("id").is(source.id)), DocumentWithLazyDBrefUsedInPresistenceConstructor.class); - assertThat(loaded.refToDocNotUsedInCtor, instanceOf(LazyLoadingProxy.class)); - assertThat(loaded.refToDocUsedInCtor, nullValue()); + assertThat(loaded.refToDocNotUsedInCtor).isInstanceOf(LazyLoadingProxy.class); + assertThat(loaded.refToDocUsedInCtor).isNull(); } @Test // DATAMONGO-1287, DATAMONGO-2004 @@ -3191,8 +3185,8 @@ public class MongoTemplateTests { DocumentWithLazyDBrefUsedInPresistenceConstructor loaded = template.findOne(query(where("id").is(source.id)), DocumentWithLazyDBrefUsedInPresistenceConstructor.class); - assertThat(loaded.refToDocUsedInCtor, instanceOf(LazyLoadingProxy.class)); - assertThat(loaded.refToDocNotUsedInCtor, instanceOf(LazyLoadingProxy.class)); + assertThat(loaded.refToDocUsedInCtor).isInstanceOf(LazyLoadingProxy.class); + assertThat(loaded.refToDocNotUsedInCtor).isInstanceOf(LazyLoadingProxy.class); } @Test // DATAMONGO-1401 @@ -3208,7 +3202,7 @@ public class MongoTemplateTests { wgj.description = "datamongo-1401-update"; template.save(wgj); - assertThat(template.findOne(query(where("id").is(wgj.id)), WithGeoJson.class).point, is(equalTo(wgj.point))); + assertThat(template.findOne(query(where("id").is(wgj.id)), WithGeoJson.class).point).isEqualTo(wgj.point); } @Test // DATAMONGO-1404 @@ -3223,7 +3217,7 @@ public class MongoTemplateTests { template.updateFirst(query(where("id").is(twd.id)), new Update().min("date", cal.getTime()), TypeWithDate.class); TypeWithDate loaded = template.find(query(where("id").is(twd.id)), TypeWithDate.class).get(0); - assertThat(loaded.date, equalTo(cal.getTime())); + assertThat(loaded.date).isEqualTo(cal.getTime()); } @Test // DATAMONGO-1404 @@ -3256,13 +3250,13 @@ public class MongoTemplateTests { template.updateFirst(query(where("id").is(twn.id)), update, TypeWithNumbers.class); TypeWithNumbers loaded = template.find(query(where("id").is(twn.id)), TypeWithNumbers.class).get(0); - assertThat(loaded.byteVal, equalTo(byteVal)); - assertThat(loaded.doubleVal, equalTo(190D)); - assertThat(loaded.floatVal, equalTo(290F)); - assertThat(loaded.intVal, equalTo(390)); - assertThat(loaded.longVal, equalTo(490L)); - assertThat(loaded.bigIntegerVal, equalTo(new BigInteger("590"))); - assertThat(loaded.bigDeciamVal, equalTo(new BigDecimal("690"))); + assertThat(loaded.byteVal).isEqualTo(byteVal); + assertThat(loaded.doubleVal).isEqualTo(190D); + assertThat(loaded.floatVal).isEqualTo(290F); + assertThat(loaded.intVal).isEqualTo(390); + assertThat(loaded.longVal).isEqualTo(490L); + assertThat(loaded.bigIntegerVal).isEqualTo(new BigInteger("590")); + assertThat(loaded.bigDeciamVal).isEqualTo(new BigDecimal("690")); } @Test // DATAMONGO-1404 @@ -3279,7 +3273,7 @@ public class MongoTemplateTests { template.updateFirst(query(where("id").is(twd.id)), new Update().max("date", cal.getTime()), TypeWithDate.class); TypeWithDate loaded = template.find(query(where("id").is(twd.id)), TypeWithDate.class).get(0); - assertThat(loaded.date, equalTo(cal.getTime())); + assertThat(loaded.date).isEqualTo(cal.getTime()); } @Test // DATAMONGO-1404 @@ -3312,13 +3306,13 @@ public class MongoTemplateTests { template.updateFirst(query(where("id").is(twn.id)), update, TypeWithNumbers.class); TypeWithNumbers loaded = template.find(query(where("id").is(twn.id)), TypeWithNumbers.class).get(0); - assertThat(loaded.byteVal, equalTo(byteVal)); - assertThat(loaded.doubleVal, equalTo(290D)); - assertThat(loaded.floatVal, equalTo(390F)); - assertThat(loaded.intVal, equalTo(490)); - assertThat(loaded.longVal, equalTo(590L)); - assertThat(loaded.bigIntegerVal, equalTo(new BigInteger("690"))); - assertThat(loaded.bigDeciamVal, equalTo(new BigDecimal("790"))); + assertThat(loaded.byteVal).isEqualTo(byteVal); + assertThat(loaded.doubleVal).isEqualTo(290D); + assertThat(loaded.floatVal).isEqualTo(390F); + assertThat(loaded.intVal).isEqualTo(490); + assertThat(loaded.longVal).isEqualTo(590L); + assertThat(loaded.bigIntegerVal).isEqualTo(new BigInteger("690")); + assertThat(loaded.bigDeciamVal).isEqualTo(new BigDecimal("790")); } @Test // DATAMONGO-1404 @@ -3341,8 +3335,8 @@ public class MongoTemplateTests { template.updateFirst(query(where("id").is(twn.id)), update, TypeWithNumbers.class); TypeWithNumbers loaded = template.find(query(where("id").is(twn.id)), TypeWithNumbers.class).get(0); - assertThat(loaded.bigIntegerVal, equalTo(new BigInteger("70"))); - assertThat(loaded.bigDeciamVal, equalTo(new BigDecimal("80"))); + assertThat(loaded.bigIntegerVal).isEqualTo(new BigInteger("70")); + assertThat(loaded.bigDeciamVal).isEqualTo(new BigDecimal("80")); } @Test // DATAMONGO-1404 @@ -3365,8 +3359,8 @@ public class MongoTemplateTests { template.updateFirst(query(where("id").is(twn.id)), update, TypeWithNumbers.class); TypeWithNumbers loaded = template.find(query(where("id").is(twn.id)), TypeWithNumbers.class).get(0); - assertThat(loaded.bigIntegerVal, equalTo(new BigInteger("700"))); - assertThat(loaded.bigDeciamVal, equalTo(new BigDecimal("800"))); + assertThat(loaded.bigIntegerVal).isEqualTo(new BigInteger("700")); + assertThat(loaded.bigDeciamVal).isEqualTo(new BigDecimal("800")); } @Test // DATAMONGO-1431 @@ -3381,13 +3375,13 @@ public class MongoTemplateTests { CloseableIterator stream = template.stream(new Query(), Document.class); - assertThat(stream.hasNext(), is(false)); + assertThat(stream.hasNext()).isFalse(); stream = template.stream(new Query(), Document.class, "some_special_collection"); - assertThat(stream.hasNext(), is(true)); - assertThat(stream.next().id, is(document.id)); - assertThat(stream.hasNext(), is(false)); + assertThat(stream.hasNext()).isTrue(); + assertThat(stream.next().id).isEqualTo(document.id); + assertThat(stream.hasNext()).isFalse(); } @Test // DATAMONGO-1194 @@ -3404,7 +3398,7 @@ public class MongoTemplateTests { template.save(source); - assertThat(template.findOne(query(where("id").is(source.id)), DocumentWithDBRefCollection.class), is(source)); + assertThat(template.findOne(query(where("id").is(source.id)), DocumentWithDBRefCollection.class)).isEqualTo(source); } @Test // DATAMONGO-1194 @@ -3424,8 +3418,8 @@ public class MongoTemplateTests { DocumentWithDBRefCollection target = template.findOne(query(where("id").is(source.id)), DocumentWithDBRefCollection.class); - assertThat(target.lazyDbRefAnnotatedList, instanceOf(LazyLoadingProxy.class)); - assertThat(target.getLazyDbRefAnnotatedList(), contains(two, one)); + assertThat(target.lazyDbRefAnnotatedList).isInstanceOf(LazyLoadingProxy.class); + assertThat(target.getLazyDbRefAnnotatedList()).containsExactly(two, one); } @Test // DATAMONGO-1194 @@ -3446,8 +3440,8 @@ public class MongoTemplateTests { DocumentWithDBRefCollection target = template.findOne(query(where("id").is(source.id)), DocumentWithDBRefCollection.class); - assertThat(target.lazyDbRefAnnotatedMap, instanceOf(LazyLoadingProxy.class)); - assertThat(target.lazyDbRefAnnotatedMap.values(), contains(two, one)); + assertThat(target.lazyDbRefAnnotatedMap).isInstanceOf(LazyLoadingProxy.class); + assertThat(target.lazyDbRefAnnotatedMap.values()).containsExactly(two, one); } @Test // DATAMONGO-2004 @@ -3465,8 +3459,8 @@ public class MongoTemplateTests { DocumentWithLazyDBRefsAndConstructorCreation target = template.findOne(query(where("id").is(source.id)), DocumentWithLazyDBRefsAndConstructorCreation.class); - assertThat(target.lazyDbRefProperty, instanceOf(LazyLoadingProxy.class)); - assertThat(target.lazyDbRefProperty, is(one)); + assertThat(target.lazyDbRefProperty).isInstanceOf(LazyLoadingProxy.class); + assertThat(target.lazyDbRefProperty).isEqualTo(one); } @Test // DATAMONGO-2004 @@ -3490,8 +3484,8 @@ public class MongoTemplateTests { DocumentWithLazyDBRefsAndConstructorCreation target = template.findOne(query(where("id").is(source.id)), DocumentWithLazyDBRefsAndConstructorCreation.class); - assertThat(target.lazyDbRefAnnotatedMap, instanceOf(LazyLoadingProxy.class)); - assertThat(target.lazyDbRefAnnotatedMap.values(), contains(two, one)); + assertThat(target.lazyDbRefAnnotatedMap).isInstanceOf(LazyLoadingProxy.class); + assertThat(target.lazyDbRefAnnotatedMap.values()).containsExactly(two, one); } @Test // DATAMONGO-2004 @@ -3513,8 +3507,8 @@ public class MongoTemplateTests { DocumentWithLazyDBRefsAndConstructorCreation target = template.findOne(query(where("id").is(source.id)), DocumentWithLazyDBRefsAndConstructorCreation.class); - assertThat(target.lazyDbRefAnnotatedList, instanceOf(LazyLoadingProxy.class)); - assertThat(target.getLazyDbRefAnnotatedList(), contains(two, one)); + assertThat(target.lazyDbRefAnnotatedList).isInstanceOf(LazyLoadingProxy.class); + assertThat(target.getLazyDbRefAnnotatedList()).containsExactly(two, one); } @Test // DATAMONGO-1513 @@ -3533,7 +3527,7 @@ public class MongoTemplateTests { template.insertAll(Collections.singletonList(document)); - assertThat(document.id, is(notNullValue())); + assertThat(document.id).isNotNull(); } @Test // DATAMONGO-2189 @@ -3545,9 +3539,9 @@ public class MongoTemplateTests { template.insertAll(Collections.singletonList(source)); - assertThat(saved.get(), is(notNullValue())); - assertThat(saved.get(), is(not(sameInstance(source)))); - assertThat(saved.get().id, is(notNullValue())); + assertThat(saved.get()).isNotNull(); + assertThat(saved.get()).isNotSameAs(source); + assertThat(saved.get().id).isNotNull(); } @@ -3560,9 +3554,9 @@ public class MongoTemplateTests { template.insert(source); - assertThat(saved.get(), is(notNullValue())); - assertThat(saved.get(), is(not(sameInstance(source)))); - assertThat(saved.get().id, is(notNullValue())); + assertThat(saved.get()).isNotNull(); + assertThat(saved.get()).isNotSameAs(source); + assertThat(saved.get().id).isNotNull(); } @Test // DATAMONGO-1509 @@ -3574,7 +3568,7 @@ public class MongoTemplateTests { template.insert(dwc); Query query = query(where("models").is(modelList)); - assertThat(template.findOne(query, DocumentWithCollection.class), is(equalTo(dwc))); + assertThat(template.findOne(query, DocumentWithCollection.class)).isEqualTo(dwc); } @Test // DATAMONGO-1517 @@ -3591,7 +3585,7 @@ public class MongoTemplateTests { template.save(source); WithObjectTypeProperty loaded = template.findOne(query(where("id").is(source.id)), WithObjectTypeProperty.class); - assertThat(loaded.getValue(), instanceOf(decimal128Type)); + assertThat(loaded.getValue()).isInstanceOf(decimal128Type); } @Test // DATAMONGO-1718 @@ -3608,9 +3602,9 @@ public class MongoTemplateTests { List result = template.findAllAndRemove(query(where("field").regex(".*stark$")), template.getCollectionName(Sample.class)); - assertThat(result, hasSize(2)); - assertThat(result, containsInAnyOrder(bran, rickon)); - assertThat(template.count(new BasicQuery("{}"), template.getCollectionName(Sample.class)), is(equalTo(1L))); + assertThat(result).hasSize(2); + assertThat(result).contains(bran, rickon); + assertThat(template.count(new BasicQuery("{}"), template.getCollectionName(Sample.class))).isEqualTo(1L); } @Test // DATAMONGO-1779 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java index 6c73f2059..b2b1078f1 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.core.Is.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.query.Criteria.*; import static org.springframework.data.mongodb.core.query.Query.*; @@ -26,6 +25,7 @@ import java.util.Optional; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.data.mongodb.config.AbstractMongoConfiguration; @@ -80,7 +80,7 @@ public class NoExplicitIdTests { TypeWithoutIdProperty retrieved = mongoOps.findOne(query(where("someString").is(noid.someString)), TypeWithoutIdProperty.class); - assertThat(retrieved.someString, is(noid.someString)); + assertThat(retrieved.someString).isEqualTo(noid.someString); } @Test // DATAMONGO-1289 @@ -92,7 +92,7 @@ public class NoExplicitIdTests { repo.save(noid); TypeWithoutIdProperty retrieved = repo.findBySomeString(noid.someString); - assertThat(retrieved.someString, is(noid.someString)); + assertThat(retrieved.someString).isEqualTo(noid.someString); } @Test // DATAMONGO-1289 @@ -108,7 +108,7 @@ public class NoExplicitIdTests { "typeWithoutIdProperty"); Optional retrieved = repo.findById(map.get("_id").toString()); - assertThat(retrieved.get().someString, is(noid.someString)); + assertThat(retrieved.get().someString).isEqualTo(noid.someString); } static class TypeWithoutIdProperty { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/ReactiveMongoTemplateExecuteTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/ReactiveMongoTemplateExecuteTests.java index 6a767b8a0..c826d9836 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/ReactiveMongoTemplateExecuteTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/ReactiveMongoTemplateExecuteTests.java @@ -15,8 +15,8 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.data.Offset.offset; import static org.junit.Assume.*; import reactor.core.publisher.Flux; @@ -28,6 +28,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.data.mongodb.UncategorizedMongoDbException; @@ -81,7 +82,7 @@ public class ReactiveMongoTemplateExecuteTests { StepVerifier.create(operations.executeCommand("{ buildInfo: 1 }")).consumeNextWith(actual -> { - assertThat(actual, hasKey("version")); + assertThat(actual).containsKey("version"); }).verifyComplete(); } @@ -90,7 +91,7 @@ public class ReactiveMongoTemplateExecuteTests { StepVerifier.create(operations.executeCommand(new Document("buildInfo", 1))).consumeNextWith(actual -> { - assertThat(actual, hasKey("version")); + assertThat(actual).containsKey("version"); }).verifyComplete(); } @@ -105,8 +106,8 @@ public class ReactiveMongoTemplateExecuteTests { StepVerifier.create(operations.executeCommand("{ find: 'execute_test'}")) // .consumeNextWith(actual -> { - assertThat(actual.get("ok", Double.class), is(closeTo(1D, 0D))); - assertThat(actual, hasKey("cursor")); + assertThat(actual.get("ok", Double.class)).isCloseTo(1D, offset(0D)); + assertThat(actual).containsKey("cursor"); }) // .verifyComplete(); } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/ReactiveMongoTemplateUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/ReactiveMongoTemplateUnitTests.java index 4e4b5fa12..6c99daadb 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/ReactiveMongoTemplateUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/ReactiveMongoTemplateUnitTests.java @@ -15,10 +15,8 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; -import static org.mockito.Mockito.any; import static org.springframework.data.mongodb.core.aggregation.Aggregation.*; import lombok.Data; @@ -42,6 +40,7 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; import org.reactivestreams.Publisher; + import org.springframework.beans.factory.annotation.Value; import org.springframework.context.ApplicationContext; import org.springframework.context.support.StaticApplicationContext; @@ -167,7 +166,7 @@ public class ReactiveMongoTemplateUnitTests { @Test // DATAMONGO-1444 public void defaultsConverterToMappingMongoConverter() throws Exception { ReactiveMongoTemplate template = new ReactiveMongoTemplate(mongoClient, "database"); - assertTrue(ReflectionTestUtils.getField(template, "mongoConverter") instanceof MappingMongoConverter); + assertThat(ReflectionTestUtils.getField(template, "mongoConverter") instanceof MappingMongoConverter).isTrue(); } @Test // DATAMONGO-1912 @@ -180,7 +179,7 @@ public class ReactiveMongoTemplateUnitTests { Map entity = new LinkedHashMap<>(); StepVerifier.create(template.save(entity, "foo")).consumeNextWith(actual -> { - assertThat(entity, hasKey("_id")); + assertThat(entity).containsKey("_id"); }).verifyComplete(); } @@ -231,7 +230,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(FindOneAndUpdateOptions.class); verify(collection).findOneAndUpdate(any(), any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("fr")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("fr"); } @Test // DATAMONGO-1518 @@ -244,7 +243,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(FindOneAndDeleteOptions.class); verify(collection).findOneAndDelete(any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("fr")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("fr"); } @Test // DATAMONGO-1518 @@ -258,7 +257,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(DeleteOptions.class); verify(collection).deleteMany(any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("fr")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("fr"); } @Test // DATAMONGO-1518 @@ -272,7 +271,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(UpdateOptions.class); verify(collection).updateOne(any(), any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("fr")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("fr"); } @Test // DATAMONGO-1518 @@ -286,7 +285,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(UpdateOptions.class); verify(collection).updateMany(any(), any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("fr")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("fr"); } @@ -301,7 +300,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(ReplaceOptions.class); verify(collection).replaceOne(any(Bson.class), any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("fr")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("fr"); } @Test // DATAMONGO-1518, DATAMONGO-2257 @@ -389,7 +388,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(CountOptions.class); verify(collection).count(any(), options.capture()); - assertThat(options.getValue().getSkip(), is(equalTo(10))); + assertThat(options.getValue().getSkip()).isEqualTo(10); } @Test // DATAMONGO-1783 @@ -400,7 +399,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(CountOptions.class); verify(collection).count(any(), options.capture()); - assertThat(options.getValue().getLimit(), is(equalTo(100))); + assertThat(options.getValue().getLimit()).isEqualTo(100); } @Test // DATAMONGO-2215 @@ -471,8 +470,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(FindOneAndUpdateOptions.class); verify(collection).findOneAndUpdate(any(), any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("de_AT").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("de_AT").build()); } @Test // DATAMONGO-1854 @@ -483,8 +482,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(FindOneAndDeleteOptions.class); verify(collection).findOneAndDelete(any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("de_AT").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("de_AT").build()); } @Test // DATAMONGO-1854 @@ -506,8 +505,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(CreateCollectionOptions.class); verify(db).createCollection(any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("de_AT").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("de_AT").build()); } @Test // DATAMONGO-1854 @@ -518,8 +517,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(CreateCollectionOptions.class); verify(db).createCollection(any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("en_US").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("en_US").build()); } @Test // DATAMONGO-1854 @@ -530,8 +529,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(CreateCollectionOptions.class); verify(db).createCollection(any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("de_AT").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("de_AT").build()); } @Test // DATAMONGO-1854 @@ -574,7 +573,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(FindOneAndReplaceOptions.class); verify(collection).findOneAndReplace(any(Bson.class), any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("fr")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("fr"); } @Test // DATAMONGO-18545 @@ -585,7 +584,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(FindOneAndReplaceOptions.class); verify(collection).findOneAndReplace(any(Bson.class), any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("de_AT")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("de_AT"); } @Test // DATAMONGO-18545 @@ -597,7 +596,7 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(FindOneAndReplaceOptions.class); verify(collection).findOneAndReplace(any(Bson.class), any(), options.capture()); - assertThat(options.getValue().getCollation().getLocale(), is("fr")); + assertThat(options.getValue().getCollation().getLocale()).isEqualTo("fr"); } @Test // DATAMONGO-1854 @@ -625,8 +624,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(UpdateOptions.class); verify(collection).updateOne(any(), any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("de_AT").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("de_AT").build()); } @Test // DATAMONGO-1854 @@ -638,8 +637,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(UpdateOptions.class); verify(collection).updateOne(any(), any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("fr").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("fr").build()); } @Test // DATAMONGO-1854 @@ -650,8 +649,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(UpdateOptions.class); verify(collection).updateMany(any(), any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("de_AT").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("de_AT").build()); } @Test // DATAMONGO-1854 @@ -663,8 +662,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(UpdateOptions.class); verify(collection).updateMany(any(), any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("fr").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("fr").build()); } @Test // DATAMONGO-1854 @@ -675,8 +674,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(DeleteOptions.class); verify(collection).deleteMany(any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("de_AT").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("de_AT").build()); } @Test // DATAMONGO-1854 @@ -687,8 +686,8 @@ public class ReactiveMongoTemplateUnitTests { ArgumentCaptor options = ArgumentCaptor.forClass(DeleteOptions.class); verify(collection).deleteMany(any(), options.capture()); - assertThat(options.getValue().getCollation(), - is(com.mongodb.client.model.Collation.builder().locale("fr").build())); + assertThat(options.getValue().getCollation()) + .isEqualTo(com.mongodb.client.model.Collation.builder().locale("fr").build()); } @Test // DATAMONGO-2261 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleMongoDbFactoryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleMongoDbFactoryUnitTests.java index 69569c45e..bf2536fce 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleMongoDbFactoryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleMongoDbFactoryUnitTests.java @@ -16,8 +16,6 @@ package org.springframework.data.mongodb.core; import static org.assertj.core.api.Assertions.*; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.assertThat; import static org.mockito.Mockito.*; import static org.springframework.test.util.ReflectionTestUtils.*; @@ -30,14 +28,15 @@ import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.aop.framework.AopProxyUtils; import org.springframework.data.mongodb.MongoDbFactory; import org.springframework.test.util.ReflectionTestUtils; import com.mongodb.MongoClient; import com.mongodb.MongoClientURI; -import com.mongodb.client.MongoDatabase; import com.mongodb.client.ClientSession; +import com.mongodb.client.MongoDatabase; /** * Unit tests for {@link SimpleMongoDbFactory}. @@ -80,7 +79,7 @@ public class SimpleMongoDbFactoryUnitTests { MongoClientURI mongoURI = new MongoClientURI("mongodb://myUsername:myPassword@localhost/myDatabase.myCollection"); MongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoURI); - assertThat(getField(mongoDbFactory, "databaseName").toString(), is("myDatabase")); + assertThat(getField(mongoDbFactory, "databaseName").toString()).isEqualTo("myDatabase"); } @Test // DATAMONGO-1158 @@ -89,7 +88,7 @@ public class SimpleMongoDbFactoryUnitTests { MongoClientURI uri = new MongoClientURI("mongodb://myUserName:myPassWord@127.0.0.1:27017/myDataBase.myCollection"); SimpleMongoDbFactory factory = new SimpleMongoDbFactory(uri); - assertThat(getField(factory, "databaseName").toString(), is("myDataBase")); + assertThat(getField(factory, "databaseName").toString()).isEqualTo("myDataBase"); } @Test // DATAMONGO-1880 @@ -105,7 +104,7 @@ public class SimpleMongoDbFactoryUnitTests { Object singletonTarget = AopProxyUtils .getSingletonTarget(ReflectionTestUtils.getField(invocationHandler, "advised")); - assertThat(singletonTarget, is(sameInstance(database))); + assertThat(singletonTarget).isSameAs(database); } private void rejectsDatabaseName(String databaseName) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleReactiveMongoDatabaseFactoryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleReactiveMongoDatabaseFactoryUnitTests.java index 68838196a..d89bdce56 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleReactiveMongoDatabaseFactoryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleReactiveMongoDatabaseFactoryUnitTests.java @@ -16,8 +16,6 @@ package org.springframework.data.mongodb.core; import static org.assertj.core.api.Assertions.*; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.assertThat; import static org.mockito.Mockito.*; import java.lang.reflect.InvocationHandler; @@ -27,6 +25,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.aop.framework.AopProxyUtils; import org.springframework.data.mongodb.ReactiveMongoDatabaseFactory; import org.springframework.test.util.ReflectionTestUtils; @@ -60,7 +59,7 @@ public class SimpleReactiveMongoDatabaseFactoryUnitTests { Object singletonTarget = AopProxyUtils .getSingletonTarget(ReflectionTestUtils.getField(invocationHandler, "advised")); - assertThat(singletonTarget, is(sameInstance(database))); + assertThat(singletonTarget).isSameAs(database); } @Test // DATAMONGO-1903 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/UnwrapAndReadDocumentCallbackUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/UnwrapAndReadDocumentCallbackUnitTests.java index 7651ce9df..dcf2f2a39 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/UnwrapAndReadDocumentCallbackUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/UnwrapAndReadDocumentCallbackUnitTests.java @@ -15,9 +15,8 @@ */ package org.springframework.data.mongodb.core; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import static org.mockito.Mockito.when; +import static org.assertj.core.api.Assertions.*; +import static org.mockito.Mockito.*; import org.bson.Document; import org.junit.Before; @@ -25,6 +24,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.MongoDbFactory; import org.springframework.data.mongodb.core.MongoTemplate.UnwrapAndReadDocumentCallback; import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver; @@ -62,8 +62,8 @@ public class UnwrapAndReadDocumentCallbackUnitTests { Target target = callback.doWith(new Document("foo", "bar")); - assertThat(target.id, is(nullValue())); - assertThat(target.foo, is("bar")); + assertThat(target.id).isNull(); + assertThat(target.foo).isEqualTo("bar"); } @Test @@ -71,8 +71,8 @@ public class UnwrapAndReadDocumentCallbackUnitTests { Target target = callback.doWith(new Document("_id", new Document("foo", "bar"))); - assertThat(target.id, is(nullValue())); - assertThat(target.foo, is("bar")); + assertThat(target.id).isNull(); + assertThat(target.foo).isEqualTo("bar"); } @Test @@ -80,8 +80,8 @@ public class UnwrapAndReadDocumentCallbackUnitTests { Target target = callback.doWith(new Document("_id", new Document("foo", "bar")).append("foo", "foobar")); - assertThat(target.id, is(nullValue())); - assertThat(target.foo, is("foobar")); + assertThat(target.id).isNull(); + assertThat(target.foo).isEqualTo("foobar"); } @Test @@ -89,8 +89,8 @@ public class UnwrapAndReadDocumentCallbackUnitTests { Target target = callback.doWith(new Document("_id", "bar").append("foo", "foo")); - assertThat(target.id, is("bar")); - assertThat(target.foo, is("foo")); + assertThat(target.id).isEqualTo("bar"); + assertThat(target.foo).isEqualTo("foo"); } static class Target { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationTests.java index 7e481e511..49815735d 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationTests.java @@ -15,12 +15,11 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.assertj.core.api.Assertions.*; import static org.springframework.data.domain.Sort.Direction.*; import static org.springframework.data.mongodb.core.aggregation.Aggregation.*; import static org.springframework.data.mongodb.core.aggregation.Fields.*; import static org.springframework.data.mongodb.core.query.Criteria.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import lombok.Builder; @@ -40,7 +39,6 @@ import org.joda.time.DateTime; import org.joda.time.DateTimeZone; import org.joda.time.LocalDateTime; import org.junit.After; -import org.junit.Assert; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -48,6 +46,7 @@ import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; import org.slf4j.Logger; import org.slf4j.LoggerFactory; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.io.ClassPathResource; import org.springframework.dao.DataAccessException; @@ -521,7 +520,7 @@ public class AggregationTests { /* //complex mongodb aggregation framework example from https://docs.mongodb.org/manual/tutorial/aggregation-examples/#largest-and-smallest-cities-by-state - + db.zipcodes.aggregate( { $group: { @@ -1553,7 +1552,7 @@ public class AggregationTests { Document firstItem = mappedResults.get(0); assertThat(firstItem).containsEntry("_id", "u1"); - Assert.assertThat(firstItem, isBsonObject().containing("linkedPerson.[0].firstname", "u1")); + assertThat(firstItem).containsEntry("linkedPerson.[0].firstname", "u1"); } @Test // DATAMONGO-1326 @@ -1574,7 +1573,7 @@ public class AggregationTests { Document firstItem = mappedResults.get(0); assertThat(firstItem).containsEntry("foreignKey", "u1"); - Assert.assertThat(firstItem, isBsonObject().containing("linkedPerson.[0].firstname", "u1")); + assertThat(firstItem).containsEntry("linkedPerson.[0].firstname", "u1"); } @Test // DATAMONGO-1418, DATAMONGO-1824 @@ -1784,7 +1783,8 @@ public class AggregationTests { assertThat(object).containsEntry("name", "Andrew").containsEntry("reportsTo", "Eliot"); assertThat(list).containsOnly( - new Document("_id", 2).append("name", "Eliot").append("reportsTo", "Dev").append("depth", 0L).append("_class", Employee.class.getName()), + new Document("_id", 2).append("name", "Eliot").append("reportsTo", "Dev").append("depth", 0L).append("_class", + Employee.class.getName()), new Document("_id", 1).append("name", "Dev").append("depth", 1L).append("_class", Employee.class.getName())); } @@ -1812,7 +1812,7 @@ public class AggregationTests { // { "_id" : 0 , "count" : 1 , "titles" : [ "Dancer"] , "sum" : 760.4000000000001} Document bound0 = result.getMappedResults().get(0); - Assert.assertThat(bound0, isBsonObject().containing("count", 1).containing("titles.[0]", "Dancer")); + assertThat(bound0).containsEntry("count", 1).containsEntry("titles.[0]", "Dancer"); assertThat((Double) bound0.get("sum")).isCloseTo(760.40, Offset.offset(0.1D)); // { "_id" : 100 , "count" : 2 , "titles" : [ "The Pillars of Society" , "The Great Wave off Kanagawa"] , "sum" : @@ -1846,8 +1846,8 @@ public class AggregationTests { // { "min" : 680.0 , "max" : 820.0 , "count" : 1 , "titles" : [ "Dancer"] , "sum" : 760.4000000000001} Document bound0 = result.getMappedResults().get(0); - Assert.assertThat(bound0, isBsonObject().containing("count", 1).containing("titles.[0]", "Dancer") - .containing("min", 680.0).containing("max")); + assertThat(bound0).containsEntry("count", 1).containsEntry("titles.[0]", "Dancer").containsEntry("min", 680.0) + .containsKey("max"); // { "min" : 820.0 , "max" : 1800.0 , "count" : 1 , "titles" : [ "The Great Wave off Kanagawa"] , "sum" : 1673.0} Document bound1 = result.getMappedResults().get(1); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/BucketAutoOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/BucketAutoOperationUnitTests.java index 90ae37e57..74d77dd99 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/BucketAutoOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/BucketAutoOperationUnitTests.java @@ -15,15 +15,14 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.core.Is.*; -import static org.junit.Assert.*; -import static org.springframework.data.mongodb.core.DocumentTestUtils.getAsDocument; +import static org.assertj.core.api.Assertions.*; +import static org.springframework.data.mongodb.core.DocumentTestUtils.*; import static org.springframework.data.mongodb.core.aggregation.Aggregation.*; -import org.junit.Test; -import org.springframework.data.mongodb.core.aggregation.BucketAutoOperation.Granularities; - import org.bson.Document; +import org.junit.Test; + +import org.springframework.data.mongodb.core.aggregation.BucketAutoOperation.Granularities; /** * Unit tests for {@link BucketAutoOperation}. @@ -50,8 +49,8 @@ public class BucketAutoOperationUnitTests { .andOutput("title").push().as("titles"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse( - "{ \"grossSalesPrice\" : { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\" , 2]} , \"titles\" : { $push: \"$title\" } }}"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse( + "{ \"grossSalesPrice\" : { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\" , 2]} , \"titles\" : { $push: \"$title\" } }}")); } @Test(expected = IllegalStateException.class) // DATAMONGO-1552 @@ -66,7 +65,7 @@ public class BucketAutoOperationUnitTests { .andOutputCount().as("titles"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ titles : { $sum: 1 } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ titles : { $sum: 1 } }")); } @Test // DATAMONGO-1552 @@ -74,7 +73,7 @@ public class BucketAutoOperationUnitTests { Document agg = bucketAuto("field", 1).withBuckets(5).toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(agg, is(Document.parse("{ $bucketAuto: { groupBy: \"$field\", buckets: 5 } }"))); + assertThat(agg).isEqualTo(Document.parse("{ $bucketAuto: { groupBy: \"$field\", buckets: 5 } }")); } @Test // DATAMONGO-1552 @@ -84,7 +83,8 @@ public class BucketAutoOperationUnitTests { .withGranularity(Granularities.E24) // .toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(agg, is(Document.parse("{ $bucketAuto: { buckets: 1, granularity: \"E24\", groupBy: \"$field\" } }"))); + assertThat(agg) + .isEqualTo(Document.parse("{ $bucketAuto: { buckets: 1, granularity: \"E24\", groupBy: \"$field\" } }")); } @Test // DATAMONGO-1552 @@ -94,7 +94,7 @@ public class BucketAutoOperationUnitTests { .andOutput("score").sum().as("cummulated_score"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ cummulated_score : { $sum: \"$score\" } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ cummulated_score : { $sum: \"$score\" } }")); } @Test // DATAMONGO-1552 @@ -104,8 +104,8 @@ public class BucketAutoOperationUnitTests { .andOutputExpression("netPrice + tax").apply("$multiply", 5).as("total"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), - is(Document.parse("{ total : { $multiply: [ {$add : [\"$netPrice\", \"$tax\"]}, 5] } }"))); + assertThat(extractOutput(agg)) + .isEqualTo(Document.parse("{ total : { $multiply: [ {$add : [\"$netPrice\", \"$tax\"]}, 5] } }")); } private static Document extractOutput(Document fromBucketClause) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/BucketOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/BucketOperationUnitTests.java index b491dfd4f..a41c3ae51 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/BucketOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/BucketOperationUnitTests.java @@ -15,14 +15,11 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.Matchers.*; -import static org.hamcrest.core.Is.is; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.aggregation.Aggregation.*; -import org.junit.Test; - import org.bson.Document; +import org.junit.Test; /** * Unit tests for {@link BucketOperation}. @@ -44,8 +41,8 @@ public class BucketOperationUnitTests { .andOutput("title").push().as("titles"); Document dbObject = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(dbObject), is(Document.parse( - "{ \"grossSalesPrice\" : { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\" , 2]} , \"titles\" : { $push: \"$title\" } }}"))); + assertThat(extractOutput(dbObject)).isEqualTo(Document.parse( + "{ \"grossSalesPrice\" : { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\" , 2]} , \"titles\" : { $push: \"$title\" } }}")); } @Test(expected = IllegalStateException.class) // DATAMONGO-1552 @@ -60,7 +57,7 @@ public class BucketOperationUnitTests { .andOutputCount().as("titles"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ titles : { $sum: 1 } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ titles : { $sum: 1 } }")); } @Test // DATAMONGO-1552 @@ -70,8 +67,8 @@ public class BucketOperationUnitTests { .andOutput(ArithmeticOperators.valueOf("quizzes").sum()).as("quizTotal") // .toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(agg, is(Document.parse( - "{ $bucket: { groupBy: \"$field\", boundaries: [], output : { quizTotal: { $sum: \"$quizzes\"} } } }"))); + assertThat(agg).isEqualTo(Document + .parse("{ $bucket: { groupBy: \"$field\", boundaries: [], output : { quizTotal: { $sum: \"$quizzes\"} } } }")); } @Test // DATAMONGO-1552 @@ -79,8 +76,8 @@ public class BucketOperationUnitTests { Document agg = bucket("field").withDefaultBucket("default bucket").toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(agg, - is(Document.parse("{ $bucket: { groupBy: \"$field\", boundaries: [], default: \"default bucket\" } }"))); + assertThat(agg).isEqualTo( + Document.parse("{ $bucket: { groupBy: \"$field\", boundaries: [], default: \"default bucket\" } }")); } @Test // DATAMONGO-1552 @@ -91,8 +88,8 @@ public class BucketOperationUnitTests { .withBoundaries(0) // .withBoundaries(10, 20).toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(agg, - is(Document.parse("{ $bucket: { boundaries: [0, 10, 20], default: \"default bucket\", groupBy: \"$field\" } }"))); + assertThat(agg).isEqualTo( + Document.parse("{ $bucket: { boundaries: [0, 10, 20], default: \"default bucket\", groupBy: \"$field\" } }")); } @Test // DATAMONGO-1552 @@ -102,7 +99,7 @@ public class BucketOperationUnitTests { .andOutput("score").sum().as("cummulated_score"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ cummulated_score : { $sum: \"$score\" } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ cummulated_score : { $sum: \"$score\" } }")); } @Test // DATAMONGO-1552 @@ -112,7 +109,7 @@ public class BucketOperationUnitTests { .andOutput("score").sum(4).as("cummulated_score"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ cummulated_score : { $sum: 4 } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ cummulated_score : { $sum: 4 } }")); } @Test // DATAMONGO-1552 @@ -122,7 +119,7 @@ public class BucketOperationUnitTests { .andOutput("score").avg().as("average"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ average : { $avg: \"$score\" } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ average : { $avg: \"$score\" } }")); } @Test // DATAMONGO-1552 @@ -132,7 +129,7 @@ public class BucketOperationUnitTests { .andOutput("title").first().as("first_title"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ first_title : { $first: \"$title\" } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ first_title : { $first: \"$title\" } }")); } @Test // DATAMONGO-1552 @@ -142,7 +139,7 @@ public class BucketOperationUnitTests { .andOutput("title").last().as("last_title"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ last_title : { $last: \"$title\" } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ last_title : { $last: \"$title\" } }")); } @Test // DATAMONGO-1552 @@ -152,7 +149,7 @@ public class BucketOperationUnitTests { .andOutput("score").min().as("min_score"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ min_score : { $min: \"$score\" } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ min_score : { $min: \"$score\" } }")); } @Test // DATAMONGO-1552 @@ -162,7 +159,7 @@ public class BucketOperationUnitTests { .andOutput("title").push().as("titles"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ titles : { $push: \"$title\" } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ titles : { $push: \"$title\" } }")); } @Test // DATAMONGO-1552 @@ -172,7 +169,7 @@ public class BucketOperationUnitTests { .andOutput("title").addToSet().as("titles"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ titles : { $addToSet: \"$title\" } }"))); + assertThat(extractOutput(agg)).isEqualTo(Document.parse("{ titles : { $addToSet: \"$title\" } }")); } @Test // DATAMONGO-1552 @@ -182,7 +179,8 @@ public class BucketOperationUnitTests { .andOutputExpression("netPrice + tax").sum().as("total"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), is(Document.parse("{ total : { $sum: { $add : [\"$netPrice\", \"$tax\"]} } }"))); + assertThat(extractOutput(agg)) + .isEqualTo(Document.parse("{ total : { $sum: { $add : [\"$netPrice\", \"$tax\"]} } }")); } @Test // DATAMONGO-1552 @@ -192,8 +190,8 @@ public class BucketOperationUnitTests { .andOutputExpression("netPrice + tax").apply("$multiply", 5).as("total"); Document agg = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(extractOutput(agg), - is(Document.parse("{ total : { $multiply: [ {$add : [\"$netPrice\", \"$tax\"]}, 5] } }"))); + assertThat(extractOutput(agg)) + .isEqualTo(Document.parse("{ total : { $multiply: [ {$add : [\"$netPrice\", \"$tax\"]}, 5] } }")); } @Test // DATAMONGO-1552 @@ -201,8 +199,8 @@ public class BucketOperationUnitTests { BucketOperation operation = bucket("field"); - assertThat(operation.getFields().exposesSingleFieldOnly(), is(true)); - assertThat(operation.getFields().getField("count"), is(notNullValue())); + assertThat(operation.getFields().exposesSingleFieldOnly()).isTrue(); + assertThat(operation.getFields().getField("count")).isNotNull(); } private static Document extractOutput(Document fromBucketClause) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/CondExpressionUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/CondExpressionUnitTests.java index 53c5824ad..ae0ebcd87 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/CondExpressionUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/CondExpressionUnitTests.java @@ -15,9 +15,8 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.junit.Assert.*; import static org.springframework.data.mongodb.core.aggregation.ConditionalOperators.Cond.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import java.util.Arrays; @@ -65,7 +64,7 @@ public class CondExpressionUnitTests { .append("then", "bright") // .append("else", "dark"); - assertThat(document, isBsonObject().containing("$cond", expectedCondition)); + assertThat(document).containsEntry("$cond", expectedCondition); } @Test // DATAMONGO-861, DATAMONGO-1542 @@ -80,7 +79,7 @@ public class CondExpressionUnitTests { .append("then", "bright") // .append("else", "dark"); - assertThat(document, isBsonObject().containing("$cond", expectedCondition)); + assertThat(document).containsEntry("$cond", expectedCondition); } @Test // DATAMONGO-861 @@ -102,7 +101,7 @@ public class CondExpressionUnitTests { .append("then", "bright") // .append("else", "$dark-field"); - assertThat(document, isBsonObject().containing("$cond", expectedCondition)); + assertThat(document).containsEntry("$cond", expectedCondition); } @Test // DATAMONGO-861, DATAMONGO-1542 @@ -122,7 +121,7 @@ public class CondExpressionUnitTests { .append("then", "bright") // .append("else", "dark"); - assertThat(document, isBsonObject().containing("$cond", expectedCondition)); + assertThat(document).containsEntry("$cond", expectedCondition); } @Test // DATAMONGO-861, DATAMONGO-1542 @@ -150,7 +149,7 @@ public class CondExpressionUnitTests { .append("then", "very-dark") // .append("else", "not-so-dark"); - assertThat(document, isBsonObject().containing("$cond.then.$cond", trueCondition)); - assertThat(document, isBsonObject().containing("$cond.else.$cond", falseCondition)); + assertThat(document).containsEntry("$cond.then.$cond", trueCondition); + assertThat(document).containsEntry("$cond.else.$cond", falseCondition); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/CountOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/CountOperationUnitTests.java index 63dab20d0..531f1b88a 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/CountOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/CountOperationUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; @@ -37,7 +36,8 @@ public class CountOperationUnitTests { public void shouldRenderCorrectly() { CountOperation countOperation = new CountOperation("field"); - assertThat(countOperation.toDocument(Aggregation.DEFAULT_CONTEXT), is(Document.parse("{$count : \"field\" }"))); + assertThat(countOperation.toDocument(Aggregation.DEFAULT_CONTEXT)) + .isEqualTo(Document.parse("{$count : \"field\" }")); } @Test // DATAMONGO-1549 @@ -45,8 +45,8 @@ public class CountOperationUnitTests { CountOperation countOperation = new CountOperation("field"); - assertThat(countOperation.getFields().exposesNoFields(), is(false)); - assertThat(countOperation.getFields().exposesSingleFieldOnly(), is(true)); - assertThat(countOperation.getFields().getField("field"), notNullValue()); + assertThat(countOperation.getFields().exposesNoFields()).isFalse(); + assertThat(countOperation.getFields().exposesSingleFieldOnly()).isTrue(); + assertThat(countOperation.getFields().getField("field")).isNotNull(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ExposedFieldsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ExposedFieldsUnitTests.java index 522d42d0b..eef3b9573 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ExposedFieldsUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ExposedFieldsUnitTests.java @@ -15,10 +15,10 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; + import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField; /** @@ -48,9 +48,9 @@ public class ExposedFieldsUnitTests { public void exposesSingleField() { ExposedFields fields = ExposedFields.synthetic(Fields.fields("foo")); - assertThat(fields.exposesSingleFieldOnly(), is(true)); + assertThat(fields.exposesSingleFieldOnly()).isTrue(); fields = fields.and(new ExposedField("bar", true)); - assertThat(fields.exposesSingleFieldOnly(), is(false)); + assertThat(fields.exposesSingleFieldOnly()).isFalse(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FacetOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FacetOperationUnitTests.java index 25dcff4b2..7b719d71f 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FacetOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FacetOperationUnitTests.java @@ -15,13 +15,12 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.*; import static org.springframework.data.mongodb.core.aggregation.Aggregation.*; -import static org.springframework.data.mongodb.test.util.Assertions.assertThat; +import static org.springframework.data.mongodb.test.util.Assertions.*; import org.bson.Document; import org.junit.Test; + import org.springframework.data.mongodb.core.query.Criteria; /** @@ -61,7 +60,7 @@ public class FacetOperationUnitTests { Document agg = facetOperation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(agg, is(Document.parse("{ $facet: { } }"))); + assertThat(agg).isEqualTo(Document.parse("{ $facet: { } }")); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-1552 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FieldsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FieldsUnitTests.java index ca315879d..679211f11 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FieldsUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FieldsUnitTests.java @@ -15,15 +15,14 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.aggregation.Fields.*; -import org.hamcrest.Matchers; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; -import org.springframework.data.mongodb.core.aggregation.Fields.AggregationField; + +import org.springframework.data.mongodb.core.aggregation.Fields.*; /** * Unit tests for {@link Fields}. @@ -76,8 +75,8 @@ public class FieldsUnitTests { AggregationField reference = new AggregationField("foo"); Fields fields = Fields.from(reference); - assertThat(fields, is(Matchers. iterableWithSize(1))); - assertThat(fields, hasItem(reference)); + assertThat(fields).hasSize(1); + assertThat(fields).contains(reference); } @Test @@ -90,7 +89,7 @@ public class FieldsUnitTests { Fields fields = fields("a", "b").and("c").and("d", "e"); - assertThat(fields, is(Matchers. iterableWithSize(4))); + assertThat(fields).hasSize(4); verify(fields.getField("a"), "a", null); verify(fields.getField("b"), "b", null); @@ -109,8 +108,8 @@ public class FieldsUnitTests { @Test // DATAMONGO-774 public void stripsLeadingDollarsFromName() { - assertThat(Fields.field("$name").getName(), is("name")); - assertThat(Fields.field("$$$$name").getName(), is("name")); + assertThat(Fields.field("$name").getName()).isEqualTo("name"); + assertThat(Fields.field("$$$$name").getName()).isEqualTo("name"); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-774 @@ -121,14 +120,14 @@ public class FieldsUnitTests { @Test // DATAMONGO-774 public void stripsLeadingDollarsFromTarget() { - assertThat(Fields.field("$target").getTarget(), is("target")); - assertThat(Fields.field("$$$$target").getTarget(), is("target")); + assertThat(Fields.field("$target").getTarget()).isEqualTo("target"); + assertThat(Fields.field("$$$$target").getTarget()).isEqualTo("target"); } private static void verify(Field field, String name, String target) { - assertThat(field, is(notNullValue())); - assertThat(field.getName(), is(name)); - assertThat(field.getTarget(), is(target != null ? target : name)); + assertThat(field).isNotNull(); + assertThat(field.getName()).isEqualTo(name); + assertThat(field.getTarget()).isEqualTo(target != null ? target : name); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FilterExpressionUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FilterExpressionUnitTests.java index be2fe8a9f..34a39cc8f 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FilterExpressionUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/FilterExpressionUnitTests.java @@ -15,9 +15,8 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.core.Is.*; -import static org.junit.Assert.*; -import static org.springframework.data.mongodb.core.aggregation.ArrayOperators.Filter.*; +import static org.assertj.core.api.Assertions.*; +import static org.springframework.data.mongodb.core.aggregation.ArrayOperators.Filter.filter; import java.util.Arrays; import java.util.List; @@ -28,6 +27,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.MongoDbFactory; import org.springframework.data.mongodb.core.DocumentTestUtils; import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver; @@ -75,7 +75,7 @@ public class FilterExpressionUnitTests { "cond: { $gte: [ \"$$item.price\", 100 ] }" + // "}"); - assertThat($filter, is(new Document(expected))); + assertThat($filter).isEqualTo(new Document(expected)); } @Test // DATAMONGO-1491 @@ -97,7 +97,7 @@ public class FilterExpressionUnitTests { "cond: { $gte: [ \"$$item.price\", 100 ] }" + // "}"); - assertThat($filter, is(expected)); + assertThat($filter).isEqualTo(expected); } @Test // DATAMONGO-1491 @@ -120,7 +120,7 @@ public class FilterExpressionUnitTests { "cond: { $gte: [ \"$$num\", 3 ] }" + // "}"); - assertThat($filter, is(expected)); + assertThat($filter).isEqualTo(expected); } static class Sales { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/GroupOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/GroupOperationUnitTests.java index a6a9385c2..97a51e249 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/GroupOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/GroupOperationUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.aggregation.AggregationFunctionExpressions.*; import static org.springframework.data.mongodb.core.aggregation.Fields.*; @@ -24,6 +23,7 @@ import java.util.Arrays; import org.bson.Document; import org.junit.Test; + import org.springframework.data.mongodb.core.DocumentTestUtils; import org.springframework.data.mongodb.core.query.Criteria; @@ -48,9 +48,9 @@ public class GroupOperationUnitTests { ExposedFields fields = operation.getFields(); Document groupClause = extractDocumentFromGroupOperation(operation); - assertThat(fields.exposesSingleFieldOnly(), is(true)); - assertThat(fields.exposesNoFields(), is(false)); - assertThat(groupClause.get(UNDERSCORE_ID), is(nullValue())); + assertThat(fields.exposesSingleFieldOnly()).isTrue(); + assertThat(fields.exposesNoFields()).isFalse(); + assertThat(groupClause.get(UNDERSCORE_ID)).isNull(); } @Test // DATAMONGO-759 @@ -60,11 +60,11 @@ public class GroupOperationUnitTests { ExposedFields fields = operation.getFields(); Document groupClause = extractDocumentFromGroupOperation(operation); - assertThat(fields.exposesSingleFieldOnly(), is(false)); - assertThat(fields.exposesNoFields(), is(false)); - assertThat(groupClause.get(UNDERSCORE_ID), is(nullValue())); - assertThat((Document) groupClause.get("cnt"), is(new Document("$sum", 1))); - assertThat((Document) groupClause.get("foo"), is(new Document("$last", "$foo"))); + assertThat(fields.exposesSingleFieldOnly()).isFalse(); + assertThat(fields.exposesNoFields()).isFalse(); + assertThat(groupClause.get(UNDERSCORE_ID)).isNull(); + assertThat((Document) groupClause.get("cnt")).isEqualTo(new Document("$sum", 1)); + assertThat((Document) groupClause.get("foo")).isEqualTo(new Document("$last", "$foo")); } @Test @@ -74,7 +74,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(operation); - assertThat(groupClause.get(UNDERSCORE_ID), is((Object) "$a")); + assertThat(groupClause.get(UNDERSCORE_ID)).isEqualTo((Object) "$a"); } @Test @@ -85,8 +85,8 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(operation); Document idClause = DocumentTestUtils.getAsDocument(groupClause, UNDERSCORE_ID); - assertThat(idClause.get("a"), is((Object) "$a")); - assertThat(idClause.get("b"), is((Object) "$c")); + assertThat(idClause.get("a")).isEqualTo((Object) "$a"); + assertThat(idClause.get("b")).isEqualTo((Object) "$c"); } @Test @@ -97,7 +97,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document eOp = DocumentTestUtils.getAsDocument(groupClause, "e"); - assertThat(eOp, is((Document) new Document("$sum", "$e"))); + assertThat(eOp).isEqualTo((Document) new Document("$sum", "$e")); } @Test @@ -108,7 +108,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document eOp = DocumentTestUtils.getAsDocument(groupClause, "ee"); - assertThat(eOp, is((Document) new Document("$sum", "$e"))); + assertThat(eOp).isEqualTo((Document) new Document("$sum", "$e")); } @Test @@ -119,7 +119,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document eOp = DocumentTestUtils.getAsDocument(groupClause, "count"); - assertThat(eOp, is((Document) new Document("$sum", 1))); + assertThat(eOp).isEqualTo((Document) new Document("$sum", 1)); } @Test @@ -131,10 +131,10 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document sum = DocumentTestUtils.getAsDocument(groupClause, "sum"); - assertThat(sum, is((Document) new Document("$sum", "$e"))); + assertThat(sum).isEqualTo((Document) new Document("$sum", "$e")); Document min = DocumentTestUtils.getAsDocument(groupClause, "min"); - assertThat(min, is((Document) new Document("$min", "$e"))); + assertThat(min).isEqualTo((Document) new Document("$min", "$e")); } @Test @@ -145,7 +145,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document push = DocumentTestUtils.getAsDocument(groupClause, "x"); - assertThat(push, is((Document) new Document("$push", 1))); + assertThat(push).isEqualTo((Document) new Document("$push", 1)); } @Test @@ -156,7 +156,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document push = DocumentTestUtils.getAsDocument(groupClause, "x"); - assertThat(push, is((Document) new Document("$push", "$ref"))); + assertThat(push).isEqualTo((Document) new Document("$push", "$ref")); } @Test @@ -167,7 +167,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document push = DocumentTestUtils.getAsDocument(groupClause, "x"); - assertThat(push, is((Document) new Document("$addToSet", "$ref"))); + assertThat(push).isEqualTo((Document) new Document("$addToSet", "$ref")); } @Test @@ -178,7 +178,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document push = DocumentTestUtils.getAsDocument(groupClause, "x"); - assertThat(push, is((Document) new Document("$addToSet", 42))); + assertThat(push).isEqualTo((Document) new Document("$addToSet", 42)); } @Test // DATAMONGO-979 @@ -192,7 +192,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document tagsCount = DocumentTestUtils.getAsDocument(groupClause, "tags_count"); - assertThat(tagsCount.get("$first"), is((Object) new Document("$size", Arrays.asList("$tags")))); + assertThat(tagsCount.get("$first")).isEqualTo((Object) new Document("$size", Arrays.asList("$tags"))); } @Test // DATAMONGO-1327 @@ -203,7 +203,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document push = DocumentTestUtils.getAsDocument(groupClause, "fieldStdDevSamp"); - assertThat(push, is(new Document("$stdDevSamp", "$field"))); + assertThat(push).isEqualTo(new Document("$stdDevSamp", "$field")); } @Test // DATAMONGO-1327 @@ -214,7 +214,7 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document push = DocumentTestUtils.getAsDocument(groupClause, "fieldStdDevPop"); - assertThat(push, is(new Document("$stdDevPop", "$field"))); + assertThat(push).isEqualTo(new Document("$stdDevPop", "$field")); } @Test // DATAMONGO-1784 @@ -231,8 +231,8 @@ public class GroupOperationUnitTests { Document groupClause = extractDocumentFromGroupOperation(groupOperation); Document foobar = DocumentTestUtils.getAsDocument(groupClause, "foobar"); - assertThat(foobar.get("$sum"), is(new Document("$cond", - new Document("if", new Document("$eq", Arrays.asList("$foo", "bar"))).append("then", 1).append("else", -1)))); + assertThat(foobar.get("$sum")).isEqualTo(new Document("$cond", + new Document("if", new Document("$eq", Arrays.asList("$foo", "bar"))).append("then", 1).append("else", -1))); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-1784 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/LookupOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/LookupOperationUnitTests.java index 836792f89..ef797145d 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/LookupOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/LookupOperationUnitTests.java @@ -15,12 +15,11 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; + import org.springframework.data.mongodb.core.DocumentTestUtils; /** @@ -59,11 +58,10 @@ public class LookupOperationUnitTests { Document lookupClause = extractDocumentFromLookupOperation(lookupOperation); - assertThat(lookupClause, - isBsonObject().containing("from", "a") // - .containing("localField", "b") // - .containing("foreignField", "c") // - .containing("as", "d")); + assertThat(lookupClause).containsEntry("from", "a") // + .containsEntry("localField", "b") // + .containsEntry("foreignField", "c") // + .containsEntry("as", "d"); } @Test // DATAMONGO-1326 @@ -71,9 +69,9 @@ public class LookupOperationUnitTests { LookupOperation lookupOperation = Aggregation.lookup("a", "b", "c", "d"); - assertThat(lookupOperation.getFields().exposesNoFields(), is(false)); - assertThat(lookupOperation.getFields().exposesSingleFieldOnly(), is(true)); - assertThat(lookupOperation.getFields().getField("d"), notNullValue()); + assertThat(lookupOperation.getFields().exposesNoFields()).isFalse(); + assertThat(lookupOperation.getFields().exposesSingleFieldOnly()).isTrue(); + assertThat(lookupOperation.getFields().getField("d")).isNotNull(); } private Document extractDocumentFromLookupOperation(LookupOperation lookupOperation) { @@ -110,11 +108,10 @@ public class LookupOperationUnitTests { Document lookupClause = extractDocumentFromLookupOperation(lookupOperation); - assertThat(lookupClause, - isBsonObject().containing("from", "a") // - .containing("localField", "b") // - .containing("foreignField", "c") // - .containing("as", "d")); + assertThat(lookupClause).containsEntry("from", "a") // + .containsEntry("localField", "b") // + .containsEntry("foreignField", "c") // + .containsEntry("as", "d"); } @Test // DATAMONGO-1326 @@ -122,8 +119,8 @@ public class LookupOperationUnitTests { LookupOperation lookupOperation = LookupOperation.newLookup().from("a").localField("b").foreignField("c").as("d"); - assertThat(lookupOperation.getFields().exposesNoFields(), is(false)); - assertThat(lookupOperation.getFields().exposesSingleFieldOnly(), is(true)); - assertThat(lookupOperation.getFields().getField("d"), notNullValue()); + assertThat(lookupOperation.getFields().exposesNoFields()).isFalse(); + assertThat(lookupOperation.getFields().exposesSingleFieldOnly()).isTrue(); + assertThat(lookupOperation.getFields().getField("d")).isNotNull(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ReplaceRootOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ReplaceRootOperationUnitTests.java index 85e0aae5a..48b348174 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ReplaceRootOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/ReplaceRootOperationUnitTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; + import org.springframework.data.mongodb.core.aggregation.ReplaceRootOperation.ReplaceRootDocumentOperation; /** @@ -46,7 +46,7 @@ public class ReplaceRootOperationUnitTests { .withDocument(new Document("hello", "world")); Document dbObject = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(dbObject, is(Document.parse("{ $replaceRoot : { newRoot: { hello: \"world\" } } }"))); + assertThat(dbObject).isEqualTo(Document.parse("{ $replaceRoot : { newRoot: { hello: \"world\" } } }")); } @Test // DATAMONGO-1550 @@ -59,8 +59,8 @@ public class ReplaceRootOperationUnitTests { Document dbObject = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(dbObject, is(Document.parse("{ $replaceRoot : { newRoot : { " - + "$map : { input : \"$array\" , as : \"element\" , in : { $multiply : [ \"$$element\" , 10]} } " + "} } }"))); + assertThat(dbObject).isEqualTo(Document.parse("{ $replaceRoot : { newRoot : { " + + "$map : { input : \"$array\" , as : \"element\" , in : { $multiply : [ \"$$element\" , 10]} } " + "} } }")); } @Test // DATAMONGO-1550 @@ -72,8 +72,8 @@ public class ReplaceRootOperationUnitTests { Document dbObject = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(dbObject, is(Document - .parse("{ $replaceRoot : { newRoot: { key: \"value\", multiply: { $multiply : [ \"$$element\" , 10]} } } }"))); + assertThat(dbObject).isEqualTo(Document + .parse("{ $replaceRoot : { newRoot: { key: \"value\", multiply: { $multiply : [ \"$$element\" , 10]} } } }")); } @Test // DATAMONGO-1550 @@ -87,7 +87,8 @@ public class ReplaceRootOperationUnitTests { Document dbObject = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(dbObject, is(Document.parse("{ $replaceRoot : { newRoot: { key: \"override\", key2: \"value2\"} } } }"))); + assertThat(dbObject) + .isEqualTo(Document.parse("{ $replaceRoot : { newRoot: { key: \"override\", key2: \"value2\"} } } }")); } @Test // DATAMONGO-1550 @@ -95,7 +96,7 @@ public class ReplaceRootOperationUnitTests { ReplaceRootOperation operation = new ReplaceRootOperation(Fields.field("field")); - assertThat(operation.getFields().exposesNoFields(), is(true)); - assertThat(operation.getFields().exposesSingleFieldOnly(), is(false)); + assertThat(operation.getFields().exposesNoFields()).isTrue(); + assertThat(operation.getFields().exposesSingleFieldOnly()).isFalse(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SampleOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SampleOperationUnitTests.java index 34283ffbd..c6f3a8e69 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SampleOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SampleOperationUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; @@ -50,10 +49,10 @@ public class SampleOperationUnitTests { Document sampleOperationDocument = sampleOperation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertNotNull(sampleOperationDocument.get(OP)); - assertThat(sampleOperationDocument.get(OP), is(instanceOf(Document.class))); + assertThat(sampleOperationDocument.get(OP)).isNotNull(); + assertThat(sampleOperationDocument.get(OP)).isInstanceOf(Document.class); Document sampleSizeDocument = sampleOperationDocument.get(OP, Document.class); - assertEquals(sampleSize, sampleSizeDocument.get(SIZE)); + assertThat(sampleSizeDocument.get(SIZE)).isEqualTo(sampleSize); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SkipOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SkipOperationUnitTests.java index 61729e20f..afb9dbc66 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SkipOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SkipOperationUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; @@ -41,6 +40,6 @@ public class SkipOperationUnitTests { SkipOperation operation = new SkipOperation(10L); Document document = operation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(document.get(OP), is((Object) 10L)); + assertThat(document.get(OP)).isEqualTo((Object) 10L); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SortOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SortOperationUnitTests.java index a484e617a..3eba5bb37 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SortOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SortOperationUnitTests.java @@ -15,12 +15,12 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.DocumentTestUtils.*; import org.bson.Document; import org.junit.Test; + import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort.Direction; @@ -39,8 +39,8 @@ public class SortOperationUnitTests { Document result = operation.toDocument(Aggregation.DEFAULT_CONTEXT); Document sortValue = getAsDocument(result, "$sort"); - assertThat(sortValue, is(notNullValue())); - assertThat(sortValue.get("foobar"), is((Object) 1)); + assertThat(sortValue).isNotNull(); + assertThat(sortValue.get("foobar")).isEqualTo((Object) 1); } @Test @@ -50,7 +50,7 @@ public class SortOperationUnitTests { Document result = operation.toDocument(Aggregation.DEFAULT_CONTEXT); Document sortValue = getAsDocument(result, "$sort"); - assertThat(sortValue, is(notNullValue())); - assertThat(sortValue.get("foobar"), is((Object) (0 - 1))); + assertThat(sortValue).isNotNull(); + assertThat(sortValue.get("foobar")).isEqualTo((Object) (0 - 1)); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerIntegrationTests.java index 7a6eebbd9..fe71c8f09 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerIntegrationTests.java @@ -15,14 +15,14 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mapping.MappingException; import org.springframework.data.mongodb.MongoDbFactory; @@ -62,8 +62,8 @@ public class SpelExpressionTransformerIntegrationTests { MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, new MongoMappingContext()); TypeBasedAggregationOperationContext ctxt = new TypeBasedAggregationOperationContext(Data.class, new MongoMappingContext(), new QueryMapper(converter)); - assertThat(transformer.transform("item.primitiveIntValue", ctxt, new Object[0]).toString(), - is("$item.primitiveIntValue")); + assertThat(transformer.transform("item.primitiveIntValue", ctxt, new Object[0]).toString()) + .isEqualTo("$item.primitiveIntValue"); } @Test // DATAMONGO-774 @@ -75,6 +75,6 @@ public class SpelExpressionTransformerIntegrationTests { MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, new MongoMappingContext()); TypeBasedAggregationOperationContext ctxt = new TypeBasedAggregationOperationContext(Data.class, new MongoMappingContext(), new QueryMapper(converter)); - assertThat(transformer.transform("item.value2", ctxt, new Object[0]).toString(), is("$item.value2")); + assertThat(transformer.transform("item.value2", ctxt, new Object[0]).toString()).isEqualTo("$item.value2"); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerUnitTests.java index bd938b21a..52e55d42e 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformerUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Arrays; @@ -24,6 +23,7 @@ import org.bson.Document; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; + import org.springframework.data.mongodb.core.Person; /** @@ -53,21 +53,21 @@ public class SpelExpressionTransformerUnitTests { @Test // DATAMONGO-774 public void shouldRenderConstantExpression() { - assertThat(transform("1"), is((Object) "1")); - assertThat(transform("-1"), is((Object) "-1")); - assertThat(transform("1.0"), is((Object) "1.0")); - assertThat(transform("-1.0"), is((Object) "-1.0")); - assertThat(transform("null"), is(nullValue())); + assertThat(transform("1")).isEqualTo((Object) "1"); + assertThat(transform("-1")).isEqualTo((Object) "-1"); + assertThat(transform("1.0")).isEqualTo((Object) "1.0"); + assertThat(transform("-1.0")).isEqualTo((Object) "-1.0"); + assertThat(transform("null")).isNull(); } @Test // DATAMONGO-774 public void shouldSupportKnownOperands() { - assertThat(transform("a + b"), is((Object) Document.parse("{ \"$add\" : [ \"$a\" , \"$b\"]}"))); - assertThat(transform("a - b"), is((Object) Document.parse("{ \"$subtract\" : [ \"$a\" , \"$b\"]}"))); - assertThat(transform("a * b"), is((Object) Document.parse("{ \"$multiply\" : [ \"$a\" , \"$b\"]}"))); - assertThat(transform("a / b"), is((Object) Document.parse("{ \"$divide\" : [ \"$a\" , \"$b\"]}"))); - assertThat(transform("a % b"), is((Object) Document.parse("{ \"$mod\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("a + b")).isEqualTo((Object) Document.parse("{ \"$add\" : [ \"$a\" , \"$b\"]}")); + assertThat(transform("a - b")).isEqualTo((Object) Document.parse("{ \"$subtract\" : [ \"$a\" , \"$b\"]}")); + assertThat(transform("a * b")).isEqualTo((Object) Document.parse("{ \"$multiply\" : [ \"$a\" , \"$b\"]}")); + assertThat(transform("a / b")).isEqualTo((Object) Document.parse("{ \"$divide\" : [ \"$a\" , \"$b\"]}")); + assertThat(transform("a % b")).isEqualTo((Object) Document.parse("{ \"$mod\" : [ \"$a\" , \"$b\"]}")); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-774 @@ -77,35 +77,35 @@ public class SpelExpressionTransformerUnitTests { @Test // DATAMONGO-774 public void shouldRenderSumExpression() { - assertThat(transform("a + 1"), is((Object) Document.parse("{ \"$add\" : [ \"$a\" , 1]}"))); + assertThat(transform("a + 1")).isEqualTo((Object) Document.parse("{ \"$add\" : [ \"$a\" , 1]}")); } @Test // DATAMONGO-774 public void shouldRenderFormula() { - assertThat(transform("(netPrice + surCharge) * taxrate + 42"), is((Object) Document.parse( - "{ \"$add\" : [ { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\"]} , 42]}"))); + assertThat(transform("(netPrice + surCharge) * taxrate + 42")).isEqualTo((Object) Document.parse( + "{ \"$add\" : [ { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\"]} , 42]}")); } @Test // DATAMONGO-774 public void shouldRenderFormulaInCurlyBrackets() { - assertThat(transform("{(netPrice + surCharge) * taxrate + 42}"), is((Object) Document.parse( - "{ \"$add\" : [ { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\"]} , 42]}"))); + assertThat(transform("{(netPrice + surCharge) * taxrate + 42}")).isEqualTo((Object) Document.parse( + "{ \"$add\" : [ { \"$multiply\" : [ { \"$add\" : [ \"$netPrice\" , \"$surCharge\"]} , \"$taxrate\"]} , 42]}")); } @Test // DATAMONGO-774 public void shouldRenderFieldReference() { - assertThat(transform("foo"), is((Object) "$foo")); - assertThat(transform("$foo"), is((Object) "$foo")); + assertThat(transform("foo")).isEqualTo((Object) "$foo"); + assertThat(transform("$foo")).isEqualTo((Object) "$foo"); } @Test // DATAMONGO-774 public void shouldRenderNestedFieldReference() { - assertThat(transform("foo.bar"), is((Object) "$foo.bar")); - assertThat(transform("$foo.bar"), is((Object) "$foo.bar")); + assertThat(transform("foo.bar")).isEqualTo((Object) "$foo.bar"); + assertThat(transform("$foo.bar")).isEqualTo((Object) "$foo.bar"); } @Test // DATAMONGO-774 @@ -113,52 +113,52 @@ public class SpelExpressionTransformerUnitTests { public void shouldRenderNestedIndexedFieldReference() { // TODO add support for rendering nested indexed field references - assertThat(transform("foo[3].bar"), is((Object) "$foo[3].bar")); + assertThat(transform("foo[3].bar")).isEqualTo((Object) "$foo[3].bar"); } @Test // DATAMONGO-774 public void shouldRenderConsecutiveOperation() { - assertThat(transform("1 + 1 + 1"), is((Object) Document.parse("{ \"$add\" : [ 1 , 1 , 1]}"))); + assertThat(transform("1 + 1 + 1")).isEqualTo((Object) Document.parse("{ \"$add\" : [ 1 , 1 , 1]}")); } @Test // DATAMONGO-774 public void shouldRenderComplexExpression0() { - assertThat(transform("-(1 + q)"), - is((Object) Document.parse("{ \"$multiply\" : [ -1 , { \"$add\" : [ 1 , \"$q\"]}]}"))); + assertThat(transform("-(1 + q)")) + .isEqualTo((Object) Document.parse("{ \"$multiply\" : [ -1 , { \"$add\" : [ 1 , \"$q\"]}]}")); } @Test // DATAMONGO-774 public void shouldRenderComplexExpression1() { - assertThat(transform("1 + (q + 1) / (q - 1)"), is((Object) Document.parse( - "{ \"$add\" : [ 1 , { \"$divide\" : [ { \"$add\" : [ \"$q\" , 1]} , { \"$subtract\" : [ \"$q\" , 1]}]}]}"))); + assertThat(transform("1 + (q + 1) / (q - 1)")).isEqualTo((Object) Document.parse( + "{ \"$add\" : [ 1 , { \"$divide\" : [ { \"$add\" : [ \"$q\" , 1]} , { \"$subtract\" : [ \"$q\" , 1]}]}]}")); } @Test // DATAMONGO-774 public void shouldRenderComplexExpression2() { - assertThat(transform("(q + 1 + 4 - 5) / (q + 1 + 3 + 4)"), is((Object) Document.parse( - "{ \"$divide\" : [ { \"$subtract\" : [ { \"$add\" : [ \"$q\" , 1 , 4]} , 5]} , { \"$add\" : [ \"$q\" , 1 , 3 , 4]}]}"))); + assertThat(transform("(q + 1 + 4 - 5) / (q + 1 + 3 + 4)")).isEqualTo((Object) Document.parse( + "{ \"$divide\" : [ { \"$subtract\" : [ { \"$add\" : [ \"$q\" , 1 , 4]} , 5]} , { \"$add\" : [ \"$q\" , 1 , 3 , 4]}]}")); } @Test // DATAMONGO-774 public void shouldRenderBinaryExpressionWithMixedSignsCorrectly() { - assertThat(transform("-4 + 1"), is((Object) Document.parse("{ \"$add\" : [ -4 , 1]}"))); - assertThat(transform("1 + -4"), is((Object) Document.parse("{ \"$add\" : [ 1 , -4]}"))); + assertThat(transform("-4 + 1")).isEqualTo((Object) Document.parse("{ \"$add\" : [ -4 , 1]}")); + assertThat(transform("1 + -4")).isEqualTo((Object) Document.parse("{ \"$add\" : [ 1 , -4]}")); } @Test // DATAMONGO-774 public void shouldRenderConsecutiveOperationsInComplexExpression() { - assertThat(transform("1 + 1 + (1 + 1 + 1) / q"), is( - (Object) Document.parse("{ \"$add\" : [ 1 , 1 , { \"$divide\" : [ { \"$add\" : [ 1 , 1 , 1]} , \"$q\"]}]}"))); + assertThat(transform("1 + 1 + (1 + 1 + 1) / q")).isEqualTo( + (Object) Document.parse("{ \"$add\" : [ 1 , 1 , { \"$divide\" : [ { \"$add\" : [ 1 , 1 , 1]} , \"$q\"]}]}")); } @Test // DATAMONGO-774 public void shouldRenderParameterExpressionResults() { - assertThat(transform("[0] + [1] + [2]", 1, 2, 3), is((Object) Document.parse("{ \"$add\" : [ 1 , 2 , 3]}"))); + assertThat(transform("[0] + [1] + [2]", 1, 2, 3)).isEqualTo((Object) Document.parse("{ \"$add\" : [ 1 , 2 , 3]}")); } @Test // DATAMONGO-774 @@ -167,8 +167,7 @@ public class SpelExpressionTransformerUnitTests { assertThat( ((Document) transform("[0].primitiveLongValue + [0].primitiveDoubleValue + [0].doubleValue.longValue()", data)) - .toJson(), - is(Document.parse("{ \"$add\" : [ 42 , 1.2345 , 23]}").toJson())); + .toJson()).isEqualTo(Document.parse("{ \"$add\" : [ 42 , 1.2345 , 23]}").toJson()); } @Test // DATAMONGO-774 @@ -177,9 +176,9 @@ public class SpelExpressionTransformerUnitTests { assertThat( ((Document) transform("((1 + [0].primitiveLongValue) + [0].primitiveDoubleValue) * [0].doubleValue.longValue()", - data)).toJson(), - is(new Document("$multiply", Arrays.asList(new Document("$add", Arrays.asList(1, 42L, 1.2345D, 23L)))) - .toJson())); + data)).toJson()).isEqualTo( + new Document("$multiply", Arrays.asList(new Document("$add", Arrays.asList(1, 42L, 1.2345D, 23L)))) + .toJson()); } @Test // DATAMONGO-840 @@ -187,746 +186,753 @@ public class SpelExpressionTransformerUnitTests { Person person = new Person(); person.setAge(10); - assertThat(transform("[0].age + a.c", person), is((Object) Document.parse("{ \"$add\" : [ 10 , \"$a.c\"] }"))); + assertThat(transform("[0].age + a.c", person)) + .isEqualTo((Object) Document.parse("{ \"$add\" : [ 10 , \"$a.c\"] }")); } @Test // DATAMONGO-840 public void shouldRenderCompoundExpressionsWithOnlyFieldReferences() { - assertThat(transform("a.b + a.c"), is((Object) Document.parse("{ \"$add\" : [ \"$a.b\" , \"$a.c\"]}"))); + assertThat(transform("a.b + a.c")).isEqualTo((Object) Document.parse("{ \"$add\" : [ \"$a.b\" , \"$a.c\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeAnd() { - assertThat(transform("and(a, b)"), is((Object) Document.parse("{ \"$and\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("and(a, b)")).isEqualTo((Object) Document.parse("{ \"$and\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeOr() { - assertThat(transform("or(a, b)"), is((Object) Document.parse("{ \"$or\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("or(a, b)")).isEqualTo((Object) Document.parse("{ \"$or\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeNot() { - assertThat(transform("not(a)"), is((Object) Document.parse("{ \"$not\" : [ \"$a\"]}"))); + assertThat(transform("not(a)")).isEqualTo((Object) Document.parse("{ \"$not\" : [ \"$a\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeSetEquals() { - assertThat(transform("setEquals(a, b)"), is((Object) Document.parse("{ \"$setEquals\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("setEquals(a, b)")) + .isEqualTo((Object) Document.parse("{ \"$setEquals\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeSetEqualsForArrays() { - assertThat(transform("setEquals(new int[]{1,2,3}, new int[]{4,5,6})"), - is((Object) Document.parse("{ \"$setEquals\" : [ [ 1 , 2 , 3] , [ 4 , 5 , 6]]}"))); + assertThat(transform("setEquals(new int[]{1,2,3}, new int[]{4,5,6})")) + .isEqualTo((Object) Document.parse("{ \"$setEquals\" : [ [ 1 , 2 , 3] , [ 4 , 5 , 6]]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeSetEqualsMixedArrays() { - assertThat(transform("setEquals(a, new int[]{4,5,6})"), - is((Object) Document.parse("{ \"$setEquals\" : [ \"$a\" , [ 4 , 5 , 6]]}"))); + assertThat(transform("setEquals(a, new int[]{4,5,6})")) + .isEqualTo((Object) Document.parse("{ \"$setEquals\" : [ \"$a\" , [ 4 , 5 , 6]]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceSetIntersection() { - assertThat(transform("setIntersection(a, new int[]{4,5,6})"), - is((Object) Document.parse("{ \"$setIntersection\" : [ \"$a\" , [ 4 , 5 , 6]]}"))); + assertThat(transform("setIntersection(a, new int[]{4,5,6})")) + .isEqualTo((Object) Document.parse("{ \"$setIntersection\" : [ \"$a\" , [ 4 , 5 , 6]]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceSetUnion() { - assertThat(transform("setUnion(a, new int[]{4,5,6})"), - is((Object) Document.parse("{ \"$setUnion\" : [ \"$a\" , [ 4 , 5 , 6]]}"))); + assertThat(transform("setUnion(a, new int[]{4,5,6})")) + .isEqualTo((Object) Document.parse("{ \"$setUnion\" : [ \"$a\" , [ 4 , 5 , 6]]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceSeDifference() { - assertThat(transform("setDifference(a, new int[]{4,5,6})"), - is((Object) Document.parse("{ \"$setDifference\" : [ \"$a\" , [ 4 , 5 , 6]]}"))); + assertThat(transform("setDifference(a, new int[]{4,5,6})")) + .isEqualTo((Object) Document.parse("{ \"$setDifference\" : [ \"$a\" , [ 4 , 5 , 6]]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceSetIsSubset() { - assertThat(transform("setIsSubset(a, new int[]{4,5,6})"), - is((Object) Document.parse("{ \"$setIsSubset\" : [ \"$a\" , [ 4 , 5 , 6]]}"))); + assertThat(transform("setIsSubset(a, new int[]{4,5,6})")) + .isEqualTo((Object) Document.parse("{ \"$setIsSubset\" : [ \"$a\" , [ 4 , 5 , 6]]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceAnyElementTrue() { - assertThat(transform("anyElementTrue(a)"), is((Object) Document.parse("{ \"$anyElementTrue\" : [ \"$a\"]}"))); + assertThat(transform("anyElementTrue(a)")).isEqualTo((Object) Document.parse("{ \"$anyElementTrue\" : [ \"$a\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceAllElementsTrue() { - assertThat(transform("allElementsTrue(a, new int[]{4,5,6})"), - is((Object) Document.parse("{ \"$allElementsTrue\" : [ \"$a\" , [ 4 , 5 , 6]]}"))); + assertThat(transform("allElementsTrue(a, new int[]{4,5,6})")) + .isEqualTo((Object) Document.parse("{ \"$allElementsTrue\" : [ \"$a\" , [ 4 , 5 , 6]]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceCmp() { - assertThat(transform("cmp(a, 250)"), is((Object) Document.parse("{ \"$cmp\" : [ \"$a\" , 250]}"))); + assertThat(transform("cmp(a, 250)")).isEqualTo((Object) Document.parse("{ \"$cmp\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceEq() { - assertThat(transform("eq(a, 250)"), is((Object) Document.parse("{ \"$eq\" : [ \"$a\" , 250]}"))); + assertThat(transform("eq(a, 250)")).isEqualTo((Object) Document.parse("{ \"$eq\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceGt() { - assertThat(transform("gt(a, 250)"), is((Object) Document.parse("{ \"$gt\" : [ \"$a\" , 250]}"))); + assertThat(transform("gt(a, 250)")).isEqualTo((Object) Document.parse("{ \"$gt\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceGte() { - assertThat(transform("gte(a, 250)"), is((Object) Document.parse("{ \"$gte\" : [ \"$a\" , 250]}"))); + assertThat(transform("gte(a, 250)")).isEqualTo((Object) Document.parse("{ \"$gte\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceLt() { - assertThat(transform("lt(a, 250)"), is((Object) Document.parse("{ \"$lt\" : [ \"$a\" , 250]}"))); + assertThat(transform("lt(a, 250)")).isEqualTo((Object) Document.parse("{ \"$lt\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceLte() { - assertThat(transform("lte(a, 250)"), is((Object) Document.parse("{ \"$lte\" : [ \"$a\" , 250]}"))); + assertThat(transform("lte(a, 250)")).isEqualTo((Object) Document.parse("{ \"$lte\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNe() { - assertThat(transform("ne(a, 250)"), is((Object) Document.parse("{ \"$ne\" : [ \"$a\" , 250]}"))); + assertThat(transform("ne(a, 250)")).isEqualTo((Object) Document.parse("{ \"$ne\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceAbs() { - assertThat(transform("abs(1)"), is((Object) Document.parse("{ \"$abs\" : 1}"))); + assertThat(transform("abs(1)")).isEqualTo((Object) Document.parse("{ \"$abs\" : 1}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceAdd() { - assertThat(transform("add(a, 250)"), is((Object) Document.parse("{ \"$add\" : [ \"$a\" , 250]}"))); + assertThat(transform("add(a, 250)")).isEqualTo((Object) Document.parse("{ \"$add\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceCeil() { - assertThat(transform("ceil(7.8)"), is((Object) Document.parse("{ \"$ceil\" : 7.8}"))); + assertThat(transform("ceil(7.8)")).isEqualTo((Object) Document.parse("{ \"$ceil\" : 7.8}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceDivide() { - assertThat(transform("divide(a, 250)"), is((Object) Document.parse("{ \"$divide\" : [ \"$a\" , 250]}"))); + assertThat(transform("divide(a, 250)")).isEqualTo((Object) Document.parse("{ \"$divide\" : [ \"$a\" , 250]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceExp() { - assertThat(transform("exp(2)"), is((Object) Document.parse("{ \"$exp\" : 2}"))); + assertThat(transform("exp(2)")).isEqualTo((Object) Document.parse("{ \"$exp\" : 2}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceFloor() { - assertThat(transform("floor(2)"), is((Object) Document.parse("{ \"$floor\" : 2}"))); + assertThat(transform("floor(2)")).isEqualTo((Object) Document.parse("{ \"$floor\" : 2}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceLn() { - assertThat(transform("ln(2)"), is((Object) Document.parse("{ \"$ln\" : 2}"))); + assertThat(transform("ln(2)")).isEqualTo((Object) Document.parse("{ \"$ln\" : 2}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceLog() { - assertThat(transform("log(100, 10)"), is((Object) Document.parse("{ \"$log\" : [ 100 , 10]}"))); + assertThat(transform("log(100, 10)")).isEqualTo((Object) Document.parse("{ \"$log\" : [ 100 , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceLog10() { - assertThat(transform("log10(100)"), is((Object) Document.parse("{ \"$log10\" : 100}"))); + assertThat(transform("log10(100)")).isEqualTo((Object) Document.parse("{ \"$log10\" : 100}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeMod() { - assertThat(transform("mod(a, b)"), is((Object) Document.parse("{ \"$mod\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("mod(a, b)")).isEqualTo((Object) Document.parse("{ \"$mod\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeMultiply() { - assertThat(transform("multiply(a, b)"), is((Object) Document.parse("{ \"$multiply\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("multiply(a, b)")).isEqualTo((Object) Document.parse("{ \"$multiply\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodePow() { - assertThat(transform("pow(a, 2)"), is((Object) Document.parse("{ \"$pow\" : [ \"$a\" , 2]}"))); + assertThat(transform("pow(a, 2)")).isEqualTo((Object) Document.parse("{ \"$pow\" : [ \"$a\" , 2]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceSqrt() { - assertThat(transform("sqrt(2)"), is((Object) Document.parse("{ \"$sqrt\" : 2}"))); + assertThat(transform("sqrt(2)")).isEqualTo((Object) Document.parse("{ \"$sqrt\" : 2}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeSubtract() { - assertThat(transform("subtract(a, b)"), is((Object) Document.parse("{ \"$subtract\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("subtract(a, b)")).isEqualTo((Object) Document.parse("{ \"$subtract\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceTrunc() { - assertThat(transform("trunc(2.1)"), is((Object) Document.parse("{ \"$trunc\" : 2.1}"))); + assertThat(transform("trunc(2.1)")).isEqualTo((Object) Document.parse("{ \"$trunc\" : 2.1}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeConcat() { - assertThat(transform("concat(a, b, 'c')"), - is((Object) Document.parse("{ \"$concat\" : [ \"$a\" , \"$b\" , \"c\"]}"))); + assertThat(transform("concat(a, b, 'c')")) + .isEqualTo((Object) Document.parse("{ \"$concat\" : [ \"$a\" , \"$b\" , \"c\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeSubstrc() { - assertThat(transform("substr(a, 0, 1)"), is((Object) Document.parse("{ \"$substr\" : [ \"$a\" , 0 , 1]}"))); + assertThat(transform("substr(a, 0, 1)")).isEqualTo((Object) Document.parse("{ \"$substr\" : [ \"$a\" , 0 , 1]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceToLower() { - assertThat(transform("toLower(a)"), is((Object) Document.parse("{ \"$toLower\" : \"$a\"}"))); + assertThat(transform("toLower(a)")).isEqualTo((Object) Document.parse("{ \"$toLower\" : \"$a\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceToUpper() { - assertThat(transform("toUpper(a)"), is((Object) Document.parse("{ \"$toUpper\" : \"$a\"}"))); + assertThat(transform("toUpper(a)")).isEqualTo((Object) Document.parse("{ \"$toUpper\" : \"$a\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeStrCaseCmp() { - assertThat(transform("strcasecmp(a, b)"), is((Object) Document.parse("{ \"$strcasecmp\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("strcasecmp(a, b)")) + .isEqualTo((Object) Document.parse("{ \"$strcasecmp\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceMeta() { - assertThat(transform("meta('textScore')"), is((Object) Document.parse("{ \"$meta\" : \"textScore\"}"))); + assertThat(transform("meta('textScore')")).isEqualTo((Object) Document.parse("{ \"$meta\" : \"textScore\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeArrayElemAt() { - assertThat(transform("arrayElemAt(a, 10)"), is((Object) Document.parse("{ \"$arrayElemAt\" : [ \"$a\" , 10]}"))); + assertThat(transform("arrayElemAt(a, 10)")) + .isEqualTo((Object) Document.parse("{ \"$arrayElemAt\" : [ \"$a\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeConcatArrays() { - assertThat(transform("concatArrays(a, b, c)"), - is((Object) Document.parse("{ \"$concatArrays\" : [ \"$a\" , \"$b\" , \"$c\"]}"))); + assertThat(transform("concatArrays(a, b, c)")) + .isEqualTo((Object) Document.parse("{ \"$concatArrays\" : [ \"$a\" , \"$b\" , \"$c\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeFilter() { - assertThat(transform("filter(a, 'num', '$$num' > 10)"), is((Object) Document.parse( - "{ \"$filter\" : { \"input\" : \"$a\" , \"as\" : \"num\" , \"cond\" : { \"$gt\" : [ \"$$num\" , 10]}}}"))); + assertThat(transform("filter(a, 'num', '$$num' > 10)")).isEqualTo((Object) Document.parse( + "{ \"$filter\" : { \"input\" : \"$a\" , \"as\" : \"num\" , \"cond\" : { \"$gt\" : [ \"$$num\" , 10]}}}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceIsArray() { - assertThat(transform("isArray(a)"), is((Object) Document.parse("{ \"$isArray\" : \"$a\"}"))); + assertThat(transform("isArray(a)")).isEqualTo((Object) Document.parse("{ \"$isArray\" : \"$a\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceIsSize() { - assertThat(transform("size(a)"), is((Object) Document.parse("{ \"$size\" : \"$a\"}"))); + assertThat(transform("size(a)")).isEqualTo((Object) Document.parse("{ \"$size\" : \"$a\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeSlice() { - assertThat(transform("slice(a, 10)"), is((Object) Document.parse("{ \"$slice\" : [ \"$a\" , 10]}"))); + assertThat(transform("slice(a, 10)")).isEqualTo((Object) Document.parse("{ \"$slice\" : [ \"$a\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeMap() { - assertThat(transform("map(quizzes, 'grade', '$$grade' + 2)"), is((Object) Document.parse( - "{ \"$map\" : { \"input\" : \"$quizzes\" , \"as\" : \"grade\" , \"in\" : { \"$add\" : [ \"$$grade\" , 2]}}}"))); + assertThat(transform("map(quizzes, 'grade', '$$grade' + 2)")).isEqualTo((Object) Document.parse( + "{ \"$map\" : { \"input\" : \"$quizzes\" , \"as\" : \"grade\" , \"in\" : { \"$add\" : [ \"$$grade\" , 2]}}}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeLet() { - assertThat(transform("let({low:1, high:'$$low'}, gt('$$low', '$$high'))"), is((Object) Document.parse( - "{ \"$let\" : { \"vars\" : { \"low\" : 1 , \"high\" : \"$$low\"} , \"in\" : { \"$gt\" : [ \"$$low\" , \"$$high\"]}}}"))); + assertThat(transform("let({low:1, high:'$$low'}, gt('$$low', '$$high'))")).isEqualTo((Object) Document.parse( + "{ \"$let\" : { \"vars\" : { \"low\" : 1 , \"high\" : \"$$low\"} , \"in\" : { \"$gt\" : [ \"$$low\" , \"$$high\"]}}}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceLiteral() { - assertThat(transform("literal($1)"), is((Object) Document.parse("{ \"$literal\" : \"$1\"}"))); + assertThat(transform("literal($1)")).isEqualTo((Object) Document.parse("{ \"$literal\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceDayOfYear() { - assertThat(transform("dayOfYear($1)"), is((Object) Document.parse("{ \"$dayOfYear\" : \"$1\"}"))); + assertThat(transform("dayOfYear($1)")).isEqualTo((Object) Document.parse("{ \"$dayOfYear\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceDayOfMonth() { - assertThat(transform("dayOfMonth($1)"), is((Object) Document.parse("{ \"$dayOfMonth\" : \"$1\"}"))); + assertThat(transform("dayOfMonth($1)")).isEqualTo((Object) Document.parse("{ \"$dayOfMonth\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceDayOfWeek() { - assertThat(transform("dayOfWeek($1)"), is((Object) Document.parse("{ \"$dayOfWeek\" : \"$1\"}"))); + assertThat(transform("dayOfWeek($1)")).isEqualTo((Object) Document.parse("{ \"$dayOfWeek\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceYear() { - assertThat(transform("year($1)"), is((Object) Document.parse("{ \"$year\" : \"$1\"}"))); + assertThat(transform("year($1)")).isEqualTo((Object) Document.parse("{ \"$year\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceMonth() { - assertThat(transform("month($1)"), is((Object) Document.parse("{ \"$month\" : \"$1\"}"))); + assertThat(transform("month($1)")).isEqualTo((Object) Document.parse("{ \"$month\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceWeek() { - assertThat(transform("week($1)"), is((Object) Document.parse("{ \"$week\" : \"$1\"}"))); + assertThat(transform("week($1)")).isEqualTo((Object) Document.parse("{ \"$week\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceHour() { - assertThat(transform("hour($1)"), is((Object) Document.parse("{ \"$hour\" : \"$1\"}"))); + assertThat(transform("hour($1)")).isEqualTo((Object) Document.parse("{ \"$hour\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceMinute() { - assertThat(transform("minute($1)"), is((Object) Document.parse("{ \"$minute\" : \"$1\"}"))); + assertThat(transform("minute($1)")).isEqualTo((Object) Document.parse("{ \"$minute\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceSecond() { - assertThat(transform("second($1)"), is((Object) Document.parse("{ \"$second\" : \"$1\"}"))); + assertThat(transform("second($1)")).isEqualTo((Object) Document.parse("{ \"$second\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceMillisecond() { - assertThat(transform("millisecond($1)"), is((Object) Document.parse("{ \"$millisecond\" : \"$1\"}"))); + assertThat(transform("millisecond($1)")).isEqualTo((Object) Document.parse("{ \"$millisecond\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceDateToString() { - assertThat(transform("dateToString('%Y-%m-%d', $date)"), - is((Object) Document.parse("{ \"$dateToString\" : { \"format\" : \"%Y-%m-%d\" , \"date\" : \"$date\"}}"))); + assertThat(transform("dateToString('%Y-%m-%d', $date)")).isEqualTo( + (Object) Document.parse("{ \"$dateToString\" : { \"format\" : \"%Y-%m-%d\" , \"date\" : \"$date\"}}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceCond() { - assertThat(transform("cond(qty > 250, 30, 20)"), is((Object) Document - .parse("{ \"$cond\" : { \"if\" : { \"$gt\" : [ \"$qty\" , 250]} , \"then\" : 30 , \"else\" : 20}}"))); + assertThat(transform("cond(qty > 250, 30, 20)")).isEqualTo((Object) Document + .parse("{ \"$cond\" : { \"if\" : { \"$gt\" : [ \"$qty\" , 250]} , \"then\" : 30 , \"else\" : 20}}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeIfNull() { - assertThat(transform("ifNull(a, 10)"), is((Object) Document.parse("{ \"$ifNull\" : [ \"$a\" , 10]}"))); + assertThat(transform("ifNull(a, 10)")).isEqualTo((Object) Document.parse("{ \"$ifNull\" : [ \"$a\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeSum() { - assertThat(transform("sum(a, b)"), is((Object) Document.parse("{ \"$sum\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("sum(a, b)")).isEqualTo((Object) Document.parse("{ \"$sum\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeAvg() { - assertThat(transform("avg(a, b)"), is((Object) Document.parse("{ \"$avg\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("avg(a, b)")).isEqualTo((Object) Document.parse("{ \"$avg\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceFirst() { - assertThat(transform("first($1)"), is((Object) Document.parse("{ \"$first\" : \"$1\"}"))); + assertThat(transform("first($1)")).isEqualTo((Object) Document.parse("{ \"$first\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceLast() { - assertThat(transform("last($1)"), is((Object) Document.parse("{ \"$last\" : \"$1\"}"))); + assertThat(transform("last($1)")).isEqualTo((Object) Document.parse("{ \"$last\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeMax() { - assertThat(transform("max(a, b)"), is((Object) Document.parse("{ \"$max\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("max(a, b)")).isEqualTo((Object) Document.parse("{ \"$max\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeMin() { - assertThat(transform("min(a, b)"), is((Object) Document.parse("{ \"$min\" : [ \"$a\" , \"$b\"]}"))); + assertThat(transform("min(a, b)")).isEqualTo((Object) Document.parse("{ \"$min\" : [ \"$a\" , \"$b\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodePush() { - assertThat(transform("push({'item':'$item', 'quantity':'$qty'})"), - is((Object) Document.parse("{ \"$push\" : { \"item\" : \"$item\" , \"quantity\" : \"$qty\"}}"))); + assertThat(transform("push({'item':'$item', 'quantity':'$qty'})")) + .isEqualTo((Object) Document.parse("{ \"$push\" : { \"item\" : \"$item\" , \"quantity\" : \"$qty\"}}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceAddToSet() { - assertThat(transform("addToSet($1)"), is((Object) Document.parse("{ \"$addToSet\" : \"$1\"}"))); + assertThat(transform("addToSet($1)")).isEqualTo((Object) Document.parse("{ \"$addToSet\" : \"$1\"}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeStdDevPop() { - assertThat(transform("stdDevPop(scores.score)"), - is((Object) Document.parse("{ \"$stdDevPop\" : [ \"$scores.score\"]}"))); + assertThat(transform("stdDevPop(scores.score)")) + .isEqualTo((Object) Document.parse("{ \"$stdDevPop\" : [ \"$scores.score\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderMethodReferenceNodeStdDevSamp() { - assertThat(transform("stdDevSamp(age)"), is((Object) Document.parse("{ \"$stdDevSamp\" : [ \"$age\"]}"))); + assertThat(transform("stdDevSamp(age)")).isEqualTo((Object) Document.parse("{ \"$stdDevSamp\" : [ \"$age\"]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodeEq() { - assertThat(transform("foo == 10"), is((Object) Document.parse("{ \"$eq\" : [ \"$foo\" , 10]}"))); + assertThat(transform("foo == 10")).isEqualTo((Object) Document.parse("{ \"$eq\" : [ \"$foo\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodeNe() { - assertThat(transform("foo != 10"), is((Object) Document.parse("{ \"$ne\" : [ \"$foo\" , 10]}"))); + assertThat(transform("foo != 10")).isEqualTo((Object) Document.parse("{ \"$ne\" : [ \"$foo\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodeGt() { - assertThat(transform("foo > 10"), is((Object) Document.parse("{ \"$gt\" : [ \"$foo\" , 10]}"))); + assertThat(transform("foo > 10")).isEqualTo((Object) Document.parse("{ \"$gt\" : [ \"$foo\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodeGte() { - assertThat(transform("foo >= 10"), is((Object) Document.parse("{ \"$gte\" : [ \"$foo\" , 10]}"))); + assertThat(transform("foo >= 10")).isEqualTo((Object) Document.parse("{ \"$gte\" : [ \"$foo\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodeLt() { - assertThat(transform("foo < 10"), is((Object) Document.parse("{ \"$lt\" : [ \"$foo\" , 10]}"))); + assertThat(transform("foo < 10")).isEqualTo((Object) Document.parse("{ \"$lt\" : [ \"$foo\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodeLte() { - assertThat(transform("foo <= 10"), is((Object) Document.parse("{ \"$lte\" : [ \"$foo\" , 10]}"))); + assertThat(transform("foo <= 10")).isEqualTo((Object) Document.parse("{ \"$lte\" : [ \"$foo\" , 10]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodePow() { - assertThat(transform("foo^2"), is((Object) Document.parse("{ \"$pow\" : [ \"$foo\" , 2]}"))); + assertThat(transform("foo^2")).isEqualTo((Object) Document.parse("{ \"$pow\" : [ \"$foo\" , 2]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodeOr() { - assertThat(transform("true || false"), is((Object) Document.parse("{ \"$or\" : [ true , false]}"))); + assertThat(transform("true || false")).isEqualTo((Object) Document.parse("{ \"$or\" : [ true , false]}")); } @Test // DATAMONGO-1530 public void shouldRenderComplexOperationNodeOr() { - assertThat(transform("1+2 || concat(a, b) || true"), is((Object) Document - .parse("{ \"$or\" : [ { \"$add\" : [ 1 , 2]} , { \"$concat\" : [ \"$a\" , \"$b\"]} , true]}"))); + assertThat(transform("1+2 || concat(a, b) || true")).isEqualTo( + (Object) Document.parse("{ \"$or\" : [ { \"$add\" : [ 1 , 2]} , { \"$concat\" : [ \"$a\" , \"$b\"]} , true]}")); } @Test // DATAMONGO-1530 public void shouldRenderOperationNodeAnd() { - assertThat(transform("true && false"), is((Object) Document.parse("{ \"$and\" : [ true , false]}"))); + assertThat(transform("true && false")).isEqualTo((Object) Document.parse("{ \"$and\" : [ true , false]}")); } @Test // DATAMONGO-1530 public void shouldRenderComplexOperationNodeAnd() { - assertThat(transform("1+2 && concat(a, b) && true"), is((Object) Document - .parse("{ \"$and\" : [ { \"$add\" : [ 1 , 2]} , { \"$concat\" : [ \"$a\" , \"$b\"]} , true]}"))); + assertThat(transform("1+2 && concat(a, b) && true")).isEqualTo((Object) Document + .parse("{ \"$and\" : [ { \"$add\" : [ 1 , 2]} , { \"$concat\" : [ \"$a\" , \"$b\"]} , true]}")); } @Test // DATAMONGO-1530 public void shouldRenderNotCorrectly() { - assertThat(transform("!true"), is((Object) Document.parse("{ \"$not\" : [ true]}"))); + assertThat(transform("!true")).isEqualTo((Object) Document.parse("{ \"$not\" : [ true]}")); } @Test // DATAMONGO-1530 public void shouldRenderComplexNotCorrectly() { - assertThat(transform("!(foo > 10)"), is((Object) Document.parse("{ \"$not\" : [ { \"$gt\" : [ \"$foo\" , 10]}]}"))); + assertThat(transform("!(foo > 10)")) + .isEqualTo((Object) Document.parse("{ \"$not\" : [ { \"$gt\" : [ \"$foo\" , 10]}]}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodReferenceIndexOfBytes() { - assertThat(transform("indexOfBytes(item, 'foo')"), - is(Document.parse("{ \"$indexOfBytes\" : [ \"$item\" , \"foo\"]}"))); + assertThat(transform("indexOfBytes(item, 'foo')")) + .isEqualTo(Document.parse("{ \"$indexOfBytes\" : [ \"$item\" , \"foo\"]}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodReferenceIndexOfCP() { - assertThat(transform("indexOfCP(item, 'foo')"), is(Document.parse("{ \"$indexOfCP\" : [ \"$item\" , \"foo\"]}"))); + assertThat(transform("indexOfCP(item, 'foo')")) + .isEqualTo(Document.parse("{ \"$indexOfCP\" : [ \"$item\" , \"foo\"]}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodReferenceSplit() { - assertThat(transform("split(item, ',')"), is(Document.parse("{ \"$split\" : [ \"$item\" , \",\"]}"))); + assertThat(transform("split(item, ',')")).isEqualTo(Document.parse("{ \"$split\" : [ \"$item\" , \",\"]}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodReferenceStrLenBytes() { - assertThat(transform("strLenBytes(item)"), is(Document.parse("{ \"$strLenBytes\" : \"$item\"}"))); + assertThat(transform("strLenBytes(item)")).isEqualTo(Document.parse("{ \"$strLenBytes\" : \"$item\"}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodReferenceStrLenCP() { - assertThat(transform("strLenCP(item)"), is(Document.parse("{ \"$strLenCP\" : \"$item\"}"))); + assertThat(transform("strLenCP(item)")).isEqualTo(Document.parse("{ \"$strLenCP\" : \"$item\"}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodSubstrCP() { - assertThat(transform("substrCP(item, 0, 5)"), is(Document.parse("{ \"$substrCP\" : [ \"$item\" , 0 , 5]}"))); + assertThat(transform("substrCP(item, 0, 5)")).isEqualTo(Document.parse("{ \"$substrCP\" : [ \"$item\" , 0 , 5]}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodReferenceReverseArray() { - assertThat(transform("reverseArray(array)"), is(Document.parse("{ \"$reverseArray\" : \"$array\"}"))); + assertThat(transform("reverseArray(array)")).isEqualTo(Document.parse("{ \"$reverseArray\" : \"$array\"}")); } @Test // DATAMONGO-1548 @Ignore("Document API cannot render String[]") public void shouldRenderMethodReferenceReduce() { - assertThat(transform("reduce(field, '', {'$concat':new String[]{'$$value','$$this'}})"), is(Document.parse( - "{ \"$reduce\" : { \"input\" : \"$field\" , \"initialValue\" : \"\" , \"in\" : { \"$concat\" : [ \"$$value\" , \"$$this\"]}}}"))); + assertThat(transform("reduce(field, '', {'$concat':new String[]{'$$value','$$this'}})")).isEqualTo(Document.parse( + "{ \"$reduce\" : { \"input\" : \"$field\" , \"initialValue\" : \"\" , \"in\" : { \"$concat\" : [ \"$$value\" , \"$$this\"]}}}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodReferenceZip() { - assertThat(transform("zip(new String[]{'$array1', '$array2'})"), - is(Document.parse("{ \"$zip\" : { \"inputs\" : [ \"$array1\" , \"$array2\"]}}"))); + assertThat(transform("zip(new String[]{'$array1', '$array2'})")) + .isEqualTo(Document.parse("{ \"$zip\" : { \"inputs\" : [ \"$array1\" , \"$array2\"]}}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodReferenceZipWithOptionalArgs() { - assertThat(transform("zip(new String[]{'$array1', '$array2'}, true, new int[]{1,2})"), is(Document.parse( - "{ \"$zip\" : { \"inputs\" : [ \"$array1\" , \"$array2\"] , \"useLongestLength\" : true , \"defaults\" : [ 1 , 2]}}"))); + assertThat(transform("zip(new String[]{'$array1', '$array2'}, true, new int[]{1,2})")).isEqualTo(Document.parse( + "{ \"$zip\" : { \"inputs\" : [ \"$array1\" , \"$array2\"] , \"useLongestLength\" : true , \"defaults\" : [ 1 , 2]}}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodIn() { - assertThat(transform("in('item', array)"), is(Document.parse("{ \"$in\" : [ \"item\" , \"$array\"]}"))); + assertThat(transform("in('item', array)")).isEqualTo(Document.parse("{ \"$in\" : [ \"item\" , \"$array\"]}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodRefereneIsoDayOfWeek() { - assertThat(transform("isoDayOfWeek(date)"), is(Document.parse("{ \"$isoDayOfWeek\" : \"$date\"}"))); + assertThat(transform("isoDayOfWeek(date)")).isEqualTo(Document.parse("{ \"$isoDayOfWeek\" : \"$date\"}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodRefereneIsoWeek() { - assertThat(transform("isoWeek(date)"), is(Document.parse("{ \"$isoWeek\" : \"$date\"}"))); + assertThat(transform("isoWeek(date)")).isEqualTo(Document.parse("{ \"$isoWeek\" : \"$date\"}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodRefereneIsoWeekYear() { - assertThat(transform("isoWeekYear(date)"), is(Document.parse("{ \"$isoWeekYear\" : \"$date\"}"))); + assertThat(transform("isoWeekYear(date)")).isEqualTo(Document.parse("{ \"$isoWeekYear\" : \"$date\"}")); } @Test // DATAMONGO-1548 public void shouldRenderMethodRefereneType() { - assertThat(transform("type(a)"), is(Document.parse("{ \"$type\" : \"$a\"}"))); + assertThat(transform("type(a)")).isEqualTo(Document.parse("{ \"$type\" : \"$a\"}")); } @Test // DATAMONGO-2077 public void shouldRenderArrayToObjectWithFieldReference() { - assertThat(transform("arrayToObject(field)"), is(Document.parse("{ \"$arrayToObject\" : \"$field\"}"))); + assertThat(transform("arrayToObject(field)")).isEqualTo(Document.parse("{ \"$arrayToObject\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderArrayToObjectWithArray() { - assertThat(transform("arrayToObject(new String[]{'key', 'value'})"), - is(Document.parse("{ \"$arrayToObject\" : [\"key\", \"value\"]}"))); + assertThat(transform("arrayToObject(new String[]{'key', 'value'})")) + .isEqualTo(Document.parse("{ \"$arrayToObject\" : [\"key\", \"value\"]}")); } @Test // DATAMONGO-2077 public void shouldRenderObjectToArrayWithFieldReference() { - assertThat(transform("objectToArray(field)"), is(Document.parse("{ \"$objectToArray\" : \"$field\"}"))); + assertThat(transform("objectToArray(field)")).isEqualTo(Document.parse("{ \"$objectToArray\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderMergeObjects() { - assertThat(transform("mergeObjects(field1, $$ROOT)"), - is(Document.parse("{ \"$mergeObjects\" : [\"$field1\", \"$$ROOT\"]}"))); + assertThat(transform("mergeObjects(field1, $$ROOT)")) + .isEqualTo(Document.parse("{ \"$mergeObjects\" : [\"$field1\", \"$$ROOT\"]}")); } @Test // DATAMONGO-2077 public void shouldRenderTrimWithoutChars() { - assertThat(transform("trim(field)"), is(Document.parse("{ \"$trim\" : {\"input\" : \"$field\"}}"))); + assertThat(transform("trim(field)")).isEqualTo(Document.parse("{ \"$trim\" : {\"input\" : \"$field\"}}")); } @Test // DATAMONGO-2077 public void shouldRenderTrimWithChars() { - assertThat(transform("trim(field, 'ie')"), - is(Document.parse("{ \"$trim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}"))); + assertThat(transform("trim(field, 'ie')")) + .isEqualTo(Document.parse("{ \"$trim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderTrimWithCharsFromFieldReference() { - assertThat(transform("trim(field1, field2)"), - is(Document.parse("{ \"$trim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}"))); + assertThat(transform("trim(field1, field2)")) + .isEqualTo(Document.parse("{ \"$trim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderLtrimWithoutChars() { - assertThat(transform("ltrim(field)"), is(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field\"}}"))); + assertThat(transform("ltrim(field)")).isEqualTo(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field\"}}")); } @Test // DATAMONGO-2077 public void shouldRenderLtrimWithChars() { - assertThat(transform("ltrim(field, 'ie')"), - is(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}"))); + assertThat(transform("ltrim(field, 'ie')")) + .isEqualTo(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderLtrimWithCharsFromFieldReference() { - assertThat(transform("ltrim(field1, field2)"), - is(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}"))); + assertThat(transform("ltrim(field1, field2)")) + .isEqualTo(Document.parse("{ \"$ltrim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderRtrimWithoutChars() { - assertThat(transform("rtrim(field)"), is(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field\"}}"))); + assertThat(transform("rtrim(field)")).isEqualTo(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field\"}}")); } @Test // DATAMONGO-2077 public void shouldRenderRtrimWithChars() { - assertThat(transform("rtrim(field, 'ie')"), - is(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}"))); + assertThat(transform("rtrim(field, 'ie')")) + .isEqualTo(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field\", \"chars\" : \"ie\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderRtrimWithCharsFromFieldReference() { - assertThat(transform("rtrim(field1, field2)"), - is(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}"))); + assertThat(transform("rtrim(field1, field2)")) + .isEqualTo(Document.parse("{ \"$rtrim\" : {\"input\" : \"$field1\", \"chars\" : \"$field2\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderConvertWithoutOptionalParameters() { - assertThat(transform("convert(field, 'string')"), - is(Document.parse("{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"string\" }}"))); + assertThat(transform("convert(field, 'string')")) + .isEqualTo(Document.parse("{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"string\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderConvertWithOnError() { - assertThat(transform("convert(field, 'int', 'Not an integer.')"), is(Document - .parse("{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"int\", \"onError\" : \"Not an integer.\" }}"))); + assertThat(transform("convert(field, 'int', 'Not an integer.')")).isEqualTo(Document + .parse("{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"int\", \"onError\" : \"Not an integer.\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderConvertWithOnErrorOnNull() { - assertThat(transform("convert(field, 'int', 'Not an integer.', -1)"), is(Document.parse( - "{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"int\", \"onError\" : \"Not an integer.\", \"onNull\" : -1 }}"))); + assertThat(transform("convert(field, 'int', 'Not an integer.', -1)")).isEqualTo(Document.parse( + "{ \"$convert\" : {\"input\" : \"$field\", \"to\" : \"int\", \"onError\" : \"Not an integer.\", \"onNull\" : -1 }}")); } @Test // DATAMONGO-2077 public void shouldRenderToBool() { - assertThat(transform("toBool(field)"), is(Document.parse("{ \"$toBool\" : \"$field\"}"))); + assertThat(transform("toBool(field)")).isEqualTo(Document.parse("{ \"$toBool\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderToDate() { - assertThat(transform("toDate(field)"), is(Document.parse("{ \"$toDate\" : \"$field\"}"))); + assertThat(transform("toDate(field)")).isEqualTo(Document.parse("{ \"$toDate\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderToDecimal() { - assertThat(transform("toDecimal(field)"), is(Document.parse("{ \"$toDecimal\" : \"$field\"}"))); + assertThat(transform("toDecimal(field)")).isEqualTo(Document.parse("{ \"$toDecimal\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderToDouble() { - assertThat(transform("toDouble(field)"), is(Document.parse("{ \"$toDouble\" : \"$field\"}"))); + assertThat(transform("toDouble(field)")).isEqualTo(Document.parse("{ \"$toDouble\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderToInt() { - assertThat(transform("toInt(field)"), is(Document.parse("{ \"$toInt\" : \"$field\"}"))); + assertThat(transform("toInt(field)")).isEqualTo(Document.parse("{ \"$toInt\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderToLong() { - assertThat(transform("toLong(field)"), is(Document.parse("{ \"$toLong\" : \"$field\"}"))); + assertThat(transform("toLong(field)")).isEqualTo(Document.parse("{ \"$toLong\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderToObjectId() { - assertThat(transform("toObjectId(field)"), is(Document.parse("{ \"$toObjectId\" : \"$field\"}"))); + assertThat(transform("toObjectId(field)")).isEqualTo(Document.parse("{ \"$toObjectId\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderToString() { - assertThat(transform("toString(field)"), is(Document.parse("{ \"$toString\" : \"$field\"}"))); + assertThat(transform("toString(field)")).isEqualTo(Document.parse("{ \"$toString\" : \"$field\"}")); } @Test // DATAMONGO-2077 public void shouldRenderDateFromStringWithoutOptionalParameters() { - assertThat(transform("dateFromString(field)"), - is(Document.parse("{ \"$dateFromString\" : {\"dateString\" : \"$field\" }}"))); + assertThat(transform("dateFromString(field)")) + .isEqualTo(Document.parse("{ \"$dateFromString\" : {\"dateString\" : \"$field\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderDateFromStringWithFormat() { - assertThat(transform("dateFromString(field, 'DD-MM-YYYY')"), - is(Document.parse("{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\" }}"))); + assertThat(transform("dateFromString(field, 'DD-MM-YYYY')")).isEqualTo( + Document.parse("{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderDateFromStringWithFormatAndTimezone() { - assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC')"), is(Document.parse( - "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\" }}"))); + assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC')")).isEqualTo(Document.parse( + "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\" }}")); } @Test // DATAMONGO-2077 public void shouldRenderDateFromStringWithFormatTimezoneAndOnError() { - assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC', -1)"), is(Document.parse( - "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\", \"onError\" : -1 }}"))); + assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC', -1)")).isEqualTo(Document.parse( + "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\", \"onError\" : -1 }}")); } @Test // DATAMONGO-2077 public void shouldRenderDateFromStringWithFormatTimezoneOnErrorAndOnNull() { - assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC', -1, -2)"), is(Document.parse( - "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\", \"onError\" : -1, \"onNull\" : -2}}"))); + assertThat(transform("dateFromString(field, 'DD-MM-YYYY', 'UTC', -1, -2)")).isEqualTo(Document.parse( + "{ \"$dateFromString\" : {\"dateString\" : \"$field\", \"format\" : \"DD-MM-YYYY\", \"timezone\" : \"UTC\", \"onError\" : -1, \"onNull\" : -2}}")); } @Test // DATAMONGO-2077 public void shouldRenderDateFromParts() { - assertThat(transform("dateFromParts(y, m, d, h, mm, s, ms, 'UTC')"), is(Document.parse( - "{ \"$dateFromParts\" : {\"year\" : \"$y\", \"month\" : \"$m\", \"day\" : \"$d\", \"hour\" : \"$h\", \"minute\" : \"$mm\", \"second\" : \"$s\", \"milliseconds\" : \"$ms\", \"timezone\" : \"UTC\"}}"))); + assertThat(transform("dateFromParts(y, m, d, h, mm, s, ms, 'UTC')")).isEqualTo(Document.parse( + "{ \"$dateFromParts\" : {\"year\" : \"$y\", \"month\" : \"$m\", \"day\" : \"$d\", \"hour\" : \"$h\", \"minute\" : \"$mm\", \"second\" : \"$s\", \"milliseconds\" : \"$ms\", \"timezone\" : \"UTC\"}}")); } @Test // DATAMONGO-2077 public void shouldRenderIsoDateFromParts() { - assertThat(transform("isoDateFromParts(y, m, d, h, mm, s, ms, 'UTC')"), is(Document.parse( - "{ \"$dateFromParts\" : {\"isoWeekYear\" : \"$y\", \"isoWeek\" : \"$m\", \"isoDayOfWeek\" : \"$d\", \"hour\" : \"$h\", \"minute\" : \"$mm\", \"second\" : \"$s\", \"milliseconds\" : \"$ms\", \"timezone\" : \"UTC\"}}"))); + assertThat(transform("isoDateFromParts(y, m, d, h, mm, s, ms, 'UTC')")).isEqualTo(Document.parse( + "{ \"$dateFromParts\" : {\"isoWeekYear\" : \"$y\", \"isoWeek\" : \"$m\", \"isoDayOfWeek\" : \"$d\", \"hour\" : \"$h\", \"minute\" : \"$mm\", \"second\" : \"$s\", \"milliseconds\" : \"$ms\", \"timezone\" : \"UTC\"}}")); } @Test // DATAMONGO-2077 public void shouldRenderDateToParts() { - assertThat(transform("dateToParts(field, 'UTC', false)"), is( - Document.parse("{ \"$dateToParts\" : {\"date\" : \"$field\", \"timezone\" : \"UTC\", \"iso8601\" : false}}"))); + assertThat(transform("dateToParts(field, 'UTC', false)")).isEqualTo( + Document.parse("{ \"$dateToParts\" : {\"date\" : \"$field\", \"timezone\" : \"UTC\", \"iso8601\" : false}}")); } @Test // DATAMONGO-2077 public void shouldRenderIndexOfArray() { - assertThat(transform("indexOfArray(field, 2)"), is(Document.parse("{ \"$indexOfArray\" : [\"$field\", 2 ]}"))); + assertThat(transform("indexOfArray(field, 2)")) + .isEqualTo(Document.parse("{ \"$indexOfArray\" : [\"$field\", 2 ]}")); } @Test // DATAMONGO-2077 public void shouldRenderRange() { - assertThat(transform("range(0, 10, 2)"), is(Document.parse("{ \"$range\" : [0, 10, 2 ]}"))); + assertThat(transform("range(0, 10, 2)")).isEqualTo(Document.parse("{ \"$range\" : [0, 10, 2 ]}")); } private Object transform(String expression, Object... params) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/TypeBasedAggregationOperationContextUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/TypeBasedAggregationOperationContextUnitTests.java index e4d0c88ce..ec8fb5258 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/TypeBasedAggregationOperationContextUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/TypeBasedAggregationOperationContextUnitTests.java @@ -15,12 +15,10 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; import static org.springframework.data.mongodb.core.DocumentTestUtils.*; import static org.springframework.data.mongodb.core.aggregation.Aggregation.*; import static org.springframework.data.mongodb.core.aggregation.Fields.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import lombok.AllArgsConstructor; @@ -34,6 +32,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.core.convert.converter.Converter; import org.springframework.core.convert.support.GenericConversionService; import org.springframework.data.annotation.Id; @@ -77,7 +76,7 @@ public class TypeBasedAggregationOperationContextUnitTests { @Test public void findsSimpleReference() { - assertThat(getContext(Foo.class).getReference("bar"), is(notNullValue())); + assertThat(getContext(Foo.class).getReference("bar")).isNotNull(); } @Test(expected = MappingException.class) @@ -92,16 +91,17 @@ public class TypeBasedAggregationOperationContextUnitTests { Field field = field("bar.name"); - assertThat(context.getReference("bar.name"), is(notNullValue())); - assertThat(context.getReference(field), is(notNullValue())); - assertThat(context.getReference(field), is(context.getReference("bar.name"))); + assertThat(context.getReference("bar.name")).isNotNull(); + assertThat(context.getReference(field)).isNotNull(); + assertThat(context.getReference(field)).isEqualTo(context.getReference("bar.name")); } @Test // DATAMONGO-806 public void aliasesIdFieldCorrectly() { AggregationOperationContext context = getContext(Foo.class); - assertThat(context.getReference("id"), is(new DirectFieldReference(new ExposedField(field("id", "_id"), true)))); + assertThat(context.getReference("id")) + .isEqualTo(new DirectFieldReference(new ExposedField(field("id", "_id"), true))); } @Test // DATAMONGO-912 @@ -119,7 +119,7 @@ public class TypeBasedAggregationOperationContextUnitTests { org.bson.Document agg = newAggregation(matchStage, projectStage).toDocument("test", context); org.bson.Document age = getValue(getValue(getPipelineElementFromAggregationAt(agg, 0), "$match"), "age"); - assertThat(age, is(new org.bson.Document("v", 10))); + assertThat(age).isEqualTo(new Document("v", 10)); } @Test // DATAMONGO-912 @@ -137,7 +137,7 @@ public class TypeBasedAggregationOperationContextUnitTests { org.bson.Document agg = newAggregation(projectStage, matchStage).toDocument("test", context); org.bson.Document age = getValue(getValue(getPipelineElementFromAggregationAt(agg, 1), "$match"), "age"); - assertThat(age, is(new org.bson.Document("v", 10))); + assertThat(age).isEqualTo(new Document("v", 10)); } @Test // DATAMONGO-960 @@ -151,13 +151,13 @@ public class TypeBasedAggregationOperationContextUnitTests { org.bson.Document document = agg.toDocument("person", context); org.bson.Document projection = getPipelineElementFromAggregationAt(document, 0); - assertThat(projection.containsKey("$project"), is(true)); + assertThat(projection.containsKey("$project")).isTrue(); - assertThat(projection.get("$project"), is(new Document("name", 1).append("age", 1))); + assertThat(projection.get("$project")).isEqualTo(new Document("name", 1).append("age", 1)); - assertThat(document.get("allowDiskUse"), is(true)); - assertThat(document.get("explain"), is(true)); - assertThat(document.get("cursor"), is(new Document("foo", 1))); + assertThat(document.get("allowDiskUse")).isEqualTo(true); + assertThat(document.get("explain")).isEqualTo(true); + assertThat(document.get("cursor")).isEqualTo(new Document("foo", 1)); } @Test // DATAMONGO-1585 @@ -171,7 +171,7 @@ public class TypeBasedAggregationOperationContextUnitTests { Document sort = getPipelineElementFromAggregationAt(dbo, 1); Document definition = (Document) sort.get("$sort"); - assertThat(definition.get("counter"), is(equalTo(1))); + assertThat(definition.get("counter")).isEqualTo(1); } @Test // DATAMONGO-1586 @@ -185,9 +185,8 @@ public class TypeBasedAggregationOperationContextUnitTests { Document dbo = agg.toDocument("person", context); Document projection = getPipelineElementFromAggregationAt(dbo, 0); - assertThat(getAsDocument(projection, "$project"), isBsonObject() // - .containing("person_name", "$name") // - .containing("age", "$age.value")); + assertThat(getAsDocument(projection, "$project")).containsEntry("person_name", "$name") // + .containsEntry("age", "$age.value"); } @Test // DATAMONGO-1893 @@ -200,7 +199,7 @@ public class TypeBasedAggregationOperationContextUnitTests { Document dbo = agg.toDocument("person", context); Document sort = getPipelineElementFromAggregationAt(dbo, 1); - assertThat(getAsDocument(sort, "$sort"), is(equalTo(new Document("age.value", 1).append("last_name", 1)))); + assertThat(getAsDocument(sort, "$sort")).isEqualTo(new Document("age.value", 1).append("last_name", 1)); } @Test // DATAMONGO-1133 @@ -215,7 +214,7 @@ public class TypeBasedAggregationOperationContextUnitTests { org.bson.Document definition = (org.bson.Document) group.get("$group"); - assertThat(definition.get("_id"), is(equalTo("$counter_name"))); + assertThat(definition.get("_id")).isEqualTo("$counter_name"); } @Test // DATAMONGO-1326, DATAMONGO-1585 @@ -231,8 +230,8 @@ public class TypeBasedAggregationOperationContextUnitTests { org.bson.Document definition = (org.bson.Document) sort.get("$sort"); - assertThat(definition.get("resourceId"), is(equalTo(1))); - assertThat(definition.get("counter_name"), is(equalTo(1))); + assertThat(definition.get("resourceId")).isEqualTo(1); + assertThat(definition.get("counter_name")).isEqualTo(1); } @Test // DATAMONGO-1326 @@ -247,7 +246,7 @@ public class TypeBasedAggregationOperationContextUnitTests { org.bson.Document definition = (org.bson.Document) sort.get("$sort"); - assertThat(definition.get("foreignKey"), is(equalTo(1))); + assertThat(definition.get("foreignKey")).isEqualTo(1); } @Test // DATAMONGO-1326 @@ -264,7 +263,7 @@ public class TypeBasedAggregationOperationContextUnitTests { org.bson.Document definition = (org.bson.Document) group.get("$group"); org.bson.Document field = (org.bson.Document) definition.get("something_totally_different"); - assertThat(field.get("$min"), is(equalTo("$lookup.otherkey"))); + assertThat(field.get("$min")).isEqualTo("$lookup.otherkey"); } @Test // DATAMONGO-1326 @@ -281,7 +280,7 @@ public class TypeBasedAggregationOperationContextUnitTests { org.bson.Document definition = (org.bson.Document) sort.get("$sort"); - assertThat(definition.get("something_totally_different"), is(equalTo(1))); + assertThat(definition.get("something_totally_different")).isEqualTo(1); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-1326 @@ -308,14 +307,14 @@ public class TypeBasedAggregationOperationContextUnitTests { Document document = agg.toDocument("person", context); Document projection = getPipelineElementFromAggregationAt(document, 0); - assertThat(projection.containsKey("$project"), is(true)); + assertThat(projection.containsKey("$project")).isTrue(); Document project = getValue(projection, "$project"); Document age = getValue(project, "age"); - assertThat(getValue(age, "$cond"), isBsonObject().containing("then.value", 0)); - assertThat(getValue(age, "$cond"), isBsonObject().containing("then._class", Age.class.getName())); - assertThat(getValue(age, "$cond"), isBsonObject().containing("else", "$age")); + assertThat((Document) getValue(age, "$cond")).containsEntry("then.value", 0); + assertThat((Document) getValue(age, "$cond")).containsEntry("then._class", Age.class.getName()); + assertThat((Document) getValue(age, "$cond")).containsEntry("else", "$age"); } /** @@ -333,17 +332,17 @@ public class TypeBasedAggregationOperationContextUnitTests { Document document = agg.toDocument("person", context); Document projection = getPipelineElementFromAggregationAt(document, 0); - assertThat(projection.containsKey("$project"), is(true)); + assertThat(projection.containsKey("$project")).isTrue(); Document project = getValue(projection, "$project"); Document age = getValue(project, "age"); - assertThat(age, is(Document.parse( - "{ $ifNull: [ \"$age\", { \"_class\":\"org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContextUnitTests$Age\", \"value\": 0} ] }"))); + assertThat(age).isEqualTo(Document.parse( + "{ $ifNull: [ \"$age\", { \"_class\":\"org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContextUnitTests$Age\", \"value\": 0} ] }")); - assertThat(age, isBsonObject().containing("$ifNull.[0]", "$age")); - assertThat(age, isBsonObject().containing("$ifNull.[1].value", 0)); - assertThat(age, isBsonObject().containing("$ifNull.[1]._class", Age.class.getName())); + assertThat(age).containsEntry("$ifNull.[0]", "$age"); + assertThat(age).containsEntry("$ifNull.[1].value", 0); + assertThat(age).containsEntry("$ifNull.[1]._class", Age.class.getName()); } @Test // DATAMONGO-1756 @@ -354,8 +353,8 @@ public class TypeBasedAggregationOperationContextUnitTests { Document agg = newAggregation(Wrapper.class, project().and("nested1.value1").plus("nested2.value2").as("val")) .toDocument("collection", context); - assertThat(getPipelineElementFromAggregationAt(agg, 0).get("$project"), is( - equalTo(new Document("val", new Document("$add", Arrays.asList("$nested1.value1", "$field2.nestedValue2")))))); + assertThat(getPipelineElementFromAggregationAt(agg, 0).get("$project")) + .isEqualTo(new Document("val", new Document("$add", Arrays.asList("$nested1.value1", "$field2.nestedValue2")))); } @org.springframework.data.mongodb.core.mapping.Document(collection = "person") diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/UnwindOperationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/UnwindOperationUnitTests.java index 2c1ad8f5b..0951e323a 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/UnwindOperationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/UnwindOperationUnitTests.java @@ -15,12 +15,11 @@ */ package org.springframework.data.mongodb.core.aggregation; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; + import org.springframework.data.mongodb.core.DocumentTestUtils; /** @@ -38,7 +37,7 @@ public class UnwindOperationUnitTests { Document pipeline = unwindOperation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(pipeline, isBsonObject().containing("$unwind", "$a")); + assertThat(pipeline).containsEntry("$unwind", "$a"); } @Test // DATAMONGO-1391 @@ -48,10 +47,9 @@ public class UnwindOperationUnitTests { Document unwindClause = extractDocumentFromUnwindOperation(unwindOperation); - assertThat(unwindClause, - isBsonObject().containing("path", "$a").// - containing("preserveNullAndEmptyArrays", false).// - containing("includeArrayIndex", "index")); + assertThat(unwindClause).containsEntry("path", "$a").// + containsEntry("preserveNullAndEmptyArrays", false).// + containsEntry("includeArrayIndex", "index"); } @Test // DATAMONGO-1391 @@ -59,7 +57,7 @@ public class UnwindOperationUnitTests { UnwindOperation unwindOperation = Aggregation.unwind("a", "index"); - assertThat(unwindOperation.getFields().getField("index"), is(not(nullValue()))); + assertThat(unwindOperation.getFields().getField("index")).isNotNull(); } @Test // DATAMONGO-1391 @@ -67,7 +65,7 @@ public class UnwindOperationUnitTests { UnwindOperation unwindOperation = Aggregation.unwind("a"); - assertThat(unwindOperation.getFields().exposesNoFields(), is(true)); + assertThat(unwindOperation.getFields().exposesNoFields()).isTrue(); } @Test // DATAMONGO-1391 @@ -77,10 +75,9 @@ public class UnwindOperationUnitTests { Document unwindClause = extractDocumentFromUnwindOperation(unwindOperation); - assertThat(unwindClause, - isBsonObject().containing("path", "$a").// - containing("preserveNullAndEmptyArrays", true).// - notContaining("includeArrayIndex")); + assertThat(unwindClause).containsEntry("path", "$a").// + containsEntry("preserveNullAndEmptyArrays", true).// + doesNotContainKey("includeArrayIndex"); } @Test // DATAMONGO-1391 @@ -89,7 +86,7 @@ public class UnwindOperationUnitTests { UnwindOperation unwindOperation = UnwindOperation.newUnwind().path("$foo").noArrayIndex().skipNullAndEmptyArrays(); Document pipeline = unwindOperation.toDocument(Aggregation.DEFAULT_CONTEXT); - assertThat(pipeline, isBsonObject().containing("$unwind", "$foo")); + assertThat(pipeline).containsEntry("$unwind", "$foo"); } @Test // DATAMONGO-1391 @@ -100,10 +97,9 @@ public class UnwindOperationUnitTests { Document unwindClause = extractDocumentFromUnwindOperation(unwindOperation); - assertThat(unwindClause, - isBsonObject().containing("path", "$foo").// - containing("preserveNullAndEmptyArrays", true).// - containing("includeArrayIndex", "myindex")); + assertThat(unwindClause).containsEntry("path", "$foo").// + containsEntry("preserveNullAndEmptyArrays", true).// + containsEntry("includeArrayIndex", "myindex"); } private Document extractDocumentFromUnwindOperation(UnwindOperation unwindOperation) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/CustomConvertersUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/CustomConvertersUnitTests.java index 8cc78c048..83c17cac3 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/CustomConvertersUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/CustomConvertersUnitTests.java @@ -15,19 +15,19 @@ */ package org.springframework.data.mongodb.core.convert; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import java.util.Arrays; import java.util.HashSet; import org.bson.Document; -import org.hamcrest.CoreMatchers; -import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.core.convert.converter.Converter; import org.springframework.data.annotation.Id; import org.springframework.data.convert.CustomConversions; @@ -109,7 +109,7 @@ public class CustomConvertersUnitTests { Document document = new Document(); document.put("foo", null); - Assert.assertThat(document.containsKey("foo"), CoreMatchers.is(true)); + assertThat(document.containsKey("foo")).isEqualTo(true); } public static class Foo { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DataMongo273Tests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DataMongo273Tests.java index 01700c3a0..ea8888707 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DataMongo273Tests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DataMongo273Tests.java @@ -15,7 +15,7 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import java.util.ArrayList; @@ -27,6 +27,7 @@ import org.bson.Document; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; + import org.springframework.data.mongodb.core.mapping.MongoMappingContext; /** @@ -67,9 +68,9 @@ public class DataMongo273Tests { @SuppressWarnings("unchecked") Map mapOfThings2 = converter.read(Map.class, result); - assertTrue(mapOfThings2.get("plane") instanceof Plane); - assertTrue(mapOfThings2.get("train") instanceof Train); - assertTrue(mapOfThings2.get("automobile") instanceof Automobile); + assertThat(mapOfThings2.get("plane") instanceof Plane).isTrue(); + assertThat(mapOfThings2.get("train") instanceof Train).isTrue(); + assertThat(mapOfThings2.get("automobile") instanceof Automobile).isTrue(); } @Test // DATAMONGO-294 @@ -90,9 +91,9 @@ public class DataMongo273Tests { List listOfThings2 = converter.read(List.class, result); - assertTrue(listOfThings2.get(0) instanceof Plane); - assertTrue(listOfThings2.get(1) instanceof Train); - assertTrue(listOfThings2.get(2) instanceof Automobile); + assertThat(listOfThings2.get(0) instanceof Plane).isTrue(); + assertThat(listOfThings2.get(1) instanceof Train).isTrue(); + assertThat(listOfThings2.get(2) instanceof Automobile).isTrue(); } @Test // DATAMONGO-294 @@ -120,9 +121,9 @@ public class DataMongo273Tests { List listOfThings2 = (List) shipment2.getBoxes().get("one"); - assertTrue(listOfThings2.get(0) instanceof Plane); - assertTrue(listOfThings2.get(1) instanceof Train); - assertTrue(listOfThings2.get(2) instanceof Automobile); + assertThat(listOfThings2.get(0) instanceof Plane).isTrue(); + assertThat(listOfThings2.get(1) instanceof Train).isTrue(); + assertThat(listOfThings2.get(2) instanceof Automobile).isTrue(); } static class Plane { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DbRefMappingMongoConverterUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DbRefMappingMongoConverterUnitTests.java index be55e769c..7db97834c 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DbRefMappingMongoConverterUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DbRefMappingMongoConverterUnitTests.java @@ -15,10 +15,8 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; -import static org.mockito.Mockito.any; import static org.springframework.data.mongodb.core.convert.LazyLoadingTestUtils.*; import java.io.Serializable; @@ -42,6 +40,7 @@ import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.annotation.AccessType; import org.springframework.data.annotation.AccessType.Type; import org.springframework.data.annotation.Id; @@ -54,7 +53,6 @@ import org.springframework.data.mongodb.core.convert.MappingMongoConverterUnitTe import org.springframework.data.mongodb.core.mapping.MongoMappingContext; import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity; import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty; -import org.springframework.data.mongodb.util.MongoClientVersion; import org.springframework.test.util.ReflectionTestUtils; import org.springframework.util.SerializationUtils; @@ -97,8 +95,8 @@ public class DbRefMappingMongoConverterUnitTests { person.id = "foo"; DBRef dbRef = converter.toDBRef(person, null); - assertThat(dbRef.getId(), is("foo")); - assertThat(dbRef.getCollectionName(), is("person")); + assertThat(dbRef.getId()).isEqualTo("foo"); + assertThat(dbRef.getCollectionName()).isEqualTo("person"); } @Test // DATAMONGO-657 @@ -135,13 +133,13 @@ public class DbRefMappingMongoConverterUnitTests { Document map = (Document) document.get("map"); - assertThat(map.get("test"), instanceOf(DBRef.class)); + assertThat(map.get("test")).isInstanceOf(DBRef.class); ((Document) document.get("map")).put("test", dbRef); MapDBRef read = converter.read(MapDBRef.class, document); - assertThat(read.map.get("test").id, is(BigInteger.ONE)); + assertThat(read.map.get("test").id).isEqualTo(BigInteger.ONE); } @Test // DATAMONGO-347 @@ -154,8 +152,8 @@ public class DbRefMappingMongoConverterUnitTests { person.id = "foo"; DBRef dbRef = converter.toDBRef(person, property); - assertThat(dbRef.getId(), is("foo")); - assertThat(dbRef.getCollectionName(), is("person")); + assertThat(dbRef.getId()).isEqualTo("foo"); + assertThat(dbRef.getCollectionName()).isEqualTo("person"); } @Test // DATAMONGO-348 @@ -174,9 +172,9 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converterSpy.read(ClassWithLazyDbRefs.class, document); assertProxyIsResolved(result.dbRefToInterface, false); - assertThat(result.dbRefToInterface.get(0).getId(), is(id)); + assertThat(result.dbRefToInterface.get(0).getId()).isEqualTo(id); assertProxyIsResolved(result.dbRefToInterface, true); - assertThat(result.dbRefToInterface.get(0).getValue(), is(value)); + assertThat(result.dbRefToInterface.get(0).getValue()).isEqualTo(value); } @Test // DATAMONGO-348 @@ -195,9 +193,9 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converterSpy.read(ClassWithLazyDbRefs.class, document); assertProxyIsResolved(result.dbRefToConcreteCollection, false); - assertThat(result.dbRefToConcreteCollection.get(0).getId(), is(id)); + assertThat(result.dbRefToConcreteCollection.get(0).getId()).isEqualTo(id); assertProxyIsResolved(result.dbRefToConcreteCollection, true); - assertThat(result.dbRefToConcreteCollection.get(0).getValue(), is(value)); + assertThat(result.dbRefToConcreteCollection.get(0).getValue()).isEqualTo(value); } @Test // DATAMONGO-348 @@ -216,9 +214,9 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converterSpy.read(ClassWithLazyDbRefs.class, document); assertProxyIsResolved(result.dbRefToConcreteType, false); - assertThat(result.dbRefToConcreteType.getId(), is(id)); + assertThat(result.dbRefToConcreteType.getId()).isEqualTo(id); assertProxyIsResolved(result.dbRefToConcreteType, true); - assertThat(result.dbRefToConcreteType.getValue(), is(value)); + assertThat(result.dbRefToConcreteType.getValue()).isEqualTo(value); } @Test // DATAMONGO-348 @@ -237,9 +235,9 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converterSpy.read(ClassWithLazyDbRefs.class, document); assertProxyIsResolved(result.dbRefToConcreteTypeWithPersistenceConstructor, false); - assertThat(result.dbRefToConcreteTypeWithPersistenceConstructor.getId(), is(id)); + assertThat(result.dbRefToConcreteTypeWithPersistenceConstructor.getId()).isEqualTo(id); assertProxyIsResolved(result.dbRefToConcreteTypeWithPersistenceConstructor, true); - assertThat(result.dbRefToConcreteTypeWithPersistenceConstructor.getValue(), is(value)); + assertThat(result.dbRefToConcreteTypeWithPersistenceConstructor.getValue()).isEqualTo(value); } @Test // DATAMONGO-348 @@ -259,9 +257,10 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converterSpy.read(ClassWithLazyDbRefs.class, document); assertProxyIsResolved(result.dbRefToConcreteTypeWithPersistenceConstructorWithoutDefaultConstructor, false); - assertThat(result.dbRefToConcreteTypeWithPersistenceConstructorWithoutDefaultConstructor.getId(), is(id)); + assertThat(result.dbRefToConcreteTypeWithPersistenceConstructorWithoutDefaultConstructor.getId()).isEqualTo(id); assertProxyIsResolved(result.dbRefToConcreteTypeWithPersistenceConstructorWithoutDefaultConstructor, true); - assertThat(result.dbRefToConcreteTypeWithPersistenceConstructorWithoutDefaultConstructor.getValue(), is(value)); + assertThat(result.dbRefToConcreteTypeWithPersistenceConstructorWithoutDefaultConstructor.getValue()) + .isEqualTo(value); } @Test // DATAMONGO-348 @@ -281,9 +280,9 @@ public class DbRefMappingMongoConverterUnitTests { SerializableClassWithLazyDbRefs deserializedResult = (SerializableClassWithLazyDbRefs) transport(result); - assertThat(deserializedResult.dbRefToSerializableTarget.getId(), is(id)); + assertThat(deserializedResult.dbRefToSerializableTarget.getId()).isEqualTo(id); assertProxyIsResolved(deserializedResult.dbRefToSerializableTarget, true); - assertThat(deserializedResult.dbRefToSerializableTarget.getValue(), is(value)); + assertThat(deserializedResult.dbRefToSerializableTarget.getValue()).isEqualTo(value); } @Test // DATAMONGO-884 @@ -301,9 +300,9 @@ public class DbRefMappingMongoConverterUnitTests { WithObjectMethodOverrideLazyDbRefs result = converterSpy.read(WithObjectMethodOverrideLazyDbRefs.class, document); - assertThat(result.dbRefToToStringObjectMethodOverride, is(notNullValue())); + assertThat(result.dbRefToToStringObjectMethodOverride).isNotNull(); assertProxyIsResolved(result.dbRefToToStringObjectMethodOverride, false); - assertThat(result.dbRefToToStringObjectMethodOverride.toString(), is(id + ":" + value)); + assertThat(result.dbRefToToStringObjectMethodOverride.toString()).isEqualTo(id + ":" + value); assertProxyIsResolved(result.dbRefToToStringObjectMethodOverride, true); } @@ -322,16 +321,16 @@ public class DbRefMappingMongoConverterUnitTests { WithObjectMethodOverrideLazyDbRefs result = converterSpy.read(WithObjectMethodOverrideLazyDbRefs.class, document); - assertThat(result.dbRefToPlainObject, is(notNullValue())); + assertThat(result.dbRefToPlainObject).isNotNull(); assertProxyIsResolved(result.dbRefToPlainObject, false); // calling Object#toString does not initialize the proxy. String proxyString = result.dbRefToPlainObject.toString(); - assertThat(proxyString, is("lazyDbRefTarget" + ":" + id + "$LazyLoadingProxy")); + assertThat(proxyString).isEqualTo("lazyDbRefTarget" + ":" + id + "$LazyLoadingProxy"); assertProxyIsResolved(result.dbRefToPlainObject, false); // calling another method not declared on object triggers proxy initialization. - assertThat(result.dbRefToPlainObject.getValue(), is(value)); + assertThat(result.dbRefToPlainObject.getValue()).isEqualTo(value); assertProxyIsResolved(result.dbRefToPlainObject, true); } @@ -350,12 +349,12 @@ public class DbRefMappingMongoConverterUnitTests { WithObjectMethodOverrideLazyDbRefs result = converterSpy.read(WithObjectMethodOverrideLazyDbRefs.class, document); - assertThat(result.dbRefToPlainObject, is(notNullValue())); + assertThat(result.dbRefToPlainObject).isNotNull(); assertProxyIsResolved(result.dbRefToPlainObject, false); - assertThat(result.dbRefToPlainObject, is(equalTo(result.dbRefToPlainObject))); - assertThat(result.dbRefToPlainObject, is(not(equalTo(null)))); - assertThat(result.dbRefToPlainObject, is(not(equalTo((Object) lazyDbRefs.dbRefToToStringObjectMethodOverride)))); + assertThat(result.dbRefToPlainObject).isEqualTo(result.dbRefToPlainObject); + assertThat(result.dbRefToPlainObject).isNotEqualTo(null); + assertThat(result.dbRefToPlainObject).isNotEqualTo((Object) lazyDbRefs.dbRefToToStringObjectMethodOverride); assertProxyIsResolved(result.dbRefToPlainObject, false); } @@ -375,10 +374,10 @@ public class DbRefMappingMongoConverterUnitTests { WithObjectMethodOverrideLazyDbRefs result = converterSpy.read(WithObjectMethodOverrideLazyDbRefs.class, document); - assertThat(result.dbRefToPlainObject, is(notNullValue())); + assertThat(result.dbRefToPlainObject).isNotNull(); assertProxyIsResolved(result.dbRefToPlainObject, false); - assertThat(result.dbRefToPlainObject.hashCode(), is(311365444)); + assertThat(result.dbRefToPlainObject.hashCode()).isEqualTo(311365444); assertProxyIsResolved(result.dbRefToPlainObject, false); } @@ -402,12 +401,12 @@ public class DbRefMappingMongoConverterUnitTests { WithObjectMethodOverrideLazyDbRefs result = converterSpy.read(WithObjectMethodOverrideLazyDbRefs.class, document); assertProxyIsResolved(result.dbRefEqualsAndHashcodeObjectMethodOverride1, false); - assertThat(result.dbRefEqualsAndHashcodeObjectMethodOverride1, is(notNullValue())); + assertThat(result.dbRefEqualsAndHashcodeObjectMethodOverride1).isNotNull(); result.dbRefEqualsAndHashcodeObjectMethodOverride1.equals(null); assertProxyIsResolved(result.dbRefEqualsAndHashcodeObjectMethodOverride1, true); assertProxyIsResolved(result.dbRefEqualsAndHashcodeObjectMethodOverride2, false); - assertThat(result.dbRefEqualsAndHashcodeObjectMethodOverride2, is(notNullValue())); + assertThat(result.dbRefEqualsAndHashcodeObjectMethodOverride2).isNotNull(); result.dbRefEqualsAndHashcodeObjectMethodOverride2.hashCode(); assertProxyIsResolved(result.dbRefEqualsAndHashcodeObjectMethodOverride2, true); } @@ -422,12 +421,12 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converter.read(ClassWithLazyDbRefs.class, document); - assertThat(result.id, is(lazyDbRefs.id)); - assertThat(result.dbRefToInterface, is(nullValue())); - assertThat(result.dbRefToConcreteCollection, is(nullValue())); - assertThat(result.dbRefToConcreteType, is(nullValue())); - assertThat(result.dbRefToConcreteTypeWithPersistenceConstructor, is(nullValue())); - assertThat(result.dbRefToConcreteTypeWithPersistenceConstructorWithoutDefaultConstructor, is(nullValue())); + assertThat(result.id).isEqualTo(lazyDbRefs.id); + assertThat(result.dbRefToInterface).isNull(); + assertThat(result.dbRefToConcreteCollection).isNull(); + assertThat(result.dbRefToConcreteType).isNull(); + assertThat(result.dbRefToConcreteTypeWithPersistenceConstructor).isNull(); + assertThat(result.dbRefToConcreteTypeWithPersistenceConstructorWithoutDefaultConstructor).isNull(); } @Test // DATAMONGO-1005 @@ -442,8 +441,8 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithDbRefField found = converter.read(ClassWithDbRefField.class, document); - assertThat(found, is(notNullValue())); - assertThat(found.reference, is(found)); + assertThat(found).isNotNull(); + assertThat(found.reference).isEqualTo(found); } @Test // DATAMONGO-1005 @@ -460,9 +459,9 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithNestedDbRefField found = converter.read(ClassWithNestedDbRefField.class, document); - assertThat(found, is(notNullValue())); - assertThat(found.nested, is(notNullValue())); - assertThat(found.nested.reference, is(found)); + assertThat(found).isNotNull(); + assertThat(found.nested).isNotNull(); + assertThat(found.nested.reference).isEqualTo(found); } @Test // DATAMONGO-1012 @@ -483,7 +482,7 @@ public class DbRefMappingMongoConverterUnitTests { MongoPersistentProperty idProperty = mappingContext.getRequiredPersistentEntity(LazyDbRefTarget.class) .getIdProperty(); - assertThat(accessor.getProperty(idProperty), is(notNullValue())); + assertThat(accessor.getProperty(idProperty)).isNotNull(); assertProxyIsResolved(result.dbRefToConcreteType, false); } @@ -501,7 +500,7 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converter.read(ClassWithLazyDbRefs.class, object); LazyDbRefTargetPropertyAccess proxy = result.dbRefToConcreteTypeWithPropertyAccess; - assertThat(ReflectionTestUtils.getField(proxy, "id"), is(nullValue())); + assertThat(ReflectionTestUtils.getField(proxy, "id")).isNull(); assertProxyIsResolved(proxy, false); } @@ -544,9 +543,9 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converterSpy.read(ClassWithLazyDbRefs.class, document); assertProxyIsResolved(result.dbRefToConcreteCollection, false); - assertThat(result.dbRefToConcreteCollection.get(0).getId(), is(id1)); + assertThat(result.dbRefToConcreteCollection.get(0).getId()).isEqualTo(id1); assertProxyIsResolved(result.dbRefToConcreteCollection, true); - assertThat(result.dbRefToConcreteCollection.get(1).getId(), is(id2)); + assertThat(result.dbRefToConcreteCollection.get(1).getId()).isEqualTo(id2); verify(converterSpy, never()).readRef(Mockito.any(DBRef.class)); } @@ -568,7 +567,7 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithDbRefSetConstructor result = converterSpy.read(ClassWithDbRefSetConstructor.class, document); - assertThat(result.dbRefToInterface, is(instanceOf(Set.class))); + assertThat(result.dbRefToInterface).isInstanceOf(Set.class); verify(converterSpy, never()).readRef(Mockito.any(DBRef.class)); } @@ -593,9 +592,9 @@ public class DbRefMappingMongoConverterUnitTests { ClassWithLazyDbRefs result = converterSpy.read(ClassWithLazyDbRefs.class, document); assertProxyIsResolved(result.dbRefToConcreteCollection, false); - assertThat(result.dbRefToConcreteCollection.get(0).getId(), is(id1)); + assertThat(result.dbRefToConcreteCollection.get(0).getId()).isEqualTo(id1); assertProxyIsResolved(result.dbRefToConcreteCollection, true); - assertThat(result.dbRefToConcreteCollection.get(1).getId(), is(id2)); + assertThat(result.dbRefToConcreteCollection.get(1).getId()).isEqualTo(id2); verify(converterSpy, times(2)).readRef(Mockito.any(DBRef.class)); verify(converterSpy, never()).bulkReadRefs(anyList()); @@ -625,9 +624,9 @@ public class DbRefMappingMongoConverterUnitTests { MapDBRef result = converterSpy.read(MapDBRef.class, document); // assertProxyIsResolved(result.map, false); - assertThat(result.map.get("one").id, is(val1.id)); + assertThat(result.map.get("one").id).isEqualTo(val1.id); // assertProxyIsResolved(result.map, true); - assertThat(result.map.get("two").id, is(val2.id)); + assertThat(result.map.get("two").id).isEqualTo(val2.id); verify(converterSpy, times(1)).bulkReadRefs(anyList()); verify(converterSpy, never()).readRef(Mockito.any(DBRef.class)); @@ -657,9 +656,9 @@ public class DbRefMappingMongoConverterUnitTests { MapDBRef result = converterSpy.read(MapDBRef.class, document); assertProxyIsResolved(result.lazyMap, false); - assertThat(result.lazyMap.get("one").id, is(val1.id)); + assertThat(result.lazyMap.get("one").id).isEqualTo(val1.id); assertProxyIsResolved(result.lazyMap, true); - assertThat(result.lazyMap.get("two").id, is(val2.id)); + assertThat(result.lazyMap.get("two").id).isEqualTo(val2.id); verify(converterSpy, times(1)).bulkReadRefs(anyList()); verify(converterSpy, never()).readRef(any()); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DefaultMongoTypeMapperUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DefaultMongoTypeMapperUnitTests.java index f4246fba9..f45858da7 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DefaultMongoTypeMapperUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DefaultMongoTypeMapperUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Arrays; import java.util.Collections; @@ -25,6 +24,7 @@ import java.util.List; import org.bson.Document; import org.junit.Before; import org.junit.Test; + import org.springframework.data.convert.ConfigurableTypeInformationMapper; import org.springframework.data.convert.SimpleTypeInformationMapper; import org.springframework.data.mongodb.core.DocumentTestUtils; @@ -115,8 +115,8 @@ public class DefaultMongoTypeMapperUnitTests { Document typeInfo = DocumentTestUtils.getAsDocument(result, DefaultMongoTypeMapper.DEFAULT_TYPE_KEY); List aliases = DocumentTestUtils.getAsDBList(typeInfo, "$in"); - assertThat(aliases, hasSize(1)); - assertThat(aliases.get(0), is((Object) String.class.getName())); + assertThat(aliases).hasSize(1); + assertThat(aliases.get(0)).isEqualTo((Object) String.class.getName()); } @Test @@ -173,15 +173,15 @@ public class DefaultMongoTypeMapperUnitTests { @Test public void returnsCorrectTypeKey() { - assertThat(typeMapper.isTypeKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(true)); + assertThat(typeMapper.isTypeKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isTrue(); typeMapper = new DefaultMongoTypeMapper("_custom"); - assertThat(typeMapper.isTypeKey("_custom"), is(true)); - assertThat(typeMapper.isTypeKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(false)); + assertThat(typeMapper.isTypeKey("_custom")).isTrue(); + assertThat(typeMapper.isTypeKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isFalse(); typeMapper = new DefaultMongoTypeMapper(null); - assertThat(typeMapper.isTypeKey("_custom"), is(false)); - assertThat(typeMapper.isTypeKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(false)); + assertThat(typeMapper.isTypeKey("_custom")).isFalse(); + assertThat(typeMapper.isTypeKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isFalse(); } private void readsTypeFromField(Document document, Class type) { @@ -189,10 +189,10 @@ public class DefaultMongoTypeMapperUnitTests { TypeInformation typeInfo = typeMapper.readType(document); if (type != null) { - assertThat(typeInfo, is(notNullValue())); - assertThat(typeInfo.getType(), is(typeCompatibleWith(type))); + assertThat(typeInfo).isNotNull(); + assertThat(typeInfo.getType()).isAssignableFrom(type); } else { - assertThat(typeInfo, is(nullValue())); + assertThat(typeInfo).isNull(); } } @@ -201,10 +201,10 @@ public class DefaultMongoTypeMapperUnitTests { typeMapper.writeType(type, document); if (field == null) { - assertThat(document.keySet().isEmpty(), is(true)); + assertThat(document.keySet().isEmpty()).isTrue(); } else { - assertThat(document.containsKey(field), is(true)); - assertThat(document.get(field), is((Object) type.getName())); + assertThat(document.containsKey(field)).isTrue(); + assertThat(document.get(field)).isEqualTo((Object) type.getName()); } } @@ -213,10 +213,10 @@ public class DefaultMongoTypeMapperUnitTests { typeMapper.writeType(type, document); if (value == null) { - assertThat(document.keySet().isEmpty(), is(true)); + assertThat(document.keySet().isEmpty()).isTrue(); } else { - assertThat(document.containsKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(true)); - assertThat(document.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(value)); + assertThat(document.containsKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isTrue(); + assertThat(document.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isEqualTo(value); } } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DocumentAccessorUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DocumentAccessorUnitTests.java index c144e5932..3299093eb 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DocumentAccessorUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/DocumentAccessorUnitTests.java @@ -15,12 +15,12 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.BsonDocument; import org.bson.Document; import org.junit.Test; + import org.springframework.data.mongodb.core.DocumentTestUtils; import org.springframework.data.mongodb.core.mapping.Field; import org.springframework.data.mongodb.core.mapping.MongoMappingContext; @@ -49,7 +49,7 @@ public class DocumentAccessorUnitTests { accessor.put(fooProperty, "FooBar"); Document aDocument = DocumentTestUtils.getAsDocument(document, "a"); - assertThat(aDocument.get("b"), is((Object) "FooBar")); + assertThat(aDocument.get("b")).isEqualTo((Object) "FooBar"); } @Test // DATAMONGO-766 @@ -58,14 +58,14 @@ public class DocumentAccessorUnitTests { Document source = new Document("a", new Document("b", "FooBar")); DocumentAccessor accessor = new DocumentAccessor(source); - assertThat(accessor.get(fooProperty), is((Object) "FooBar")); + assertThat(accessor.get(fooProperty)).isEqualTo((Object) "FooBar"); } @Test // DATAMONGO-766 public void returnsNullForNonExistingFieldPath() { DocumentAccessor accessor = new DocumentAccessor(new Document()); - assertThat(accessor.get(fooProperty), is(nullValue())); + assertThat(accessor.get(fooProperty)).isNull(); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-766 @@ -92,9 +92,9 @@ public class DocumentAccessorUnitTests { Document nestedA = DocumentTestUtils.getAsDocument(target, "a"); - assertThat(nestedA, is(notNullValue())); - assertThat(nestedA.get("b"), is((Object) "b")); - assertThat(nestedA.get("c"), is((Object) "c")); + assertThat(nestedA).isNotNull(); + assertThat(nestedA.get("b")).isEqualTo((Object) "b"); + assertThat(nestedA.get("c")).isEqualTo((Object) "c"); } @Test // DATAMONGO-1471 @@ -103,9 +103,9 @@ public class DocumentAccessorUnitTests { DocumentAccessor accessor = new DocumentAccessor(new Document("a", new BasicDBObject("c", "d"))); MongoPersistentEntity entity = context.getRequiredPersistentEntity(ProjectingType.class); - assertThat(accessor.hasValue(entity.getRequiredPersistentProperty("foo")), is(false)); - assertThat(accessor.hasValue(entity.getRequiredPersistentProperty("a")), is(true)); - assertThat(accessor.hasValue(entity.getRequiredPersistentProperty("name")), is(false)); + assertThat(accessor.hasValue(entity.getRequiredPersistentProperty("foo"))).isFalse(); + assertThat(accessor.hasValue(entity.getRequiredPersistentProperty("a"))).isTrue(); + assertThat(accessor.hasValue(entity.getRequiredPersistentProperty("name"))).isFalse(); } static class ProjectingType { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/GeoConvertersUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/GeoConvertersUnitTests.java index 060308add..cdc34841d 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/GeoConvertersUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/GeoConvertersUnitTests.java @@ -15,31 +15,21 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Arrays; import java.util.List; import org.bson.Document; import org.junit.Test; + import org.springframework.data.geo.Box; import org.springframework.data.geo.Circle; import org.springframework.data.geo.Distance; import org.springframework.data.geo.Metrics; import org.springframework.data.geo.Point; import org.springframework.data.geo.Polygon; -import org.springframework.data.mongodb.core.convert.GeoConverters.BoxToDocumentConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.CircleToDocumentConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.DocumentToBoxConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.DocumentToCircleConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.DocumentToPointConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.DocumentToPolygonConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.DocumentToSphereConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.GeoCommandToDocumentConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.PointToDocumentConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.PolygonToDocumentConverter; -import org.springframework.data.mongodb.core.convert.GeoConverters.SphereToDocumentConverter; +import org.springframework.data.mongodb.core.convert.GeoConverters.*; import org.springframework.data.mongodb.core.geo.Sphere; import org.springframework.data.mongodb.core.query.GeoCommand; @@ -61,8 +51,8 @@ public class GeoConvertersUnitTests { Document document = BoxToDocumentConverter.INSTANCE.convert(box); Box result = DocumentToBoxConverter.INSTANCE.convert(document); - assertThat(result, is(box)); - assertThat(result.getClass().equals(Box.class), is(true)); + assertThat(result).isEqualTo(box); + assertThat(result.getClass().equals(Box.class)).isTrue(); } @Test // DATAMONGO-858 @@ -73,7 +63,7 @@ public class GeoConvertersUnitTests { Document document = CircleToDocumentConverter.INSTANCE.convert(circle); Circle result = DocumentToCircleConverter.INSTANCE.convert(document); - assertThat(result, is(circle)); + assertThat(result).isEqualTo(circle); } @Test // DATAMONGO-858 @@ -85,8 +75,8 @@ public class GeoConvertersUnitTests { Document document = CircleToDocumentConverter.INSTANCE.convert(circle); Circle result = DocumentToCircleConverter.INSTANCE.convert(document); - assertThat(result, is(circle)); - assertThat(result.getRadius(), is(radius)); + assertThat(result).isEqualTo(circle); + assertThat(result.getRadius()).isEqualTo(radius); } @Test // DATAMONGO-858 @@ -97,8 +87,8 @@ public class GeoConvertersUnitTests { Document document = PolygonToDocumentConverter.INSTANCE.convert(polygon); Polygon result = DocumentToPolygonConverter.INSTANCE.convert(document); - assertThat(result, is(polygon)); - assertThat(result.getClass().equals(Polygon.class), is(true)); + assertThat(result).isEqualTo(polygon); + assertThat(result.getClass().equals(Polygon.class)).isTrue(); } @Test // DATAMONGO-858 @@ -109,8 +99,8 @@ public class GeoConvertersUnitTests { Document document = SphereToDocumentConverter.INSTANCE.convert(sphere); Sphere result = DocumentToSphereConverter.INSTANCE.convert(document); - assertThat(result, is(sphere)); - assertThat(result.getClass().equals(Sphere.class), is(true)); + assertThat(result).isEqualTo(sphere); + assertThat(result.getClass().equals(Sphere.class)).isTrue(); } @Test // DATAMONGO-858 @@ -122,9 +112,9 @@ public class GeoConvertersUnitTests { Document document = SphereToDocumentConverter.INSTANCE.convert(sphere); Sphere result = DocumentToSphereConverter.INSTANCE.convert(document); - assertThat(result, is(sphere)); - assertThat(result.getRadius(), is(radius)); - assertThat(result.getClass().equals(org.springframework.data.mongodb.core.geo.Sphere.class), is(true)); + assertThat(result).isEqualTo(sphere); + assertThat(result.getRadius()).isEqualTo(radius); + assertThat(result.getClass().equals(Sphere.class)).isTrue(); } @Test // DATAMONGO-858 @@ -135,8 +125,8 @@ public class GeoConvertersUnitTests { Document document = PointToDocumentConverter.INSTANCE.convert(point); Point result = DocumentToPointConverter.INSTANCE.convert(document); - assertThat(result, is(point)); - assertThat(result.getClass().equals(Point.class), is(true)); + assertThat(result).isEqualTo(point); + assertThat(result.getClass().equals(Point.class)).isTrue(); } @Test // DATAMONGO-858 @@ -147,19 +137,19 @@ public class GeoConvertersUnitTests { Document document = GeoCommandToDocumentConverter.INSTANCE.convert(cmd); - assertThat(document, is(notNullValue())); + assertThat(document).isNotNull(); List boxObject = (List) document.get("$box"); - assertThat(boxObject, - is((Object) Arrays.asList(GeoConverters.toList(box.getFirst()), GeoConverters.toList(box.getSecond())))); + assertThat(boxObject) + .isEqualTo((Object) Arrays.asList(GeoConverters.toList(box.getFirst()), GeoConverters.toList(box.getSecond()))); } @Test // DATAMONGO-1607 public void convertsPointCorrectlyWhenUsingNonDoubleForCoordinates() { - assertThat(DocumentToPointConverter.INSTANCE.convert(new Document().append("x", 1L).append("y", 2L)), - is(new Point(1, 2))); + assertThat(DocumentToPointConverter.INSTANCE.convert(new Document().append("x", 1L).append("y", 2L))) + .isEqualTo(new Point(1, 2)); } @Test // DATAMONGO-1607 @@ -169,7 +159,8 @@ public class GeoConvertersUnitTests { circle.put("center", new Document().append("x", 1).append("y", 2)); circle.put("radius", 3L); - assertThat(DocumentToCircleConverter.INSTANCE.convert(circle), is(new Circle(new Point(1, 2), new Distance(3)))); + assertThat(DocumentToCircleConverter.INSTANCE.convert(circle)) + .isEqualTo(new Circle(new Point(1, 2), new Distance(3))); } @Test // DATAMONGO-1607 @@ -179,7 +170,8 @@ public class GeoConvertersUnitTests { sphere.put("center", new Document().append("x", 1).append("y", 2)); sphere.put("radius", 3L); - assertThat(DocumentToSphereConverter.INSTANCE.convert(sphere), is(new Sphere(new Point(1, 2), new Distance(3)))); + assertThat(DocumentToSphereConverter.INSTANCE.convert(sphere)) + .isEqualTo(new Sphere(new Point(1, 2), new Distance(3))); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/GeoJsonConverterUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/GeoJsonConverterUnitTests.java index f95ce8e8c..f76a7e57b 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/GeoJsonConverterUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/GeoJsonConverterUnitTests.java @@ -15,9 +15,7 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.core.IsEqual.*; -import static org.hamcrest.core.IsNull.*; -import static org.junit.Assert.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import java.util.Arrays; @@ -28,6 +26,7 @@ import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses; + import org.springframework.data.geo.Point; import org.springframework.data.mongodb.core.convert.GeoConverters.DocumentToGeoJsonLineStringConverter; import org.springframework.data.mongodb.core.convert.GeoConverters.DocumentToGeoJsonMultiLineStringConverter; @@ -181,12 +180,12 @@ public class GeoJsonConverterUnitTests { @Test // DATAMONGO-1137 public void shouldConvertDboCorrectly() { - assertThat(converter.convert(POLYGON_DOC), equalTo(POLYGON)); + assertThat(converter.convert(POLYGON_DOC)).isEqualTo(POLYGON); } @Test // DATAMONGO-1137 public void shouldReturnNullWhenConvertIsGivenNull() { - assertThat(converter.convert(null), nullValue()); + assertThat(converter.convert(null)).isNull(); } @Test // DATAMONGO-1137 @@ -200,7 +199,7 @@ public class GeoJsonConverterUnitTests { @Test // DATAMONGO-1399 public void shouldConvertDboWithMultipleRingsCorrectly() { - assertThat(converter.convert(POLYGON_WITH_2_RINGS_DOC), equalTo(POLYGON_WITH_2_RINGS)); + assertThat(converter.convert(POLYGON_WITH_2_RINGS_DOC)).isEqualTo(POLYGON_WITH_2_RINGS); } } @@ -215,12 +214,12 @@ public class GeoJsonConverterUnitTests { @Test // DATAMONGO-1137 public void shouldConvertDboCorrectly() { - assertThat(converter.convert(SINGLE_POINT_DOC), equalTo(SINGLE_POINT)); + assertThat(converter.convert(SINGLE_POINT_DOC)).isEqualTo(SINGLE_POINT); } @Test // DATAMONGO-1137 public void shouldReturnNullWhenConvertIsGivenNull() { - assertThat(converter.convert(null), nullValue()); + assertThat(converter.convert(null)).isNull(); } @Test // DATAMONGO-1137 @@ -243,12 +242,12 @@ public class GeoJsonConverterUnitTests { @Test // DATAMONGO-1137 public void shouldConvertDboCorrectly() { - assertThat(converter.convert(LINE_STRING_DOC), equalTo(LINE_STRING)); + assertThat(converter.convert(LINE_STRING_DOC)).isEqualTo(LINE_STRING); } @Test // DATAMONGO-1137 public void shouldReturnNullWhenConvertIsGivenNull() { - assertThat(converter.convert(null), nullValue()); + assertThat(converter.convert(null)).isNull(); } @Test // DATAMONGO-1137 @@ -271,12 +270,12 @@ public class GeoJsonConverterUnitTests { @Test // DATAMONGO-1137 public void shouldConvertDboCorrectly() { - assertThat(converter.convert(MULTI_LINE_STRING_DOC), equalTo(MULTI_LINE_STRING)); + assertThat(converter.convert(MULTI_LINE_STRING_DOC)).isEqualTo(MULTI_LINE_STRING); } @Test // DATAMONGO-1137 public void shouldReturnNullWhenConvertIsGivenNull() { - assertThat(converter.convert(null), nullValue()); + assertThat(converter.convert(null)).isNull(); } @Test // DATAMONGO-1137 @@ -299,12 +298,12 @@ public class GeoJsonConverterUnitTests { @Test // DATAMONGO-1137 public void shouldConvertDboCorrectly() { - assertThat(converter.convert(MULTI_POINT_DOC), equalTo(MULTI_POINT)); + assertThat(converter.convert(MULTI_POINT_DOC)).isEqualTo(MULTI_POINT); } @Test // DATAMONGO-1137 public void shouldReturnNullWhenConvertIsGivenNull() { - assertThat(converter.convert(null), nullValue()); + assertThat(converter.convert(null)).isNull(); } @Test // DATAMONGO-1137 @@ -327,12 +326,12 @@ public class GeoJsonConverterUnitTests { @Test // DATAMONGO-1137 public void shouldConvertDboCorrectly() { - assertThat(converter.convert(MULTI_POLYGON_DOC), equalTo(MULTI_POLYGON)); + assertThat(converter.convert(MULTI_POLYGON_DOC)).isEqualTo(MULTI_POLYGON); } @Test // DATAMONGO-1137 public void shouldReturnNullWhenConvertIsGivenNull() { - assertThat(converter.convert(null), nullValue()); + assertThat(converter.convert(null)).isNull(); } @Test // DATAMONGO-1137 @@ -354,47 +353,47 @@ public class GeoJsonConverterUnitTests { // DATAMONGO-1135 public void convertShouldReturnNullWhenGivenNull() { - assertThat(converter.convert(null), nullValue()); + assertThat(converter.convert(null)).isNull(); } @Test // DATAMONGO-1135 public void shouldConvertGeoJsonPointCorrectly() { - assertThat(converter.convert(SINGLE_POINT), equalTo(SINGLE_POINT_DOC)); + assertThat(converter.convert(SINGLE_POINT)).isEqualTo(SINGLE_POINT_DOC); } @Test // DATAMONGO-1135 public void shouldConvertGeoJsonPolygonCorrectly() { - assertThat(converter.convert(POLYGON), equalTo(POLYGON_DOC)); + assertThat(converter.convert(POLYGON)).isEqualTo(POLYGON_DOC); } @Test // DATAMONGO-1137 public void shouldConvertGeoJsonLineStringCorrectly() { - assertThat(converter.convert(LINE_STRING), equalTo(LINE_STRING_DOC)); + assertThat(converter.convert(LINE_STRING)).isEqualTo(LINE_STRING_DOC); } @Test // DATAMONGO-1137 public void shouldConvertGeoJsonMultiLineStringCorrectly() { - assertThat(converter.convert(MULTI_LINE_STRING), equalTo(MULTI_LINE_STRING_DOC)); + assertThat(converter.convert(MULTI_LINE_STRING)).isEqualTo(MULTI_LINE_STRING_DOC); } @Test // DATAMONGO-1137 public void shouldConvertGeoJsonMultiPointCorrectly() { - assertThat(converter.convert(MULTI_POINT), equalTo(MULTI_POINT_DOC)); + assertThat(converter.convert(MULTI_POINT)).isEqualTo(MULTI_POINT_DOC); } @Test // DATAMONGO-1137 public void shouldConvertGeoJsonMultiPolygonCorrectly() { - assertThat(converter.convert(MULTI_POLYGON), equalTo(MULTI_POLYGON_DOC)); + assertThat(converter.convert(MULTI_POLYGON)).isEqualTo(MULTI_POLYGON_DOC); } @Test // DATAMONGO-1137 public void shouldConvertGeometryCollectionCorrectly() { - assertThat(converter.convert(GEOMETRY_COLLECTION), equalTo(GEOMETRY_COLLECTION_DOC)); + assertThat(converter.convert(GEOMETRY_COLLECTION)).isEqualTo(GEOMETRY_COLLECTION_DOC); } @Test // DATAMONGO-1399 public void shouldConvertGeoJsonPolygonWithMultipleRingsCorrectly() { - assertThat(converter.convert(POLYGON_WITH_2_RINGS), equalTo(POLYGON_WITH_2_RINGS_DOC)); + assertThat(converter.convert(POLYGON_WITH_2_RINGS)).isEqualTo(POLYGON_WITH_2_RINGS_DOC); } } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/LazyLoadingTestUtils.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/LazyLoadingTestUtils.java index da186d359..9b123514b 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/LazyLoadingTestUtils.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/LazyLoadingTestUtils.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.springframework.aop.framework.Advised; import org.springframework.cglib.proxy.Factory; @@ -40,8 +39,14 @@ public class LazyLoadingTestUtils { public static void assertProxyIsResolved(Object target, boolean expected) { LazyLoadingInterceptor interceptor = extractInterceptor(target); - assertThat(ReflectionTestUtils.getField(interceptor, "resolved"), is((Object) expected)); - assertThat(ReflectionTestUtils.getField(interceptor, "result"), is(expected ? notNullValue() : nullValue())); + assertThat(ReflectionTestUtils.getField(interceptor, "resolved")).isEqualTo((Object) expected); + + if (expected) { + assertThat(ReflectionTestUtils.getField(interceptor, "result")).isNotNull(); + } else { + assertThat(ReflectionTestUtils.getField(interceptor, "result")).isNull(); + + } } private static LazyLoadingInterceptor extractInterceptor(Object proxy) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MappingMongoConverterUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MappingMongoConverterUnitTests.java index 29c9bbce1..ff7fdda4c 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MappingMongoConverterUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MappingMongoConverterUnitTests.java @@ -17,12 +17,6 @@ package org.springframework.data.mongodb.core.convert; import static java.time.ZoneId.*; import static org.assertj.core.api.Assertions.*; -import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.Matchers.*; -import static org.hamcrest.Matchers.not; -import static org.junit.Assert.*; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.fail; import static org.mockito.Mockito.*; import static org.springframework.data.mongodb.core.DocumentTestUtils.*; @@ -38,8 +32,6 @@ import java.util.*; import org.bson.types.Code; import org.bson.types.Decimal128; import org.bson.types.ObjectId; -import org.hamcrest.Matcher; -import org.hamcrest.Matchers; import org.joda.time.LocalDate; import org.junit.Before; import org.junit.Ignore; @@ -50,6 +42,7 @@ import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.aop.framework.ProxyFactory; import org.springframework.beans.ConversionNotSupportedException; import org.springframework.beans.factory.annotation.Value; @@ -135,8 +128,8 @@ public class MappingMongoConverterUnitTests { converter.write(address, document); - assertThat(document.get("city").toString(), is("New York")); - assertThat(document.get("street").toString(), is("Broadway")); + assertThat(document.get("city").toString()).isEqualTo("New York"); + assertThat(document.get("street").toString()).isEqualTo("Broadway"); } @Test @@ -151,10 +144,10 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(person, document); - assertThat(document.get("birthDate"), is(instanceOf(Date.class))); + assertThat(document.get("birthDate")).isInstanceOf(Date.class); Person result = converter.read(Person.class, document); - assertThat(result.birthDate, is(notNullValue())); + assertThat(result.birthDate).isNotNull(); } @Test @@ -175,7 +168,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(map, document); - assertThat(document.get(Locale.US.toString()).toString(), is("Foo")); + assertThat(document.get(Locale.US.toString()).toString()).isEqualTo("Foo"); } @Test // DATAMONGO-130 @@ -185,7 +178,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document("map", mapObject); ClassWithMapProperty result = converter.read(ClassWithMapProperty.class, document); - assertThat(result.map.get(Locale.US), is("Value")); + assertThat(result.map.get(Locale.US)).isEqualTo("Value"); } @Test // DATAMONGO-128 @@ -195,7 +188,7 @@ public class MappingMongoConverterUnitTests { document.put("birthDate", new LocalDate()); document.put(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY, Person.class.getName()); - assertThat(converter.read(Contact.class, document), is(instanceOf(Person.class))); + assertThat(converter.read(Contact.class, document)).isInstanceOf(Person.class); } @Test // DATAMONGO-128 @@ -205,7 +198,7 @@ public class MappingMongoConverterUnitTests { document.put("birthDate", new LocalDate()); document.put(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY, Person.class.getName()); - assertThat(converter.read(BirthDateContainer.class, document), is(instanceOf(BirthDateContainer.class))); + assertThat(converter.read(BirthDateContainer.class, document)).isInstanceOf(BirthDateContainer.class); } @Test @@ -216,8 +209,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = new org.bson.Document(); converter.write(person, result); - assertThat(result.containsKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(true)); - assertThat(result.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY).toString(), is(Person.class.getName())); + assertThat(result.containsKey(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isTrue(); + assertThat(result.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY).toString()).isEqualTo(Person.class.getName()); } @Test // DATAMONGO-136 @@ -229,8 +222,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = new org.bson.Document(); converter.write(value, result); - assertThat(result.get("sampleEnum"), is(instanceOf(String.class))); - assertThat(result.get("sampleEnum").toString(), is("FIRST")); + assertThat(result.get("sampleEnum")).isInstanceOf(String.class); + assertThat(result.get("sampleEnum").toString()).isEqualTo("FIRST"); } @Test // DATAMONGO-209 @@ -242,11 +235,11 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = new org.bson.Document(); converter.write(value, result); - assertThat(result.get("enums"), is(instanceOf(List.class))); + assertThat(result.get("enums")).isInstanceOf(List.class); List enums = (List) result.get("enums"); - assertThat(enums.size(), is(1)); - assertThat(enums.get(0), is("FIRST")); + assertThat(enums.size()).isEqualTo(1); + assertThat(enums.get(0)).isEqualTo("FIRST"); } @Test // DATAMONGO-136 @@ -254,7 +247,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document("sampleEnum", "FIRST"); ClassWithEnumProperty result = converter.read(ClassWithEnumProperty.class, document); - assertThat(result.sampleEnum, is(SampleEnum.FIRST)); + assertThat(result.sampleEnum).isEqualTo(SampleEnum.FIRST); } @Test // DATAMONGO-209 @@ -266,9 +259,9 @@ public class MappingMongoConverterUnitTests { ClassWithEnumProperty result = converter.read(ClassWithEnumProperty.class, document); - assertThat(result.enums, is(instanceOf(List.class))); - assertThat(result.enums.size(), is(1)); - assertThat(result.enums, hasItem(SampleEnum.FIRST)); + assertThat(result.enums).isInstanceOf(List.class); + assertThat(result.enums.size()).isEqualTo(1); + assertThat(result.enums).contains(SampleEnum.FIRST); } @Test // DATAMONGO-144 @@ -280,8 +273,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = new org.bson.Document(); converter.write(person, result); - assertThat(result.containsKey("foo"), is(true)); - assertThat(result.containsKey("firstname"), is(false)); + assertThat(result.containsKey("foo")).isTrue(); + assertThat(result.containsKey("firstname")).isFalse(); } @Test // DATAMONGO-144 @@ -290,7 +283,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document("foo", "Oliver"); Person result = converter.read(Person.class, document); - assertThat(result.firstname, is("Oliver")); + assertThat(result.firstname).isEqualTo("Oliver"); } @Test @@ -306,7 +299,7 @@ public class MappingMongoConverterUnitTests { person.put("addresses", addresses); Person result = converter.read(Person.class, person); - assertThat(result.addresses, is(notNullValue())); + assertThat(result.addresses).isNotNull(); } @Test // DATAMONGO-145 @@ -322,11 +315,11 @@ public class MappingMongoConverterUnitTests { converter.write(wrapper, document); Object result = document.get("contacts"); - assertThat(result, is(instanceOf(List.class))); + assertThat(result).isInstanceOf(List.class); List contacts = (List) result; org.bson.Document personDocument = (org.bson.Document) contacts.get(0); - assertThat(personDocument.get("foo").toString(), is("Oliver")); - assertThat((String) personDocument.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(Person.class.getName())); + assertThat(personDocument.get("foo").toString()).isEqualTo("Oliver"); + assertThat((String) personDocument.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isEqualTo(Person.class.getName()); } @Test // DATAMONGO-145 @@ -339,11 +332,11 @@ public class MappingMongoConverterUnitTests { contacts.add(person); CollectionWrapper result = converter.read(CollectionWrapper.class, new org.bson.Document("contacts", contacts)); - assertThat(result.contacts, is(notNullValue())); - assertThat(result.contacts.size(), is(1)); + assertThat(result.contacts).isNotNull(); + assertThat(result.contacts.size()).isEqualTo(1); Contact contact = result.contacts.get(0); - assertThat(contact, is(instanceOf(Person.class))); - assertThat(((Person) contact).firstname, is("Oliver")); + assertThat(contact).isInstanceOf(Person.class); + assertThat(((Person) contact).firstname).isEqualTo("Oliver"); } @Test @@ -355,11 +348,11 @@ public class MappingMongoConverterUnitTests { converter.write(wrapper, document); Object localeField = document.get("locale"); - assertThat(localeField, is(instanceOf(String.class))); - assertThat(localeField, is("en_US")); + assertThat(localeField).isInstanceOf(String.class); + assertThat(localeField).isEqualTo("en_US"); LocaleWrapper read = converter.read(LocaleWrapper.class, document); - assertThat(read.locale, is(Locale.US)); + assertThat(read.locale).isEqualTo(Locale.US); } @Test // DATAMONGO-161 @@ -382,8 +375,8 @@ public class MappingMongoConverterUnitTests { ClassWithNestedMaps result = converter.read(ClassWithNestedMaps.class, document); Map>> nestedMap = result.nestedMaps; - assertThat(nestedMap, is(notNullValue())); - assertThat(nestedMap.get("afield"), is(firstLevel)); + assertThat(nestedMap).isNotNull(); + assertThat(nestedMap.get("afield")).isEqualTo(firstLevel); } @Test // DATACMNS-42, DATAMONGO-171 @@ -396,9 +389,9 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(container, document); - assertThat(document.get("value"), is(instanceOf(String.class))); - assertThat((String) document.get("value"), is("2.5")); - assertThat(((org.bson.Document) document.get("map")).get("foo"), is(instanceOf(String.class))); + assertThat(document.get("value")).isInstanceOf(String.class); + assertThat((String) document.get("value")).isEqualTo("2.5"); + assertThat(((org.bson.Document) document.get("map")).get("foo")).isInstanceOf(String.class); } @Test // DATACMNS-42, DATAMONGO-171 @@ -412,9 +405,9 @@ public class MappingMongoConverterUnitTests { document.put("collection", list); BigDecimalContainer result = converter.read(BigDecimalContainer.class, document); - assertThat(result.value, is(BigDecimal.valueOf(2.5d))); - assertThat(result.map.get("foo"), is(BigDecimal.valueOf(2.5d))); - assertThat(result.collection.get(0), is(BigDecimal.valueOf(2.5d))); + assertThat(result.value).isEqualTo(BigDecimal.valueOf(2.5d)); + assertThat(result.map.get("foo")).isEqualTo(BigDecimal.valueOf(2.5d)); + assertThat(result.collection.get(0)).isEqualTo(BigDecimal.valueOf(2.5d)); } @Test @@ -427,10 +420,10 @@ public class MappingMongoConverterUnitTests { converter.write(wrapper, document); Object outerStrings = document.get("strings"); - assertThat(outerStrings, is(instanceOf(List.class))); + assertThat(outerStrings).isInstanceOf(List.class); List typedOuterString = (List) outerStrings; - assertThat(typedOuterString.size(), is(1)); + assertThat(typedOuterString.size()).isEqualTo(1); } @Test // DATAMONGO-192 @@ -450,13 +443,13 @@ public class MappingMongoConverterUnitTests { org.bson.Document doc1 = new org.bson.Document(); converter.write(p1, doc1); - assertThat(doc1.get("_id"), is(instanceOf(String.class))); + assertThat(doc1.get("_id")).isInstanceOf(String.class); PersonPojoStringId p2 = new PersonPojoStringId(new ObjectId().toString(), "Text-1"); org.bson.Document doc2 = new org.bson.Document(); converter.write(p2, doc2); - assertThat(doc2.get("_id"), is(instanceOf(ObjectId.class))); + assertThat(doc2.get("_id")).isInstanceOf(ObjectId.class); } @Test // DATAMONGO-207 @@ -467,13 +460,13 @@ public class MappingMongoConverterUnitTests { ClassWithSortedMap result = converter.read(ClassWithSortedMap.class, wrapper); - assertThat(result, is(instanceOf(ClassWithSortedMap.class))); - assertThat(result.map, is(instanceOf(SortedMap.class))); + assertThat(result).isInstanceOf(ClassWithSortedMap.class); + assertThat(result.map).isInstanceOf(SortedMap.class); } @Test // DATAMONGO-211 public void maybeConvertHandlesNullValuesCorrectly() { - assertThat(converter.convertToMongoType(null), is(nullValue())); + assertThat(converter.convertToMongoType(null)).isNull(); } @Test // DATAMONGO-1509 @@ -488,7 +481,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document content = (org.bson.Document) result.get("content"); assertTypeHint(content, Address.class); - assertThat(content.get("city"), is(notNullValue())); + assertThat(content.get("city")).isNotNull(); } @Test @@ -498,7 +491,7 @@ public class MappingMongoConverterUnitTests { address.put("city", "London"); GenericType result = converter.read(GenericType.class, new org.bson.Document("content", address)); - assertThat(result.content, is(instanceOf(Address.class))); + assertThat(result.content).isInstanceOf(Address.class); } @Test // DATAMONGO-228 @@ -511,8 +504,8 @@ public class MappingMongoConverterUnitTests { converter.write(foo, result); Object map = result.get("map"); - assertThat(map, is(instanceOf(org.bson.Document.class))); - assertThat(((org.bson.Document) map).keySet(), hasItem("en_US")); + assertThat(map).isInstanceOf(org.bson.Document.class); + assertThat(((org.bson.Document) map).keySet()).contains("en_US"); } @Test @@ -524,13 +517,13 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = new org.bson.Document(); converter.write(foo, result); - assertThat(result.get("_id"), is(instanceOf(String.class))); + assertThat(result.get("_id")).isInstanceOf(String.class); } public void convertsObjectsIfNecessary() { ObjectId id = new ObjectId(); - assertThat(converter.convertToMongoType(id), is(id)); + assertThat(converter.convertToMongoType(id)).isEqualTo(id); } @Test // DATAMONGO-235 @@ -543,15 +536,15 @@ public class MappingMongoConverterUnitTests { converter.write(input, result); Object field = result.get("mapOfLists"); - assertThat(field, is(instanceOf(org.bson.Document.class))); + assertThat(field).isInstanceOf(org.bson.Document.class); org.bson.Document map = (org.bson.Document) field; Object foo = map.get("Foo"); - assertThat(foo, is(instanceOf(List.class))); + assertThat(foo).isInstanceOf(List.class); List value = (List) foo; - assertThat(value.size(), is(1)); - assertThat(value.get(0), is("Bar")); + assertThat(value.size()).isEqualTo(1); + assertThat(value.get(0)).isEqualTo("Bar"); } @Test // DATAMONGO-235 @@ -562,7 +555,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document source = new org.bson.Document("mapOfLists", new org.bson.Document("Foo", list)); ClassWithMapProperty result = converter.read(ClassWithMapProperty.class, source); - assertThat(result.mapOfLists, is(not(nullValue()))); + assertThat(result.mapOfLists).isNotNull(); } @Test // DATAMONGO-235 @@ -576,15 +569,15 @@ public class MappingMongoConverterUnitTests { converter.write(input, result); Object field = result.get("mapOfObjects"); - assertThat(field, is(instanceOf(org.bson.Document.class))); + assertThat(field).isInstanceOf(org.bson.Document.class); org.bson.Document map = (org.bson.Document) field; Object foo = map.get("Foo"); - assertThat(foo, is(instanceOf(BasicDBList.class))); + assertThat(foo).isInstanceOf(BasicDBList.class); BasicDBList value = (BasicDBList) foo; - assertThat(value.size(), is(1)); - assertThat(value.get(0), is("Bar")); + assertThat(value.size()).isEqualTo(1); + assertThat(value.get(0)).isEqualTo("Bar"); } @Test // DATAMONGO-235 @@ -595,7 +588,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document source = new org.bson.Document("mapOfObjects", new org.bson.Document("Foo", list)); ClassWithMapProperty result = converter.read(ClassWithMapProperty.class, source); - assertThat(result.mapOfObjects, is(not(nullValue()))); + assertThat(result.mapOfObjects).isNotNull(); } @Test // DATAMONGO-245 @@ -607,8 +600,8 @@ public class MappingMongoConverterUnitTests { ClassWithMapProperty result = converter.read(ClassWithMapProperty.class, source); Object firstObjectInFoo = ((List) result.mapOfObjects.get("Foo")).get(0); - assertThat(firstObjectInFoo, is(instanceOf(Map.class))); - assertThat(((Map) firstObjectInFoo).get("Hello"), is(equalTo("World"))); + assertThat(firstObjectInFoo).isInstanceOf(Map.class); + assertThat(((Map) firstObjectInFoo).get("Hello")).isEqualTo("World"); } @Test // DATAMONGO-245 @@ -622,10 +615,10 @@ public class MappingMongoConverterUnitTests { ClassWithMapProperty result = converter.read(ClassWithMapProperty.class, source); Object foo = result.mapOfObjects.get("Foo"); - assertThat(foo, is(instanceOf(Map.class))); + assertThat(foo).isInstanceOf(Map.class); Object doublyNestedObject = ((Map) foo).get("nested"); - assertThat(doublyNestedObject, is(instanceOf(Map.class))); - assertThat(((Map) doublyNestedObject).get("Hello"), is(equalTo("World"))); + assertThat(doublyNestedObject).isInstanceOf(Map.class); + assertThat(((Map) doublyNestedObject).get("Hello")).isEqualTo("World"); } @Test // DATAMONGO-245 @@ -641,10 +634,10 @@ public class MappingMongoConverterUnitTests { ClassWithMapProperty result = converter.read(ClassWithMapProperty.class, source); Object firstObjectInFoo = ((List) result.mapOfObjects.get("Foo")).get(0); - assertThat(firstObjectInFoo, is(instanceOf(Map.class))); + assertThat(firstObjectInFoo).isInstanceOf(Map.class); Object doublyNestedObject = ((Map) firstObjectInFoo).get("nested"); - assertThat(doublyNestedObject, is(instanceOf(Map.class))); - assertThat(((Map) doublyNestedObject).get("Hello"), is(equalTo("World"))); + assertThat(doublyNestedObject).isInstanceOf(Map.class); + assertThat(((Map) doublyNestedObject).get("Hello")).isEqualTo("World"); } @Test // DATAMONGO-259 @@ -660,12 +653,12 @@ public class MappingMongoConverterUnitTests { converter.write(wrapper, result); List list = (List) result.get("listOfMaps"); - assertThat(list, is(notNullValue())); - assertThat(list.size(), is(1)); + assertThat(list).isNotNull(); + assertThat(list.size()).isEqualTo(1); org.bson.Document document = (org.bson.Document) list.get(0); - assertThat(document.containsKey("Foo"), is(true)); - assertThat((String) document.get("Foo"), is(Locale.ENGLISH.toString())); + assertThat(document.containsKey("Foo")).isTrue(); + assertThat((String) document.get("Foo")).isEqualTo(Locale.ENGLISH.toString()); } @Test // DATAMONGO-259 @@ -680,10 +673,10 @@ public class MappingMongoConverterUnitTests { CollectionWrapper wrapper = converter.read(CollectionWrapper.class, wrapperSource); - assertThat(wrapper.listOfMaps, is(notNullValue())); - assertThat(wrapper.listOfMaps.size(), is(1)); - assertThat(wrapper.listOfMaps.get(0), is(notNullValue())); - assertThat(wrapper.listOfMaps.get(0).get("Foo"), is(Locale.ENGLISH)); + assertThat(wrapper.listOfMaps).isNotNull(); + assertThat(wrapper.listOfMaps.size()).isEqualTo(1); + assertThat(wrapper.listOfMaps.get(0)).isNotNull(); + assertThat(wrapper.listOfMaps.get(0).get("Foo")).isEqualTo(Locale.ENGLISH); } @Test // DATAMONGO-259 @@ -693,14 +686,14 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = new org.bson.Document(); converter.write(map, result); - assertThat(result.containsKey("Foo"), is(true)); - assertThat(result.get("Foo"), is(notNullValue())); - assertThat(result.get("Foo"), is(instanceOf(BasicDBList.class))); + assertThat(result.containsKey("Foo")).isTrue(); + assertThat(result.get("Foo")).isNotNull(); + assertThat(result.get("Foo")).isInstanceOf(BasicDBList.class); BasicDBList list = (BasicDBList) result.get("Foo"); - assertThat(list.size(), is(1)); - assertThat(list.get(0), is(Locale.US.toString())); + assertThat(list.size()).isEqualTo(1); + assertThat(list.get(0)).isEqualTo(Locale.US.toString()); } @Test // DATAMONGO-285 @@ -719,13 +712,13 @@ public class MappingMongoConverterUnitTests { Map keyValuesFromMongo = converter.read(Map.class, document); - assertEquals(keyValues.size(), keyValuesFromMongo.size()); - assertEquals(keyValues.get("string"), keyValuesFromMongo.get("string")); - assertTrue(List.class.isAssignableFrom(keyValuesFromMongo.get("list").getClass())); + assertThat(keyValuesFromMongo.size()).isEqualTo(keyValues.size()); + assertThat(keyValuesFromMongo.get("string")).isEqualTo(keyValues.get("string")); + assertThat(List.class.isAssignableFrom(keyValuesFromMongo.get("list").getClass())).isTrue(); List listFromMongo = (List) keyValuesFromMongo.get("list"); - assertEquals(list.size(), listFromMongo.size()); - assertEquals(list.get(0), listFromMongo.get(0)); - assertEquals(list.get(1), listFromMongo.get(1)); + assertThat(listFromMongo.size()).isEqualTo(list.size()); + assertThat(listFromMongo.get(0)).isEqualTo(list.get(0)); + assertThat(listFromMongo.get(1)).isEqualTo(list.get(1)); } @Test // DATAMONGO-309 @@ -740,15 +733,15 @@ public class MappingMongoConverterUnitTests { converter.write(wrapper, result); Object mapObject = result.get("mapOfObjects"); - assertThat(mapObject, is(instanceOf(org.bson.Document.class))); + assertThat(mapObject).isInstanceOf(org.bson.Document.class); org.bson.Document map = (org.bson.Document) mapObject; Object valueObject = map.get("foo"); - assertThat(valueObject, is(instanceOf(BasicDBList.class))); + assertThat(valueObject).isInstanceOf(BasicDBList.class); List list = (List) valueObject; - assertThat(list.size(), is(1)); - assertThat(list, hasItem((Object) "bar")); + assertThat(list.size()).isEqualTo(1); + assertThat(list).contains((Object) "bar"); } @Test // DATAMONGO-324 @@ -762,7 +755,7 @@ public class MappingMongoConverterUnitTests { converter.write(document, result); result.remove(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY); - assertThat(document, is(result)); + assertThat(document).isEqualTo(result); } @Test // DATAMONGO-324 @@ -773,7 +766,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = converter.read(org.bson.Document.class, document); - assertThat(result, is(document)); + assertThat(result).isEqualTo(document); } @Test // DATAMONGO-329 @@ -787,17 +780,17 @@ public class MappingMongoConverterUnitTests { converter.write(a, result); - assertThat(result.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(A.class.getName())); - assertThat(result.get("valueType"), is(HashMap.class.getName())); + assertThat(result.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isEqualTo(A.class.getName()); + assertThat(result.get("valueType")).isEqualTo(HashMap.class.getName()); org.bson.Document object = (org.bson.Document) result.get("value"); - assertThat(object, is(notNullValue())); + assertThat(object).isNotNull(); org.bson.Document inner = (org.bson.Document) object.get("test"); - assertThat(inner, is(notNullValue())); - assertThat(inner.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY), is(A.class.getName())); - assertThat(inner.get("valueType"), is(String.class.getName())); - assertThat(inner.get("value"), is("testValue")); + assertThat(inner).isNotNull(); + assertThat(inner.get(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY)).isEqualTo(A.class.getName()); + assertThat(inner.get("valueType")).isEqualTo(String.class.getName()); + assertThat(inner.get("value")).isEqualTo("testValue"); } @Test @@ -809,7 +802,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = new org.bson.Document(); converter.write(value, result); - assertThat(result.get("_id"), is(5)); + assertThat(result.get("_id")).isEqualTo(5); } @Test // DATAMONGO-368 @@ -823,9 +816,9 @@ public class MappingMongoConverterUnitTests { converter.write(wrapper, result); Object contacts = result.get("contacts"); - assertThat(contacts, is(instanceOf(Collection.class))); - assertThat(((Collection) contacts).size(), is(2)); - assertThat((Collection) contacts, hasItem(nullValue())); + assertThat(contacts).isInstanceOf(Collection.class); + assertThat(((Collection) contacts).size()).isEqualTo(2); + assertThat((Collection) contacts).containsNull(); } @Test // DATAMONGO-379 @@ -835,7 +828,7 @@ public class MappingMongoConverterUnitTests { document.put("foobar", 2.5); DefaultedConstructorArgument result = converter.read(DefaultedConstructorArgument.class, document); - assertThat(result.bar, is(-1)); + assertThat(result.bar).isEqualTo(-1); } @Test // DATAMONGO-379 @@ -846,7 +839,7 @@ public class MappingMongoConverterUnitTests { document.put("foobar", 2.5); DefaultedConstructorArgument result = converter.read(DefaultedConstructorArgument.class, document); - assertThat(result.bar, is(37)); + assertThat(result.bar).isEqualTo(37); } @Test(expected = MappingInstantiationException.class) // DATAMONGO-379 @@ -872,15 +865,15 @@ public class MappingMongoConverterUnitTests { converter.write(item, result); Item read = converter.read(Item.class, result); - assertThat(read.attributes.size(), is(1)); - assertThat(read.attributes.get(0).key, is(attribute.key)); - assertThat(read.attributes.get(0).value, is(instanceOf(Collection.class))); + assertThat(read.attributes.size()).isEqualTo(1); + assertThat(read.attributes.get(0).key).isEqualTo(attribute.key); + assertThat(read.attributes.get(0).value).isInstanceOf(Collection.class); @SuppressWarnings("unchecked") Collection values = (Collection) read.attributes.get(0).value; - assertThat(values.size(), is(2)); - assertThat(values, hasItems("1", "2")); + assertThat(values.size()).isEqualTo(2); + assertThat(values).contains("1", "2"); } @Test(expected = MappingException.class) // DATAMONGO-380 @@ -896,8 +889,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(Collections.singletonMap("foo.bar", "foobar"), document); - assertThat((String) document.get("foo~bar"), is("foobar")); - assertThat(document.containsKey("foo.bar"), is(false)); + assertThat((String) document.get("foo~bar")).isEqualTo("foobar"); + assertThat(document.containsKey("foo.bar")).isFalse(); } @Test // DATAMONGO-380 @@ -909,8 +902,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document("foo~bar", "foobar"); Map result = converter.read(Map.class, document); - assertThat(result.get("foo.bar"), is("foobar")); - assertThat(result.containsKey("foobar"), is(false)); + assertThat(result.get("foo.bar")).isEqualTo("foobar"); + assertThat(result.containsKey("foobar")).isFalse(); } @Test // DATAMONGO-382 @@ -922,11 +915,11 @@ public class MappingMongoConverterUnitTests { address.street = "Foo"; Object result = converter.convertToMongoType(Collections.singleton(address), ClassTypeInformation.OBJECT); - assertThat(result, is(instanceOf(List.class))); + assertThat(result).isInstanceOf(List.class); Set readResult = converter.read(Set.class, (org.bson.Document) result); - assertThat(readResult.size(), is(1)); - assertThat(readResult.iterator().next(), is(instanceOf(Address.class))); + assertThat(readResult.size()).isEqualTo(1); + assertThat(readResult.iterator().next()).isInstanceOf(Address.class); } @Test // DATAMONGO-402 @@ -935,8 +928,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document("inner", new org.bson.Document("value", "FOO!")); Outer outer = converter.read(Outer.class, document); - assertThat(outer.inner, is(notNullValue())); - assertThat(outer.inner.value, is("FOO!")); + assertThat(outer.inner).isNotNull(); + assertThat(outer.inner.value).isEqualTo("FOO!"); assertSyntheticFieldValueOf(outer.inner, outer); } @@ -946,7 +939,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document("contactsSet", new BasicDBList()); CollectionWrapper wrapper = converter.read(CollectionWrapper.class, document); - assertThat(wrapper.contactsSet, is(notNullValue())); + assertThat(wrapper.contactsSet).isNotNull(); wrapper.contactsSet.add(new Contact() {}); } @@ -957,7 +950,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document("ref", dbRef); DBRefWrapper result = converter.read(DBRefWrapper.class, document); - assertThat(result.ref, is(dbRef)); + assertThat(result.ref).isEqualTo(dbRef); } @Test // DATAMONGO-424 @@ -970,8 +963,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document("refs", refs); DBRefWrapper result = converter.read(DBRefWrapper.class, document); - assertThat(result.refs, hasSize(1)); - assertThat(result.refs, hasItem(dbRef)); + assertThat(result.refs).hasSize(1); + assertThat(result.refs).contains(dbRef); } @Test // DATAMONGO-424 @@ -983,8 +976,8 @@ public class MappingMongoConverterUnitTests { DBRefWrapper result = converter.read(DBRefWrapper.class, document); - assertThat(result.refMap.entrySet(), hasSize(1)); - assertThat(result.refMap.values(), hasItem(dbRef)); + assertThat(result.refMap.entrySet()).hasSize(1); + assertThat(result.refMap.values()).contains(dbRef); } @Test // DATAMONGO-424 @@ -999,10 +992,9 @@ public class MappingMongoConverterUnitTests { DBRefWrapper result = converter.read(DBRefWrapper.class, document); - Matcher isPerson = instanceOf(Person.class); - assertThat(result.personMap.entrySet(), hasSize(1)); - assertThat(result.personMap.values(), hasItem(isPerson)); + assertThat(result.personMap.entrySet()).hasSize(1); + assertThat(result.personMap.values()).anyMatch(Person.class::isInstance); } @Test // DATAMONGO-462 @@ -1014,14 +1006,14 @@ public class MappingMongoConverterUnitTests { converter.write(wrapper, sink); - assertThat(sink.get("url"), is("https://springsource.org")); + assertThat(sink.get("url")).isEqualTo("https://springsource.org"); } @Test // DATAMONGO-462 public void readsURLFromStringOutOfTheBox() throws Exception { org.bson.Document document = new org.bson.Document("url", "https://springsource.org"); URLWrapper result = converter.read(URLWrapper.class, document); - assertThat(result.url, is(new URL("https://springsource.org"))); + assertThat(result.url).isEqualTo(new URL("https://springsource.org")); } @Test // DATAMONGO-485 @@ -1037,9 +1029,9 @@ public class MappingMongoConverterUnitTests { converter.write(entity, document); Object idField = document.get("_id"); - assertThat(idField, is(notNullValue())); - assertThat(idField, is(instanceOf(org.bson.Document.class))); - assertThat(((org.bson.Document) idField).get("innerId"), is(4711L)); + assertThat(idField).isNotNull(); + assertThat(idField).isInstanceOf(org.bson.Document.class); + assertThat(((org.bson.Document) idField).get("innerId")).isEqualTo(4711L); } @Test // DATAMONGO-485 @@ -1050,8 +1042,8 @@ public class MappingMongoConverterUnitTests { ClassWithComplexId result = converter.read(ClassWithComplexId.class, entity); - assertThat(result.complexId, is(notNullValue())); - assertThat(result.complexId.innerId, is(4711L)); + assertThat(result.complexId).isNotNull(); + assertThat(result.complexId.innerId).isEqualTo(4711L); } @Test // DATAMONGO-489 @@ -1065,11 +1057,11 @@ public class MappingMongoConverterUnitTests { org.bson.Document wrapper = new org.bson.Document("mapOfStrings", map); ClassWithMapProperty result = converter.read(ClassWithMapProperty.class, wrapper); - assertThat(result.mapOfStrings, is(notNullValue())); + assertThat(result.mapOfStrings).isNotNull(); String[] values = result.mapOfStrings.get("key"); - assertThat(values, is(notNullValue())); - assertThat(values, is(arrayWithSize(2))); + assertThat(values).isNotNull(); + assertThat(values).hasSize(2); } @Test // DATAMONGO-497 @@ -1078,14 +1070,14 @@ public class MappingMongoConverterUnitTests { org.bson.Document source = new org.bson.Document("attributes", new BasicDBList()); TypWithCollectionConstructor result = converter.read(TypWithCollectionConstructor.class, source); - assertThat(result.attributes, is(notNullValue())); + assertThat(result.attributes).isNotNull(); } private static void assertSyntheticFieldValueOf(Object target, Object expected) { for (int i = 0; i < 10; i++) { try { - assertThat(ReflectionTestUtils.getField(target, "this$" + i), is(expected)); + assertThat(ReflectionTestUtils.getField(target, "this$" + i)).isEqualTo(expected); return; } catch (IllegalArgumentException e) { // Suppress and try next @@ -1102,7 +1094,7 @@ public class MappingMongoConverterUnitTests { MongoPersistentProperty property = mock(MongoPersistentProperty.class); - assertThat(converter.createDBRef(dbRef, property), is(dbRef)); + assertThat(converter.createDBRef(dbRef, property)).isEqualTo(dbRef); } @Test // DATAMONGO-523, DATAMONGO-1509 @@ -1181,17 +1173,17 @@ public class MappingMongoConverterUnitTests { ClassWithMapProperty result = mongoConverter.read(ClassWithMapProperty.class, document); - assertThat(result.mapOfPersons, is(notNullValue())); + assertThat(result.mapOfPersons).isNotNull(); Person personCandidate = result.mapOfPersons.get("foo"); - assertThat(personCandidate, is(notNullValue())); - assertThat(personCandidate.firstname, is("Dave")); + assertThat(personCandidate).isNotNull(); + assertThat(personCandidate.firstname).isEqualTo("Dave"); - assertThat(result.mapOfObjects, is(notNullValue())); + assertThat(result.mapOfObjects).isNotNull(); Object value = result.mapOfObjects.get("foo"); - assertThat(value, is(notNullValue())); - assertThat(value, is(instanceOf(Person.class))); - assertThat(((Person) value).firstname, is("Dave")); - assertThat(((Person) value).lastname, is("converter")); + assertThat(value).isNotNull(); + assertThat(value).isInstanceOf(Person.class); + assertThat(((Person) value).firstname).isEqualTo("Dave"); + assertThat(((Person) value).lastname).isEqualTo("converter"); } @Test // DATAMONGO-743, DATAMONGO-2198 @@ -1199,10 +1191,10 @@ public class MappingMongoConverterUnitTests { String target = converter.read(String.class, new org.bson.Document("firstname", "Dave")); - assertThat(target, Matchers.startsWith("{")); - assertThat(target, Matchers.endsWith("}")); - assertThat(target, Matchers.containsString("\"firstname\"")); - assertThat(target, Matchers.containsString("\"Dave\"")); + assertThat(target).startsWith("{"); + assertThat(target).endsWith("}"); + assertThat(target).contains("\"firstname\""); + assertThat(target).contains("\"Dave\""); } @Test // DATAMONGO-766 @@ -1219,10 +1211,10 @@ public class MappingMongoConverterUnitTests { org.bson.Document result = new org.bson.Document(); converter.write(type, result); - assertThat(result.get("name"), is((Object) "name")); + assertThat(result.get("name")).isEqualTo((Object) "name"); org.bson.Document aValue = DocumentTestUtils.getAsDocument(result, "a"); - assertThat(aValue.get("b"), is((Object) "bar")); - assertThat(aValue.get("c"), is((Object) "C")); + assertThat(aValue.get("b")).isEqualTo((Object) "bar"); + assertThat(aValue.get("c")).isEqualTo((Object) "C"); } @Test // DATAMONGO-812, DATAMONGO-893, DATAMONGO-1509 @@ -1235,10 +1227,10 @@ public class MappingMongoConverterUnitTests { Object result = converter.convertToMongoType(Collections.singletonList(address), ClassTypeInformation.from(InterfaceType.class)); - assertThat(result, is(instanceOf(List.class))); + assertThat(result).isInstanceOf(List.class); List dbList = (List) result; - assertThat(dbList, hasSize(1)); + assertThat(dbList).hasSize(1); assertTypeHint(getAsDocument(dbList, 0), Address.class); } @@ -1247,11 +1239,11 @@ public class MappingMongoConverterUnitTests { Object result = converter.convertToMongoType(Collections.singletonList("foo")); - assertThat(result, is(instanceOf(List.class))); + assertThat(result).isInstanceOf(List.class); List dbList = (List) result; - assertThat(dbList, hasSize(1)); - assertThat(dbList.get(0), instanceOf(String.class)); + assertThat(dbList).hasSize(1); + assertThat(dbList.get(0)).isInstanceOf(String.class); } @Test // DATAMONGO-812, DATAMONGO-1509 @@ -1263,10 +1255,10 @@ public class MappingMongoConverterUnitTests { Object result = converter.convertToMongoType(new Address[] { address }, ClassTypeInformation.OBJECT); - assertThat(result, is(instanceOf(List.class))); + assertThat(result).isInstanceOf(List.class); List dbList = (List) result; - assertThat(dbList, hasSize(1)); + assertThat(dbList).hasSize(1); assertTypeHint(getAsDocument(dbList, 0), Address.class); } @@ -1275,11 +1267,11 @@ public class MappingMongoConverterUnitTests { Object result = converter.convertToMongoType(new String[] { "foo" }); - assertThat(result, is(instanceOf(List.class))); + assertThat(result).isInstanceOf(List.class); List dbList = (List) result; - assertThat(dbList, hasSize(1)); - assertThat(dbList.get(0), instanceOf(String.class)); + assertThat(dbList).hasSize(1); + assertThat(dbList.get(0)).isInstanceOf(String.class); } @Test // DATAMONGO-833 @@ -1291,9 +1283,9 @@ public class MappingMongoConverterUnitTests { ClassWithEnumProperty result = converter.read(ClassWithEnumProperty.class, document); - assertThat(result.enumSet, is(instanceOf(EnumSet.class))); - assertThat(result.enumSet.size(), is(1)); - assertThat(result.enumSet, hasItem(SampleEnum.SECOND)); + assertThat(result.enumSet).isInstanceOf(EnumSet.class); + assertThat(result.enumSet.size()).isEqualTo(1); + assertThat(result.enumSet).contains(SampleEnum.SECOND); } @Test // DATAMONGO-833 @@ -1303,9 +1295,9 @@ public class MappingMongoConverterUnitTests { ClassWithEnumProperty result = converter.read(ClassWithEnumProperty.class, new org.bson.Document("enumMap", enumMap)); - assertThat(result.enumMap, is(instanceOf(EnumMap.class))); - assertThat(result.enumMap.size(), is(1)); - assertThat(result.enumMap.get(SampleEnum.FIRST), is("Dave")); + assertThat(result.enumMap).isInstanceOf(EnumMap.class); + assertThat(result.enumMap.size()).isEqualTo(1); + assertThat(result.enumMap.get(SampleEnum.FIRST)).isEqualTo("Dave"); } @Test // DATAMONGO-887 @@ -1317,9 +1309,9 @@ public class MappingMongoConverterUnitTests { ClassWithMapProperty result = converter.read(ClassWithMapProperty.class, document); - assertThat(result.treeMapOfPersons, is(notNullValue())); - assertThat(result.treeMapOfPersons.get("key"), is(notNullValue())); - assertThat(result.treeMapOfPersons.get("key").firstname, is("Dave")); + assertThat(result.treeMapOfPersons).isNotNull(); + assertThat(result.treeMapOfPersons.get("key")).isNotNull(); + assertThat(result.treeMapOfPersons.get("key").firstname).isEqualTo("Dave"); } @Test // DATAMONGO-887 @@ -1338,7 +1330,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document map = getAsDocument(result, "treeMapOfPersons"); org.bson.Document entry = getAsDocument(map, "key"); - assertThat(entry.get("foo"), is("Dave")); + assertThat(entry.get("foo")).isEqualTo("Dave"); } @Test // DATAMONGO-858 @@ -1350,10 +1342,10 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(object, document); - assertThat(document, is(notNullValue())); - assertThat(document.get("box"), is(instanceOf(org.bson.Document.class))); - assertThat(document.get("box"), is((Object) new org.bson.Document() - .append("first", toDocument(object.box.getFirst())).append("second", toDocument(object.box.getSecond())))); + assertThat(document).isNotNull(); + assertThat(document.get("box")).isInstanceOf(org.bson.Document.class); + assertThat(document.get("box")).isEqualTo((Object) new org.bson.Document() + .append("first", toDocument(object.box.getFirst())).append("second", toDocument(object.box.getSecond()))); } private static org.bson.Document toDocument(Point point) { @@ -1371,8 +1363,8 @@ public class MappingMongoConverterUnitTests { ClassWithGeoBox result = converter.read(ClassWithGeoBox.class, document); - assertThat(result, is(notNullValue())); - assertThat(result.box, is(object.box)); + assertThat(result).isNotNull(); + assertThat(result.box).isEqualTo(object.box); } @Test // DATAMONGO-858 @@ -1384,17 +1376,17 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(object, document); - assertThat(document, is(notNullValue())); + assertThat(document).isNotNull(); - assertThat(document.get("polygon"), is(instanceOf(org.bson.Document.class))); + assertThat(document.get("polygon")).isInstanceOf(org.bson.Document.class); org.bson.Document polygonDoc = (org.bson.Document) document.get("polygon"); @SuppressWarnings("unchecked") List points = (List) polygonDoc.get("points"); - assertThat(points, hasSize(3)); - assertThat(points, Matchers. hasItems(toDocument(object.polygon.getPoints().get(0)), - toDocument(object.polygon.getPoints().get(1)), toDocument(object.polygon.getPoints().get(2)))); + assertThat(points).hasSize(3); + assertThat(points).contains(toDocument(object.polygon.getPoints().get(0)), + toDocument(object.polygon.getPoints().get(1)), toDocument(object.polygon.getPoints().get(2))); } @Test // DATAMONGO-858 @@ -1408,8 +1400,8 @@ public class MappingMongoConverterUnitTests { ClassWithGeoPolygon result = converter.read(ClassWithGeoPolygon.class, document); - assertThat(result, is(notNullValue())); - assertThat(result.polygon, is(object.polygon)); + assertThat(result).isNotNull(); + assertThat(result.polygon).isEqualTo(object.polygon); } @Test // DATAMONGO-858 @@ -1423,12 +1415,11 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(object, document); - assertThat(document, is(notNullValue())); - assertThat(document.get("circle"), is(instanceOf(org.bson.Document.class))); - assertThat(document.get("circle"), - is((Object) new org.bson.Document("center", - new org.bson.Document("x", circle.getCenter().getX()).append("y", circle.getCenter().getY())) - .append("radius", radius.getNormalizedValue()).append("metric", radius.getMetric().toString()))); + assertThat(document).isNotNull(); + assertThat(document.get("circle")).isInstanceOf(org.bson.Document.class); + assertThat(document.get("circle")).isEqualTo((Object) new org.bson.Document("center", + new org.bson.Document("x", circle.getCenter().getX()).append("y", circle.getCenter().getY())) + .append("radius", radius.getNormalizedValue()).append("metric", radius.getMetric().toString())); } @Test // DATAMONGO-858 @@ -1442,8 +1433,8 @@ public class MappingMongoConverterUnitTests { ClassWithGeoCircle result = converter.read(ClassWithGeoCircle.class, document); - assertThat(result, is(notNullValue())); - assertThat(result.circle, is(result.circle)); + assertThat(result).isNotNull(); + assertThat(result.circle).isEqualTo(result.circle); } @Test // DATAMONGO-858 @@ -1457,12 +1448,11 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(object, document); - assertThat(document, is(notNullValue())); - assertThat(document.get("sphere"), is(instanceOf(org.bson.Document.class))); - assertThat(document.get("sphere"), - is((Object) new org.bson.Document("center", - new org.bson.Document("x", sphere.getCenter().getX()).append("y", sphere.getCenter().getY())) - .append("radius", radius.getNormalizedValue()).append("metric", radius.getMetric().toString()))); + assertThat(document).isNotNull(); + assertThat(document.get("sphere")).isInstanceOf(org.bson.Document.class); + assertThat(document.get("sphere")).isEqualTo((Object) new org.bson.Document("center", + new org.bson.Document("x", sphere.getCenter().getX()).append("y", sphere.getCenter().getY())) + .append("radius", radius.getNormalizedValue()).append("metric", radius.getMetric().toString())); } @Test // DATAMONGO-858 @@ -1476,12 +1466,11 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(object, document); - assertThat(document, is(notNullValue())); - assertThat(document.get("sphere"), is(instanceOf(org.bson.Document.class))); - assertThat(document.get("sphere"), - is((Object) new org.bson.Document("center", - new org.bson.Document("x", sphere.getCenter().getX()).append("y", sphere.getCenter().getY())) - .append("radius", radius.getNormalizedValue()).append("metric", radius.getMetric().toString()))); + assertThat(document).isNotNull(); + assertThat(document.get("sphere")).isInstanceOf(org.bson.Document.class); + assertThat(document.get("sphere")).isEqualTo((Object) new org.bson.Document("center", + new org.bson.Document("x", sphere.getCenter().getX()).append("y", sphere.getCenter().getY())) + .append("radius", radius.getNormalizedValue()).append("metric", radius.getMetric().toString())); } @Test // DATAMONGO-858 @@ -1495,8 +1484,8 @@ public class MappingMongoConverterUnitTests { ClassWithGeoSphere result = converter.read(ClassWithGeoSphere.class, document); - assertThat(result, is(notNullValue())); - assertThat(result.sphere, is(object.sphere)); + assertThat(result).isNotNull(); + assertThat(result.sphere).isEqualTo(object.sphere); } @Test // DATAMONGO-858 @@ -1510,12 +1499,11 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(object, document); - assertThat(document, is(notNullValue())); - assertThat(document.get("shape"), is(instanceOf(org.bson.Document.class))); - assertThat(document.get("shape"), - is((Object) new org.bson.Document("center", - new org.bson.Document("x", sphere.getCenter().getX()).append("y", sphere.getCenter().getY())) - .append("radius", radius.getNormalizedValue()).append("metric", radius.getMetric().toString()))); + assertThat(document).isNotNull(); + assertThat(document.get("shape")).isInstanceOf(org.bson.Document.class); + assertThat(document.get("shape")).isEqualTo((Object) new org.bson.Document("center", + new org.bson.Document("x", sphere.getCenter().getX()).append("y", sphere.getCenter().getY())) + .append("radius", radius.getNormalizedValue()).append("metric", radius.getMetric().toString())); } @Test // DATAMONGO-858 @@ -1531,8 +1519,8 @@ public class MappingMongoConverterUnitTests { ClassWithGeoShape result = converter.read(ClassWithGeoShape.class, document); - assertThat(result, is(notNullValue())); - assertThat(result.shape, is(sphere)); + assertThat(result).isNotNull(); + assertThat(result.shape).isEqualTo(sphere); } @Test // DATAMONGO-976 @@ -1544,7 +1532,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document document = new org.bson.Document(); converter.write(source, document); - assertThat(document.get("score"), nullValue()); + assertThat(document.get("score")).isNull(); } @Test // DATAMONGO-976 @@ -1552,7 +1540,7 @@ public class MappingMongoConverterUnitTests { ClassWithTextScoreProperty entity = converter.read(ClassWithTextScoreProperty.class, new org.bson.Document("score", 5F)); - assertThat(entity.score, equalTo(5F)); + assertThat(entity.score).isEqualTo(5F); } @Test // DATAMONGO-1001, DATAMONGO-1509 @@ -1623,8 +1611,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document sink = new org.bson.Document(); converter.write(source, sink); - assertThat(sink.get("_id"), is("rootId")); - assertThat(sink.get("nested"), is(new org.bson.Document().append("id", "nestedId"))); + assertThat(sink.get("_id")).isEqualTo("rootId"); + assertThat(sink.get("nested")).isEqualTo(new org.bson.Document().append("id", "nestedId")); } @Test // DATAMONGO-1050 @@ -1636,9 +1624,9 @@ public class MappingMongoConverterUnitTests { RootForClassWithExplicitlyRenamedIdField sink = converter.read(RootForClassWithExplicitlyRenamedIdField.class, source); - assertThat(sink.id, is("rootId")); - assertThat(sink.nested, notNullValue()); - assertThat(sink.nested.id, is("nestedId")); + assertThat(sink.id).isEqualTo("rootId"); + assertThat(sink.nested).isNotNull(); + assertThat(sink.nested.id).isEqualTo("nestedId"); } @Test // DATAMONGO-1050 @@ -1648,7 +1636,7 @@ public class MappingMongoConverterUnitTests { ClassWithNamedIdField withNamedIdField = converter.read(ClassWithNamedIdField.class, document); - assertThat(withNamedIdField.id, is("A")); + assertThat(withNamedIdField.id).isEqualTo("A"); } @Test // DATAMONGO-1050 @@ -1659,7 +1647,7 @@ public class MappingMongoConverterUnitTests { ClassWithExplicitlyRenamedField withExplicitlyRenamedField = converter.read(ClassWithExplicitlyRenamedField.class, document); - assertThat(withExplicitlyRenamedField.id, is("B")); + assertThat(withExplicitlyRenamedField.id).isEqualTo("B"); } @Test // DATAMONGO-1050 @@ -1669,7 +1657,7 @@ public class MappingMongoConverterUnitTests { ClassWithAnnotatedIdField withAnnotatedIdField = converter.read(ClassWithAnnotatedIdField.class, document); - assertThat(withAnnotatedIdField.key, is("A")); + assertThat(withAnnotatedIdField.key).isEqualTo("A"); } @Test // DATAMONGO-1102 @@ -1681,8 +1669,8 @@ public class MappingMongoConverterUnitTests { converter.write(source, result); - assertThat(result.get("date"), is(instanceOf(Date.class))); - assertThat(converter.read(TypeWithLocalDateTime.class, result).date, is(reference)); + assertThat(result.get("date")).isInstanceOf(Date.class); + assertThat(converter.read(TypeWithLocalDateTime.class, result).date).isEqualTo(reference); } @Test // DATAMONGO-1128 @@ -1695,10 +1683,10 @@ public class MappingMongoConverterUnitTests { converter.write(type, result); - assertThat(getAsDocument(result, "string"), is(new org.bson.Document())); + assertThat(getAsDocument(result, "string")).isEqualTo(new org.bson.Document()); org.bson.Document localDateTime = getAsDocument(result, "localDateTime"); - assertThat(localDateTime.get("value"), is(instanceOf(Date.class))); + assertThat(localDateTime.get("value")).isInstanceOf(Date.class); } @Test // DATAMONGO-1128 @@ -1713,8 +1701,8 @@ public class MappingMongoConverterUnitTests { TypeWithOptional read = converter.read(TypeWithOptional.class, result); - assertThat(read.string, is(Optional. empty())); - assertThat(read.localDateTime, is(Optional.of(now))); + assertThat(read.string).isEmpty(); + assertThat(read.localDateTime).isEqualTo(Optional.of(now)); } @Test // DATAMONGO-1118 @@ -1732,7 +1720,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document target = new org.bson.Document(); converter.write(source, target); - assertThat(converter.read(ClassWithMapUsingEnumAsKey.class, target).map, is(source.map)); + assertThat(converter.read(ClassWithMapUsingEnumAsKey.class, target).map).isEqualTo(source.map); } @Test // DATAMONGO-1118 @@ -1752,8 +1740,8 @@ public class MappingMongoConverterUnitTests { org.bson.Document map = DocumentTestUtils.getAsDocument(target, "map"); - assertThat(map.containsKey("foo-enum-value"), is(true)); - assertThat(map.containsKey("bar-enum-value"), is(true)); + assertThat(map.containsKey("foo-enum-value")).isTrue(); + assertThat(map.containsKey("bar-enum-value")).isTrue(); } @Test // DATAMONGO-1118 @@ -1767,12 +1755,12 @@ public class MappingMongoConverterUnitTests { ClassWithMapUsingEnumAsKey target = converter.read(ClassWithMapUsingEnumAsKey.class, source); - assertThat(target.map.get(FooBarEnum.FOO), is("spring")); + assertThat(target.map.get(FooBarEnum.FOO)).isEqualTo("spring"); } @Test // DATAMONGO-1471 public void readsDocumentWithPrimitiveIdButNoValue() { - assertThat(converter.read(ClassWithIntId.class, new org.bson.Document()), is(notNullValue())); + assertThat(converter.read(ClassWithIntId.class, new org.bson.Document())).isNotNull(); } @Test // DATAMONGO-1497 @@ -1781,7 +1769,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document source = new org.bson.Document("nested", new org.bson.Document("sample", "value")); TypeWithPropertyInNestedField result = converter.read(TypeWithPropertyInNestedField.class, source); - assertThat(result.sample, is("value")); + assertThat(result.sample).isEqualTo("value"); } @Test // DATAMONGO-1525 @@ -1789,7 +1777,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document source = new org.bson.Document("enumSet", Collections.emptyList()); - assertThat(converter.read(ClassWithEnumProperty.class, source).enumSet, is(EnumSet.noneOf(SampleEnum.class))); + assertThat(converter.read(ClassWithEnumProperty.class, source).enumSet).isEqualTo(EnumSet.noneOf(SampleEnum.class)); } @Test // DATAMONGO-1757 @@ -1810,7 +1798,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document source = new org.bson.Document("array", Collections.emptyList()); - assertThat(converter.read(WithArrayInConstructor.class, source).array, is(emptyArray())); + assertThat(converter.read(WithArrayInConstructor.class, source).array).isEmpty(); } @Test // DATAMONGO-1831 @@ -1818,7 +1806,7 @@ public class MappingMongoConverterUnitTests { org.bson.Document source = new org.bson.Document(); - assertThat(converter.read(WithArrayInConstructor.class, source).array, is(nullValue())); + assertThat(converter.read(WithArrayInConstructor.class, source).array).isNull(); } @Test // DATAMONGO-1898 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MongoExampleMapperUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MongoExampleMapperUnitTests.java index 7c18817f3..4284f1688 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MongoExampleMapperUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MongoExampleMapperUnitTests.java @@ -15,25 +15,24 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; import static org.springframework.data.domain.Example.*; import static org.springframework.data.domain.ExampleMatcher.*; import static org.springframework.data.mongodb.core.DocumentTestUtils.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import java.util.Arrays; +import java.util.Collections; import java.util.List; import java.util.Set; import java.util.regex.Pattern; import org.bson.conversions.Bson; -import org.hamcrest.core.Is; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.annotation.Id; import org.springframework.data.domain.Example; import org.springframework.data.domain.ExampleMatcher; @@ -47,7 +46,6 @@ import org.springframework.data.mongodb.core.mapping.Document; import org.springframework.data.mongodb.core.mapping.Field; import org.springframework.data.mongodb.core.mapping.MongoMappingContext; import org.springframework.data.mongodb.core.query.UntypedExampleMatcher; -import org.springframework.data.mongodb.test.util.IsBsonObject; import org.springframework.data.util.TypeInformation; /** @@ -80,10 +78,8 @@ public class MongoExampleMapperUnitTests { FlatDocument probe = new FlatDocument(); probe.id = "steelheart"; - IsBsonObject expected = isBsonObject().containing("_id", "steelheart"); - - assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class)), - is(expected)); + assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("_id", "steelheart"); } @Test // DATAMONGO-1245 @@ -94,13 +90,10 @@ public class MongoExampleMapperUnitTests { probe.stringValue = "firefight"; probe.intValue = 100; - IsBsonObject expected = isBsonObject().// - containing("_id", "steelheart").// - containing("stringValue", "firefight").// - containing("intValue", 100); - - assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class)), - is(expected)); + assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("_id", "steelheart") // + .containsEntry("stringValue", "firefight") // + .containsEntry("intValue", 100); } @Test // DATAMONGO-1245 @@ -110,12 +103,9 @@ public class MongoExampleMapperUnitTests { probe.stringValue = "firefight"; probe.intValue = 100; - IsBsonObject expected = isBsonObject().// - containing("stringValue", "firefight").// - containing("intValue", 100); - - assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class)), - is(expected)); + assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class))) // + .containsEntry("stringValue", "firefight") // + .containsEntry("intValue", 100); } @Test // DATAMONGO-1245 @@ -126,11 +116,8 @@ public class MongoExampleMapperUnitTests { List list = (Arrays.asList("Prof", "Tia", "David")); - IsBsonObject expected = isBsonObject().// - containing("listOfString", list); - - assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class)), - is(expected)); + assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("listOfString", list); } @Test // DATAMONGO-1245 @@ -139,10 +126,8 @@ public class MongoExampleMapperUnitTests { FlatDocument probe = new FlatDocument(); probe.customNamedField = "Mitosis"; - IsBsonObject expected = isBsonObject().containing("custom_field_name", "Mitosis"); - - assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class)), - is(expected)); + assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("custom_field_name", "Mitosis"); } @Test // DATAMONGO-1245 @@ -155,8 +140,8 @@ public class MongoExampleMapperUnitTests { org.bson.Document document = mapper.getMappedExample(Example.of(probe), context.getRequiredPersistentEntity(WrapperDocument.class)); - assertThat(document, - isBsonObject().containing("_class", new org.bson.Document("$in", new String[] { probe.getClass().getName() }))); + assertThat(document).containsEntry("_class", + new org.bson.Document("$in", Collections.singletonList(probe.getClass().getName()))); } @Test // DATAMONGO-1245 @@ -166,10 +151,8 @@ public class MongoExampleMapperUnitTests { probe.flatDoc = new FlatDocument(); probe.flatDoc.stringValue = "conflux"; - IsBsonObject expected = isBsonObject().containing("flatDoc\\.stringValue", "conflux"); - - assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(WrapperDocument.class)), - is(expected)); + assertThat(mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(WrapperDocument.class))) + .containsEntry("flatDoc\\.stringValue", "conflux"); } @Test // DATAMONGO-1245 @@ -181,8 +164,8 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withIncludeNullValues()); - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(WrapperDocument.class)), // - isBsonObject().containing("flatDoc.stringValue", "conflux")); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(WrapperDocument.class))) + .containsEntry("flatDoc.stringValue", "conflux"); } @Test // DATAMONGO-1245 @@ -194,11 +177,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withStringMatcher(StringMatcher.STARTING)); - IsBsonObject expected = isBsonObject().// - containing("stringValue.$regex", "^firefight").// - containing("intValue", 100); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("stringValue.$regex", "^firefight")// + .containsEntry("intValue", 100); } @Test // DATAMONGO-1245 @@ -210,11 +191,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withStringMatcher(StringMatcher.STARTING)); - IsBsonObject expected = isBsonObject().// - containing("stringValue.$regex", "^" + Pattern.quote("fire.ight")).// - containing("intValue", 100); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("stringValue.$regex", "^" + Pattern.quote("fire.ight"))// + .containsEntry("intValue", 100); } @Test // DATAMONGO-1245 @@ -226,11 +205,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withStringMatcher(StringMatcher.ENDING)); - IsBsonObject expected = isBsonObject().// - containing("stringValue.$regex", "firefight$").// - containing("intValue", 100); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("stringValue.$regex", "firefight$") // + .containsEntry("intValue", 100); } @Test // DATAMONGO-1245 @@ -242,11 +219,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withStringMatcher(StringMatcher.REGEX)); - IsBsonObject expected = isBsonObject().// - containing("stringValue.$regex", "firefight").// - containing("custom_field_name.$regex", "^(cat|dog).*shelter\\d?"); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("stringValue.$regex", "firefight") // + .containsEntry("custom_field_name.$regex", "^(cat|dog).*shelter\\d?"); } @Test // DATAMONGO-1245 @@ -258,11 +233,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withStringMatcher(StringMatcher.ENDING).withIgnoreCase()); - IsBsonObject expected = isBsonObject().// - containing("stringValue", new org.bson.Document("$regex", "firefight$").append("$options", "i")).// - containing("intValue", 100); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("stringValue", new org.bson.Document("$regex", "firefight$").append("$options", "i")) // + .containsEntry("intValue", 100); } @Test // DATAMONGO-1245 @@ -274,11 +247,10 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withIgnoreCase()); - IsBsonObject expected = isBsonObject().// - containing("stringValue", new org.bson.Document("$regex", Pattern.quote("firefight")).append("$options", "i")).// - containing("intValue", 100); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("stringValue", + new org.bson.Document("$regex", Pattern.quote("firefight")).append("$options", "i")) // + .containsEntry("intValue", 100); } @Test // DATAMONGO-1245 @@ -293,8 +265,8 @@ public class MongoExampleMapperUnitTests { context.getRequiredPersistentEntity(WithDBRef.class)); com.mongodb.DBRef reference = getTypedValue(document, "referenceDocument", com.mongodb.DBRef.class); - assertThat(reference.getId(), Is. is("200")); - assertThat(reference.getCollectionName(), is("refDoc")); + assertThat(reference.getId()).isEqualTo("200"); + assertThat(reference.getCollectionName()).isEqualTo("refDoc"); } @Test // DATAMONGO-1245 @@ -306,7 +278,7 @@ public class MongoExampleMapperUnitTests { org.bson.Document document = mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class)); - assertThat(document, isBsonObject().containing("stringValue", "steelheart")); + assertThat(document).containsEntry("stringValue", "steelheart"); } @Test // DATAMONGO-1245 @@ -318,8 +290,8 @@ public class MongoExampleMapperUnitTests { org.bson.Document document = mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(WithDBRef.class)); - assertThat(document.get("legacyPoint.x"), Is. is(10D)); - assertThat(document.get("legacyPoint.y"), Is. is(20D)); + assertThat(document.get("legacyPoint.x")).isEqualTo(10D); + assertThat(document.get("legacyPoint.y")).isEqualTo(20D); } @Test // DATAMONGO-1245 @@ -332,11 +304,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withIgnorePaths("customNamedField")); - IsBsonObject expected = isBsonObject().// - containing("stringValue", "string").// - containing("intValue", 10); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("stringValue", "string") // + .containsEntry("intValue", 10); } @Test // DATAMONGO-1245 @@ -349,11 +319,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withIgnorePaths("stringValue")); - IsBsonObject expected = isBsonObject().// - containing("custom_field_name", "foo").// - containing("intValue", 10); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("custom_field_name", "foo") // + .containsEntry("intValue", 10); } @Test // DATAMONGO-1245 @@ -367,12 +335,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withIgnorePaths("flatDoc.stringValue")); - IsBsonObject expected = isBsonObject().// - containing("flatDoc\\.custom_field_name", "foo").// - containing("flatDoc\\.intValue", 10); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(WrapperDocument.class)), - is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(WrapperDocument.class))) + .containsEntry("flatDoc\\.custom_field_name", "foo")// + .containsEntry("flatDoc\\.intValue", 10); } @Test // DATAMONGO-1245 @@ -386,12 +351,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withIgnorePaths("flatDoc.customNamedField")); - IsBsonObject expected = isBsonObject().// - containing("flatDoc\\.stringValue", "string").// - containing("flatDoc\\.intValue", 10); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(WrapperDocument.class)), - is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(WrapperDocument.class))) + .containsEntry("flatDoc\\.stringValue", "string") // + .containsEntry("flatDoc\\.intValue", 10); } @Test // DATAMONGO-1245 @@ -403,11 +365,9 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, matching().withMatcher("stringValue", GenericPropertyMatchers.contains())); - IsBsonObject expected = isBsonObject().// - containing("stringValue.$regex", ".*firefight.*").// - containing("custom_field_name", "steelheart"); - - assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class)), is(expected)); + assertThat(mapper.getMappedExample(example, context.getRequiredPersistentEntity(FlatDocument.class))) + .containsEntry("stringValue.$regex", ".*firefight.*") // + .containsEntry("custom_field_name", "steelheart"); } @Test // DATAMONGO-1245 @@ -421,7 +381,7 @@ public class MongoExampleMapperUnitTests { org.bson.Document document = mapper.getMappedExample(of(probe), context.getRequiredPersistentEntity(FlatDocument.class)); - assertThat(document, isBsonObject().containing("anotherStringValue", "calamity")); + assertThat(document).containsEntry("anotherStringValue", "calamity"); } @Test // DATAMONGO-1459 @@ -433,7 +393,7 @@ public class MongoExampleMapperUnitTests { Example example = Example.of(probe, ExampleMatcher.matchingAny()); - assertThat(mapper.getMappedExample(example), isBsonObject().containing("$or").containing("_class")); + assertThat(mapper.getMappedExample(example)).containsKeys("$or", "_class"); } @Test // DATAMONGO-1768 @@ -446,7 +406,7 @@ public class MongoExampleMapperUnitTests { org.bson.Document document = mapper .getMappedExample(Example.of(probe, ExampleMatcher.matching().withIgnorePaths("_class"))); - assertThat(document, isBsonObject().notContaining("_class")); + assertThat(document).doesNotContainKey("_class"); } @Test // DATAMONGO-1768 @@ -480,7 +440,7 @@ public class MongoExampleMapperUnitTests { org.bson.Document document = new MongoExampleMapper(mappingMongoConverter) .getMappedExample(Example.of(probe, ExampleMatcher.matching().withIgnorePaths("_foo"))); - assertThat(document, isBsonObject().notContaining("_class").notContaining("_foo")); + assertThat(document).doesNotContainKeys("_class", "_foo"); } @Test // DATAMONGO-1768 @@ -491,7 +451,7 @@ public class MongoExampleMapperUnitTests { probe.flatDoc.stringValue = "conflux"; org.bson.Document document = mapper.getMappedExample(Example.of(probe, UntypedExampleMatcher.matching())); - assertThat(document, isBsonObject().notContaining("_class")); + assertThat(document).doesNotContainKey("_class"); } static class FlatDocument { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/NamedMongoScriptConvertsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/NamedMongoScriptConvertsUnitTests.java index 9ac30f782..c96e6bbe1 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/NamedMongoScriptConvertsUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/NamedMongoScriptConvertsUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import org.bson.Document; import org.bson.types.Code; @@ -24,6 +23,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses; + import org.springframework.core.convert.converter.Converter; import org.springframework.data.mongodb.core.convert.MongoConverters.DocumentToNamedMongoScriptConverter; import org.springframework.data.mongodb.core.convert.MongoConverters.NamedMongoScriptToDocumentConverter; @@ -39,7 +39,8 @@ import org.springframework.data.mongodb.core.script.NamedMongoScript; * @since 1.7 */ @RunWith(Suite.class) -@SuiteClasses({ NamedMongoScriptToDocumentConverterUnitTests.class, DocumentToNamedMongoScriptConverterUnitTests.class }) +@SuiteClasses({ NamedMongoScriptToDocumentConverterUnitTests.class, + DocumentToNamedMongoScriptConverterUnitTests.class }) public class NamedMongoScriptConvertsUnitTests { static final String FUNCTION_NAME = "echo"; @@ -57,7 +58,7 @@ public class NamedMongoScriptConvertsUnitTests { @Test // DATAMONGO-479 public void convertShouldReturnEmptyDocWhenScriptIsNull() { - assertThat(converter.convert(null), is((Document) new Document())); + assertThat(converter.convert(null)).isEqualTo(new Document()); } @Test // DATAMONGO-479 @@ -66,8 +67,7 @@ public class NamedMongoScriptConvertsUnitTests { Document document = converter.convert(ECHO_SCRIPT); Object id = document.get("_id"); - assertThat(id, is(instanceOf(String.class))); - assertThat(id, is((Object) FUNCTION_NAME)); + assertThat(id).isInstanceOf(String.class).isEqualTo(FUNCTION_NAME); } @Test // DATAMONGO-479 @@ -76,8 +76,7 @@ public class NamedMongoScriptConvertsUnitTests { Document document = converter.convert(ECHO_SCRIPT); Object code = document.get("value"); - assertThat(code, is(instanceOf(Code.class))); - assertThat(code, is((Object) new Code(JS_FUNCTION))); + assertThat(code).isInstanceOf(Code.class).isEqualTo(new Code(JS_FUNCTION)); } } @@ -90,7 +89,7 @@ public class NamedMongoScriptConvertsUnitTests { @Test // DATAMONGO-479 public void convertShouldReturnNullIfSourceIsNull() { - assertThat(converter.convert(null), is(nullValue())); + assertThat(converter.convert(null)).isNull(); } @Test // DATAMONGO-479 @@ -98,7 +97,7 @@ public class NamedMongoScriptConvertsUnitTests { NamedMongoScript script = converter.convert(FUNCTION); - assertThat(script.getName(), is(FUNCTION_NAME)); + assertThat(script.getName()).isEqualTo(FUNCTION_NAME); } @Test // DATAMONGO-479 @@ -106,8 +105,7 @@ public class NamedMongoScriptConvertsUnitTests { NamedMongoScript script = converter.convert(FUNCTION); - assertThat(script.getCode(), is(notNullValue())); - assertThat(script.getCode(), is(JS_FUNCTION)); + assertThat(script.getCode()).isEqualTo(JS_FUNCTION); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/NumberToNumberConverterFactoryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/NumberToNumberConverterFactoryUnitTests.java index d7911459c..271c43bed 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/NumberToNumberConverterFactoryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/NumberToNumberConverterFactoryUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.core.Is.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Arrays; import java.util.Collection; @@ -28,6 +27,7 @@ import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; + import org.springframework.data.mongodb.core.convert.MongoConverters.NumberToNumberConverterFactory; /** @@ -54,6 +54,7 @@ public class NumberToNumberConverterFactoryUnitTests { @Test // DATAMONGO-1288 public void convertsToTargetTypeCorrectly() { - assertThat(NumberToNumberConverterFactory.INSTANCE.getConverter(expected.getClass()).convert(source), is(expected)); + assertThat(NumberToNumberConverterFactory.INSTANCE.getConverter(expected.getClass()).convert(source)) + .isEqualTo(expected); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/TermToStringConverterUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/TermToStringConverterUnitTests.java index 04ac19327..79c944d90 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/TermToStringConverterUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/TermToStringConverterUnitTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.core.convert; -import static org.hamcrest.core.IsNull.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import org.junit.Test; + import org.springframework.data.mongodb.core.convert.MongoConverters.TermToStringConverter; import org.springframework.data.mongodb.core.query.Term; import org.springframework.data.mongodb.core.query.Term.Type; @@ -31,7 +31,7 @@ public class TermToStringConverterUnitTests { @Test // DATAMONGO-973 public void shouldNotConvertNull() { - assertThat(TermToStringConverter.INSTANCE.convert(null), nullValue()); + assertThat(TermToStringConverter.INSTANCE.convert(null)).isNull(); } @Test // DATAMONGO-973 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoJsonModuleUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoJsonModuleUnitTests.java index e632c5339..b0deca101 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoJsonModuleUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoJsonModuleUnitTests.java @@ -15,14 +15,14 @@ */ package org.springframework.data.mongodb.core.geo; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.io.IOException; import java.util.Arrays; import org.junit.Before; import org.junit.Test; + import org.springframework.data.geo.Point; import com.fasterxml.jackson.core.JsonParseException; @@ -48,7 +48,7 @@ public class GeoJsonModuleUnitTests { String json = "{ \"type\": \"Point\", \"coordinates\": [10.0, 20.0] }"; - assertThat(mapper.readValue(json, GeoJsonPoint.class), is(new GeoJsonPoint(10D, 20D))); + assertThat(mapper.readValue(json, GeoJsonPoint.class)).isEqualTo(new GeoJsonPoint(10D, 20D)); } @Test // DATAMONGO-1181 @@ -57,8 +57,8 @@ public class GeoJsonModuleUnitTests { String json = "{ \"type\": \"LineString\", \"coordinates\": [ [10.0, 20.0], [30.0, 40.0], [50.0, 60.0] ]}"; - assertThat(mapper.readValue(json, GeoJsonLineString.class), - is(new GeoJsonLineString(Arrays.asList(new Point(10, 20), new Point(30, 40), new Point(50, 60))))); + assertThat(mapper.readValue(json, GeoJsonLineString.class)) + .isEqualTo(new GeoJsonLineString(Arrays.asList(new Point(10, 20), new Point(30, 40), new Point(50, 60)))); } @Test // DATAMONGO-1181 @@ -67,8 +67,8 @@ public class GeoJsonModuleUnitTests { String json = "{ \"type\": \"MultiPoint\", \"coordinates\": [ [10.0, 20.0], [30.0, 40.0], [50.0, 60.0] ]}"; - assertThat(mapper.readValue(json, GeoJsonLineString.class), - is(new GeoJsonMultiPoint(Arrays.asList(new Point(10, 20), new Point(30, 40), new Point(50, 60))))); + assertThat(mapper.readValue(json, GeoJsonLineString.class)) + .isEqualTo(new GeoJsonMultiPoint(Arrays.asList(new Point(10, 20), new Point(30, 40), new Point(50, 60)))); } @Test // DATAMONGO-1181 @@ -78,10 +78,8 @@ public class GeoJsonModuleUnitTests { String json = "{ \"type\": \"MultiLineString\", \"coordinates\": [ [ [10.0, 20.0], [30.0, 40.0] ], [ [50.0, 60.0] , [70.0, 80.0] ] ]}"; - assertThat( - mapper.readValue(json, GeoJsonMultiLineString.class), - is(new GeoJsonMultiLineString(Arrays.asList(new Point(10, 20), new Point(30, 40)), Arrays.asList(new Point(50, - 60), new Point(70, 80))))); + assertThat(mapper.readValue(json, GeoJsonMultiLineString.class)).isEqualTo(new GeoJsonMultiLineString( + Arrays.asList(new Point(10, 20), new Point(30, 40)), Arrays.asList(new Point(50, 60), new Point(70, 80)))); } @Test // DATAMONGO-1181 @@ -89,10 +87,8 @@ public class GeoJsonModuleUnitTests { String json = "{ \"type\": \"Polygon\", \"coordinates\": [ [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ] ]}"; - assertThat( - mapper.readValue(json, GeoJsonPolygon.class), - is(new GeoJsonPolygon(Arrays.asList(new Point(100, 0), new Point(101, 0), new Point(101, 1), new Point(100, 1), - new Point(100, 0))))); + assertThat(mapper.readValue(json, GeoJsonPolygon.class)).isEqualTo(new GeoJsonPolygon( + Arrays.asList(new Point(100, 0), new Point(101, 0), new Point(101, 1), new Point(100, 1), new Point(100, 0)))); } @Test // DATAMONGO-1181 @@ -105,15 +101,13 @@ public class GeoJsonModuleUnitTests { + "[[100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]]]"// + "]}"; - assertThat( - mapper.readValue(json, GeoJsonMultiPolygon.class), - is(new GeoJsonMultiPolygon(Arrays.asList( - new GeoJsonPolygon(Arrays.asList(new Point(102, 2), new Point(103, 2), new Point(103, 3), - new Point(102, 3), new Point(102, 2))), - new GeoJsonPolygon(Arrays.asList(new Point(100, 0), new Point(101, 0), new Point(101, 1), - new Point(100, 1), new Point(100, 0))), - new GeoJsonPolygon(Arrays.asList(new Point(100.2, 0.2), new Point(100.8, 0.2), new Point(100.8, 0.8), - new Point(100.2, 0.8), new Point(100.2, 0.2))))))); + assertThat(mapper.readValue(json, GeoJsonMultiPolygon.class)).isEqualTo(new GeoJsonMultiPolygon(Arrays.asList( + new GeoJsonPolygon(Arrays.asList(new Point(102, 2), new Point(103, 2), new Point(103, 3), new Point(102, 3), + new Point(102, 2))), + new GeoJsonPolygon(Arrays.asList(new Point(100, 0), new Point(101, 0), new Point(101, 1), new Point(100, 1), + new Point(100, 0))), + new GeoJsonPolygon(Arrays.asList(new Point(100.2, 0.2), new Point(100.8, 0.2), new Point(100.8, 0.8), + new Point(100.2, 0.8), new Point(100.2, 0.2)))))); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoSpatial2DSphereTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoSpatial2DSphereTests.java index 0ce5b9e83..f58ef2ceb 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoSpatial2DSphereTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoSpatial2DSphereTests.java @@ -16,25 +16,25 @@ package org.springframework.data.mongodb.core.geo; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.query.Criteria.*; import static org.springframework.data.mongodb.core.query.Query.*; import java.util.List; import org.junit.Test; + import org.springframework.data.domain.Sort.Direction; import org.springframework.data.geo.GeoResults; import org.springframework.data.geo.Metric; import org.springframework.data.geo.Metrics; import org.springframework.data.geo.Point; -import org.springframework.data.mongodb.core.index.IndexOperations; import org.springframework.data.mongodb.core.Venue; import org.springframework.data.mongodb.core.index.GeoSpatialIndexType; import org.springframework.data.mongodb.core.index.GeospatialIndex; import org.springframework.data.mongodb.core.index.IndexField; import org.springframework.data.mongodb.core.index.IndexInfo; +import org.springframework.data.mongodb.core.index.IndexOperations; import org.springframework.data.mongodb.core.query.NearQuery; /** @@ -48,15 +48,15 @@ public class GeoSpatial2DSphereTests extends AbstractGeoSpatialTests { IndexOperations operations = template.indexOps(Venue.class); List indexInfo = operations.getIndexInfo(); - assertThat(indexInfo.size(), is(2)); + assertThat(indexInfo.size()).isEqualTo(2); List fields = indexInfo.get(0).getIndexFields(); - assertThat(fields.size(), is(1)); - assertThat(fields, hasItem(IndexField.create("_id", Direction.ASC))); + assertThat(fields.size()).isEqualTo(1); + assertThat(fields).contains(IndexField.create("_id", Direction.ASC)); fields = indexInfo.get(1).getIndexFields(); - assertThat(fields.size(), is(1)); - assertThat(fields, hasItem(IndexField.geo("location"))); + assertThat(fields.size()).isEqualTo(1); + assertThat(fields).contains(IndexField.geo("location")); } @Test // DATAMONGO-1110 @@ -66,15 +66,15 @@ public class GeoSpatial2DSphereTests extends AbstractGeoSpatialTests { GeoResults result = template.geoNear(geoNear, Venue.class); - assertThat(result.getContent().size(), is(not(0))); - assertThat(result.getAverageDistance().getMetric(), is((Metric) Metrics.KILOMETERS)); + assertThat(result.getContent().size()).isNotEqualTo(0); + assertThat(result.getAverageDistance().getMetric()).isEqualTo((Metric) Metrics.KILOMETERS); } @Test // DATAMONGO-1110 public void nearSphereWithMinDistance() { Point point = new Point(-73.99171, 40.738868); List venues = template.find(query(where("location").nearSphere(point).minDistance(0.01)), Venue.class); - assertThat(venues.size(), is(1)); + assertThat(venues.size()).isEqualTo(1); } @Override diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoSpatial2DTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoSpatial2DTests.java index 5f2858c89..74ce4af6c 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoSpatial2DTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/geo/GeoSpatial2DTests.java @@ -16,22 +16,22 @@ package org.springframework.data.mongodb.core.geo; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.query.Criteria.*; import static org.springframework.data.mongodb.core.query.Query.*; import java.util.List; import org.junit.Test; + import org.springframework.data.domain.Sort.Direction; import org.springframework.data.geo.Point; -import org.springframework.data.mongodb.core.index.IndexOperations; import org.springframework.data.mongodb.core.Venue; import org.springframework.data.mongodb.core.index.GeoSpatialIndexType; import org.springframework.data.mongodb.core.index.GeospatialIndex; import org.springframework.data.mongodb.core.index.IndexField; import org.springframework.data.mongodb.core.index.IndexInfo; +import org.springframework.data.mongodb.core.index.IndexOperations; /** * Modified from https://github.com/deftlabs/mongo-java-geospatial-example @@ -47,7 +47,7 @@ public class GeoSpatial2DTests extends AbstractGeoSpatialTests { public void nearPoint() { Point point = new Point(-73.99171, 40.738868); List venues = template.find(query(where("location").near(point).maxDistance(0.01)), Venue.class); - assertThat(venues.size(), is(7)); + assertThat(venues.size()).isEqualTo(7); } @Test // DATAMONGO-360 @@ -56,15 +56,15 @@ public class GeoSpatial2DTests extends AbstractGeoSpatialTests { IndexOperations operations = template.indexOps(Venue.class); List indexInfo = operations.getIndexInfo(); - assertThat(indexInfo.size(), is(2)); + assertThat(indexInfo.size()).isEqualTo(2); List fields = indexInfo.get(0).getIndexFields(); - assertThat(fields.size(), is(1)); - assertThat(fields, hasItem(IndexField.create("_id", Direction.ASC))); + assertThat(fields.size()).isEqualTo(1); + assertThat(fields).contains(IndexField.create("_id", Direction.ASC)); fields = indexInfo.get(1).getIndexFields(); - assertThat(fields.size(), is(1)); - assertThat(fields, hasItem(IndexField.geo("location"))); + assertThat(fields.size()).isEqualTo(1); + assertThat(fields).contains(IndexField.geo("location")); } @Override diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexCreatorIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexCreatorIntegrationTests.java index 7d6c1fc25..c1a61e543 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexCreatorIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexCreatorIntegrationTests.java @@ -15,14 +15,11 @@ */ package org.springframework.data.mongodb.core.index; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; -import java.net.UnknownHostException; import java.util.Arrays; import java.util.List; -import org.hamcrest.Matchers; import org.hamcrest.core.IsInstanceOf; import org.junit.ClassRule; import org.junit.Rule; @@ -30,6 +27,7 @@ import org.junit.Test; import org.junit.rules.ExpectedException; import org.junit.rules.RuleChain; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.dao.DataIntegrityViolationException; @@ -76,11 +74,11 @@ public class MongoPersistentEntityIndexCreatorIntegrationTests { public void createsIndexForConfiguredMappingContextOnly() { List indexInfo = templateOne.indexOps(SampleEntity.class).getIndexInfo(); - assertThat(indexInfo, hasSize(greaterThan(0))); - assertThat(indexInfo, Matchers. hasItem(hasProperty("name", is("prop")))); + assertThat(indexInfo).isNotEmpty(); + assertThat(indexInfo).extracting(IndexInfo::getName).contains("prop"); indexInfo = templateTwo.indexOps(SAMPLE_TYPE_COLLECTION_NAME).getIndexInfo(); - assertThat(indexInfo, hasSize(0)); + assertThat(indexInfo).hasSize(0); } @Test // DATAMONGO-1202 @@ -88,12 +86,12 @@ public class MongoPersistentEntityIndexCreatorIntegrationTests { List indexInfo = templateOne.indexOps(RecursiveConcreteType.class).getIndexInfo(); - assertThat(indexInfo, hasSize(greaterThan(0))); - assertThat(indexInfo, Matchers. hasItem(hasProperty("name", is("firstName")))); + assertThat(indexInfo).isNotEmpty(); + assertThat(indexInfo).extracting(IndexInfo::getName).contains("firstName"); } @Test // DATAMONGO-1125 - public void createIndexShouldThrowMeaningfulExceptionWhenIndexCreationFails() throws UnknownHostException { + public void createIndexShouldThrowMeaningfulExceptionWhenIndexCreationFails() { expectedException.expect(DataIntegrityViolationException.class); expectedException.expectMessage("collection 'datamongo-1125'"); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/index/PathUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/index/PathUnitTests.java index 9ad23161e..6ed88814b 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/index/PathUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/index/PathUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.index; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import org.junit.Before; @@ -25,6 +24,7 @@ import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexResolver.CycleGuard.Path; import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity; import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty; @@ -54,9 +54,9 @@ public class PathUnitTests { Path path = Path.of(foo).append(bar).append(bar); - assertThat(path.isCycle(), is(true)); - assertThat(path.toCyclePath(), is(equalTo("bar -> bar"))); - assertThat(path.toString(), is(equalTo("foo -> bar -> bar"))); + assertThat(path.isCycle()).isTrue(); + assertThat(path.toCyclePath()).isEqualTo("bar -> bar"); + assertThat(path.toString()).isEqualTo("foo -> bar -> bar"); } @Test // DATAMONGO-1782 @@ -67,9 +67,9 @@ public class PathUnitTests { Path path = Path.of(foo).append(bar); - assertThat(path.isCycle(), is(false)); - assertThat(path.toCyclePath(), is(equalTo(""))); - assertThat(path.toString(), is(equalTo("foo -> bar"))); + assertThat(path.isCycle()).isFalse(); + assertThat(path.toCyclePath()).isEqualTo(""); + assertThat(path.toString()).isEqualTo("foo -> bar"); } @Test // DATAMONGO-1782 @@ -79,7 +79,7 @@ public class PathUnitTests { MongoPersistentProperty bar = createPersistentPropertyMock(entityMock, "bar"); MongoPersistentProperty bar2 = createPersistentPropertyMock(mock(MongoPersistentEntity.class), "bar"); - assertThat(Path.of(foo).append(bar).append(bar2).isCycle(), is(false)); + assertThat(Path.of(foo).append(bar).append(bar2).isCycle()).isFalse(); } @SuppressWarnings({ "rawtypes", "unchecked" }) diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/BasicMongoPersistentPropertyUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/BasicMongoPersistentPropertyUnitTests.java index 10e981cce..d1189262f 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/BasicMongoPersistentPropertyUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/BasicMongoPersistentPropertyUnitTests.java @@ -15,9 +15,7 @@ */ package org.springframework.data.mongodb.core.mapping; -import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.assertThat; +import static org.assertj.core.api.Assertions.*; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; @@ -33,6 +31,7 @@ import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; + import org.springframework.core.annotation.AliasFor; import org.springframework.data.annotation.Id; import org.springframework.data.mapping.MappingException; @@ -66,22 +65,22 @@ public class BasicMongoPersistentPropertyUnitTests { public void usesAnnotatedFieldName() { Field field = ReflectionUtils.findField(Person.class, "firstname"); - assertThat(getPropertyFor(field).getFieldName(), is("foo")); + assertThat(getPropertyFor(field).getFieldName()).isEqualTo("foo"); } @Test public void returns_IdForIdProperty() { Field field = ReflectionUtils.findField(Person.class, "id"); MongoPersistentProperty property = getPropertyFor(field); - assertThat(property.isIdProperty(), is(true)); - assertThat(property.getFieldName(), is("_id")); + assertThat(property.isIdProperty()).isTrue(); + assertThat(property.getFieldName()).isEqualTo("_id"); } @Test public void returnsPropertyNameForUnannotatedProperties() { Field field = ReflectionUtils.findField(Person.class, "lastname"); - assertThat(getPropertyFor(field).getFieldName(), is("lastname")); + assertThat(getPropertyFor(field).getFieldName()).isEqualTo("lastname"); } @Test @@ -96,7 +95,7 @@ public class BasicMongoPersistentPropertyUnitTests { ClassTypeInformation.from(Throwable.class)); MongoPersistentProperty property = getPropertyFor(entity, "cause"); - assertThat(property.usePropertyAccess(), is(true)); + assertThat(property.usePropertyAccess()).isTrue(); } @Test // DATAMONGO-607 @@ -107,13 +106,13 @@ public class BasicMongoPersistentPropertyUnitTests { MongoPersistentProperty property = new BasicMongoPersistentProperty(Property.of(type, field), entity, SimpleTypeHolder.DEFAULT, UppercaseFieldNamingStrategy.INSTANCE); - assertThat(property.getFieldName(), is("LASTNAME")); + assertThat(property.getFieldName()).isEqualTo("LASTNAME"); field = ReflectionUtils.findField(Person.class, "firstname"); property = new BasicMongoPersistentProperty(Property.of(type, field), entity, SimpleTypeHolder.DEFAULT, UppercaseFieldNamingStrategy.INSTANCE); - assertThat(property.getFieldName(), is("foo")); + assertThat(property.getFieldName()).isEqualTo("foo"); } @Test // DATAMONGO-607 @@ -136,35 +135,35 @@ public class BasicMongoPersistentPropertyUnitTests { public void shouldDetectAnnotatedLanguagePropertyCorrectly() { MongoPersistentProperty property = getPropertyFor(DocumentWithLanguageProperty.class, "lang"); - assertThat(property.isLanguageProperty(), is(true)); + assertThat(property.isLanguageProperty()).isTrue(); } @Test // DATAMONGO-937 public void shouldDetectIplicitLanguagePropertyCorrectly() { MongoPersistentProperty property = getPropertyFor(DocumentWithImplicitLanguageProperty.class, "language"); - assertThat(property.isLanguageProperty(), is(true)); + assertThat(property.isLanguageProperty()).isTrue(); } @Test // DATAMONGO-976 public void shouldDetectTextScorePropertyCorrectly() { MongoPersistentProperty property = getPropertyFor(DocumentWithTextScoreProperty.class, "score"); - assertThat(property.isTextScoreProperty(), is(true)); + assertThat(property.isTextScoreProperty()).isTrue(); } @Test // DATAMONGO-976 public void shouldDetectTextScoreAsReadOnlyProperty() { MongoPersistentProperty property = getPropertyFor(DocumentWithTextScoreProperty.class, "score"); - assertThat(property.isWritable(), is(false)); + assertThat(property.isWritable()).isFalse(); } @Test // DATAMONGO-1050 public void shouldNotConsiderExplicitlyNameFieldAsIdProperty() { MongoPersistentProperty property = getPropertyFor(DocumentWithExplicitlyRenamedIdProperty.class, "id"); - assertThat(property.isIdProperty(), is(false)); + assertThat(property.isIdProperty()).isFalse(); } @Test // DATAMONGO-1050 @@ -172,22 +171,22 @@ public class BasicMongoPersistentPropertyUnitTests { MongoPersistentProperty property = getPropertyFor(DocumentWithExplicitlyRenamedIdPropertyHavingIdAnnotation.class, "id"); - assertThat(property.isIdProperty(), is(true)); + assertThat(property.isIdProperty()).isTrue(); } @Test // DATAMONGO-1373 public void shouldConsiderComposedAnnotationsForIdField() { MongoPersistentProperty property = getPropertyFor(DocumentWithComposedAnnotations.class, "myId"); - assertThat(property.isIdProperty(), is(true)); - assertThat(property.getFieldName(), is("_id")); + assertThat(property.isIdProperty()).isTrue(); + assertThat(property.getFieldName()).isEqualTo("_id"); } @Test // DATAMONGO-1373 public void shouldConsiderComposedAnnotationsForFields() { MongoPersistentProperty property = getPropertyFor(DocumentWithComposedAnnotations.class, "myField"); - assertThat(property.getFieldName(), is("myField")); + assertThat(property.getFieldName()).isEqualTo("myField"); } @Test // DATAMONGO-1737 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/GenericMappingTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/GenericMappingTests.java index 98780b0ab..a08823b67 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/GenericMappingTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/GenericMappingTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.mapping; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Collections; @@ -26,6 +25,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.core.convert.DbRefResolver; import org.springframework.data.mongodb.core.convert.MappingMongoConverter; import org.springframework.data.mongodb.core.convert.MongoConverter; @@ -64,12 +64,12 @@ public class GenericMappingTests { converter.write(wrapper, document); Object container = document.get("container"); - assertThat(container, is(notNullValue())); - assertTrue(container instanceof Document); + assertThat(container).isNotNull(); + assertThat(container instanceof Document).isTrue(); Object content = ((Document) container).get("content"); - assertTrue(content instanceof String); - assertThat((String) content, is("Foo!")); + assertThat(content instanceof String).isTrue(); + assertThat((String) content).isEqualTo("Foo!"); } @Test @@ -79,8 +79,8 @@ public class GenericMappingTests { Document container = new Document("container", content); StringWrapper result = converter.read(StringWrapper.class, container); - assertThat(result.container, is(notNullValue())); - assertThat(result.container.content, is("Foo!")); + assertThat(result.container).isNotNull(); + assertThat(result.container.content).isEqualTo("Foo!"); } static class StringWrapper extends Wrapper { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MappingTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MappingTests.java index 5cab63b3a..1fea7176e 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MappingTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MappingTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.mapping; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.query.Criteria.*; import static org.springframework.data.mongodb.core.query.Query.*; import static org.springframework.data.mongodb.core.query.Update.*; @@ -28,8 +27,10 @@ import java.util.Iterator; import java.util.List; import java.util.Map; +import org.bson.Document; import org.bson.types.ObjectId; import org.junit.Test; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessException; import org.springframework.dao.DuplicateKeyException; @@ -43,7 +44,6 @@ import org.springframework.data.mongodb.core.MongoOperations; import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.data.mongodb.core.query.Query; -import org.bson.Document; import com.mongodb.MongoException; import com.mongodb.client.MongoCollection; @@ -62,7 +62,7 @@ public class MappingTests extends AbstractIntegrationTests { GeneratedId genId = new GeneratedId("test"); template.insert(genId); - assertNotNull(genId.getId()); + assertThat(genId.getId()).isNotNull(); } @Test @@ -70,12 +70,12 @@ public class MappingTests extends AbstractIntegrationTests { PersonWithObjectId p = new PersonWithObjectId(12345, "Person", "Pojo"); template.insert(p); - assertNotNull(p.getId()); + assertThat(p.getId()).isNotNull(); List result = template.find(new Query(Criteria.where("ssn").is(12345)), PersonWithObjectId.class); - assertThat(result.size(), is(1)); - assertThat(result.get(0).getSsn(), is(12345)); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).getSsn()).isEqualTo(12345); } @Test @@ -86,24 +86,24 @@ public class MappingTests extends AbstractIntegrationTests { List result = template.find(new Query(Criteria.where("lastName").is(p.getLastName())), PersonCustomIdName.class); - assertThat(result.size(), is(1)); - assertThat(result.get(0).getFirstName(), is("Custom Id")); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).getFirstName()).isEqualTo("Custom Id"); PersonCustomIdName p2 = new PersonCustomIdName(654321, "Custom Id", "LastName"); template.insert(p2); List result2 = template.find(new Query(Criteria.where("lastName").is("LastName")), PersonCustomIdName.class); - assertThat(result2.size(), is(1)); - assertNotNull(result2.get(0).getLastName()); - assertThat(result2.get(0).getLastName(), is("LastName")); + assertThat(result2.size()).isEqualTo(1); + assertThat(result2.get(0).getLastName()).isNotNull(); + assertThat(result2.get(0).getLastName()).isEqualTo("LastName"); // Test "in" query List result3 = template.find(new Query(Criteria.where("lastName").in("LastName")), PersonCustomIdName.class); - assertThat(result3.size(), is(1)); - assertNotNull(result3.get(0).getLastName()); - assertThat(result3.get(0).getLastName(), is("LastName")); + assertThat(result3.size()).isEqualTo(1); + assertThat(result3.get(0).getLastName()).isNotNull(); + assertThat(result3.get(0).getLastName()).isEqualTo("LastName"); } @Test @@ -119,13 +119,13 @@ public class MappingTests extends AbstractIntegrationTests { p.setAccounts(accounts); template.insert(p); - assertNotNull(p.getId()); + assertThat(p.getId()).isNotNull(); List result = template.find(new Query(Criteria.where("ssn").is(1234567)), PersonMapProperty.class); - assertThat(result.size(), is(1)); - assertThat(result.get(0).getAccounts().size(), is(2)); - assertThat(result.get(0).getAccounts().get("checking").getBalance(), is(1000.0f)); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).getAccounts().size()).isEqualTo(2); + assertThat(result.get(0).getAccounts().get("checking").getBalance()).isEqualTo(1000.0f); } @Test @@ -156,12 +156,12 @@ public class MappingTests extends AbstractIntegrationTests { accounts.add(newAcct); template.save(p, "person"); - assertNotNull(p.getId()); + assertThat(p.getId()).isNotNull(); List result = template.find(new Query(Criteria.where("ssn").is(123456789)), Person.class); - assertThat(result.size(), is(1)); - assertThat(result.get(0).getAddress().getCountry(), is("USA")); - assertThat(result.get(0).getAccounts(), notNullValue()); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).getAddress().getCountry()).isEqualTo("USA"); + assertThat(result.get(0).getAccounts()).isNotNull(); } @Test(expected = DuplicateKeyException.class) @@ -191,8 +191,8 @@ public class MappingTests extends AbstractIntegrationTests { PersonCustomCollection1.class, "person1"); List p2Results = template.find(new Query(Criteria.where("ssn").is(66666)), PersonCustomCollection2.class, "person2"); - assertThat(p1Results.size(), is(1)); - assertThat(p2Results.size(), is(1)); + assertThat(p1Results.size()).isEqualTo(1); + assertThat(p2Results.size()).isEqualTo(1); } @Test @@ -201,7 +201,7 @@ public class MappingTests extends AbstractIntegrationTests { template.insert(loc); List result = template.find(new Query(Criteria.where("_id").is(loc.getId())), Location.class, "places"); - assertThat(result.size(), is(1)); + assertThat(result.size()).isEqualTo(1); } @Test @@ -209,7 +209,7 @@ public class MappingTests extends AbstractIntegrationTests { CustomCollectionWithIndex ccwi = new CustomCollectionWithIndex("test"); template.insert(ccwi); - assertTrue(template.execute("foobar", new CollectionCallback() { + assertThat(template.execute("foobar", new CollectionCallback() { public Boolean doInCollection(MongoCollection collection) throws MongoException, DataAccessException { List indexes = new ArrayList(); @@ -223,12 +223,12 @@ public class MappingTests extends AbstractIntegrationTests { } return false; } - })); + })).isTrue(); DetectedCollectionWithIndex dcwi = new DetectedCollectionWithIndex("test"); template.insert(dcwi); - assertTrue(template.execute(MongoCollectionUtils.getPreferredCollectionName(DetectedCollectionWithIndex.class), + assertThat(template.execute(MongoCollectionUtils.getPreferredCollectionName(DetectedCollectionWithIndex.class), new CollectionCallback() { public Boolean doInCollection(MongoCollection collection) throws MongoException, DataAccessException { @@ -244,7 +244,7 @@ public class MappingTests extends AbstractIntegrationTests { } return false; } - })); + })).isTrue(); } @Test @@ -256,9 +256,9 @@ public class MappingTests extends AbstractIntegrationTests { template.insert(p); List result = template.find(new Query(Criteria.where("ssn").is(123)), PersonMultiDimArrays.class); - assertThat(result.size(), is(1)); + assertThat(result.size()).isEqualTo(1); - assertThat(result.get(0).getGrid().length, is(3)); + assertThat(result.get(0).getGrid().length).isEqualTo(3); } @Test @@ -276,9 +276,9 @@ public class MappingTests extends AbstractIntegrationTests { List result = template.find(new Query(Criteria.where("ssn").is(321)), PersonMultiCollection.class); - assertThat(result.size(), is(1)); + assertThat(result.size()).isEqualTo(1); - assertThat(result.get(0).getGrid().size(), is(1)); + assertThat(result.get(0).getGrid().size()).isEqualTo(1); } @Test @@ -291,8 +291,8 @@ public class MappingTests extends AbstractIntegrationTests { template.insert(p); List result = template.find(new Query(Criteria.where("ssn").is(4321)), PersonWithDbRef.class); - assertThat(result.size(), is(1)); - assertThat(result.get(0).getHome().getLocation(), is(pos)); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(0).getHome().getLocation()).isEqualTo(pos); } @Test @@ -300,7 +300,7 @@ public class MappingTests extends AbstractIntegrationTests { PersonNullProperties p = new PersonNullProperties(); template.insert(p); - assertNotNull(p.getId()); + assertThat(p.getId()).isNotNull(); } @Test @@ -319,7 +319,7 @@ public class MappingTests extends AbstractIntegrationTests { template.updateFirst(query(where("ssn").is(1111)), update("address", addr), Person.class); Person p2 = template.findOne(query(where("ssn").is(1111)), Person.class); - assertThat(p2.getAddress().getCity(), is("New Town")); + assertThat(p2.getAddress().getCity()).isEqualTo("New Town"); } @Test @@ -332,19 +332,19 @@ public class MappingTests extends AbstractIntegrationTests { addr.setCountry("USA"); Person p2 = template.findOne(query(where("ssn").is(1111)), Person.class); - assertNull(p2); + assertThat(p2).isNull(); template.upsert(query(where("ssn").is(1111).and("firstName").is("Query").and("lastName").is("Update")), update("address", addr), Person.class); p2 = template.findOne(query(where("ssn").is(1111)), Person.class); - assertThat(p2.getAddress().getCity(), is("Anytown")); + assertThat(p2.getAddress().getCity()).isEqualTo("Anytown"); template.dropCollection(Person.class); template.upsert(query(where("ssn").is(1111).and("firstName").is("Query").and("lastName").is("Update")), update("address", addr), "person"); p2 = template.findOne(query(where("ssn").is(1111)), Person.class); - assertThat(p2.getAddress().getCity(), is("Anytown")); + assertThat(p2.getAddress().getCity()).isEqualTo("Anytown"); } @@ -358,9 +358,9 @@ public class MappingTests extends AbstractIntegrationTests { List results = template .find(new Query(new Criteria().orOperator(where("ssn").is(1), where("ssn").is(2))), PersonWithObjectId.class); - assertNotNull(results); - assertThat(results.size(), is(2)); - assertThat(results.get(1).getSsn(), is(2)); + assertThat(results).isNotNull(); + assertThat(results.size()).isEqualTo(2); + assertThat(results.get(1).getSsn()).isEqualTo(2); } @Test @@ -371,7 +371,7 @@ public class MappingTests extends AbstractIntegrationTests { template.save(p); PrimitiveId p2 = template.findOne(query(where("id").is(1)), PrimitiveId.class); - assertNotNull(p2); + assertThat(p2).isNotNull(); } @Test @@ -381,13 +381,13 @@ public class MappingTests extends AbstractIntegrationTests { template.updateFirst(query(where("id").is(1)), update("text", "New Text"), PersonPojoIntId.class); PersonPojoIntId p2 = template.findOne(query(where("id").is(1)), PersonPojoIntId.class); - assertEquals("New Text", p2.getText()); + assertThat(p2.getText()).isEqualTo("New Text"); p.setText("Different Text"); template.save(p); PersonPojoIntId p3 = template.findOne(query(where("id").is(1)), PersonPojoIntId.class); - assertEquals("Different Text", p3.getText()); + assertThat(p3.getText()).isEqualTo("Different Text"); } @@ -398,13 +398,13 @@ public class MappingTests extends AbstractIntegrationTests { template.updateFirst(query(where("id").is(1)), update("text", "New Text"), PersonPojoLongId.class); PersonPojoLongId p2 = template.findOne(query(where("id").is(1)), PersonPojoLongId.class); - assertEquals("New Text", p2.getText()); + assertThat(p2.getText()).isEqualTo("New Text"); p.setText("Different Text"); template.save(p); PersonPojoLongId p3 = template.findOne(query(where("id").is(1)), PersonPojoLongId.class); - assertEquals("Different Text", p3.getText()); + assertThat(p3.getText()).isEqualTo("Different Text"); } @@ -416,13 +416,13 @@ public class MappingTests extends AbstractIntegrationTests { template.updateFirst(query(where("id").is("1")), update("text", "New Text"), PersonPojoStringId.class); PersonPojoStringId p2 = template.findOne(query(where("id").is("1")), PersonPojoStringId.class); - assertEquals("New Text", p2.getText()); + assertThat(p2.getText()).isEqualTo("New Text"); p.setText("Different Text"); template.save(p); PersonPojoStringId p3 = template.findOne(query(where("id").is("1")), PersonPojoStringId.class); - assertEquals("Different Text", p3.getText()); + assertThat(p3.getText()).isEqualTo("Different Text"); PersonPojoStringId p4 = new PersonPojoStringId("2", "Text-2"); template.insert(p4); @@ -430,7 +430,7 @@ public class MappingTests extends AbstractIntegrationTests { Query q = query(where("id").in("1", "2")); q.with(Sort.by(Direction.ASC, "id")); List people = template.find(q, PersonPojoStringId.class); - assertEquals(2, people.size()); + assertThat(people.size()).isEqualTo(2); } @@ -444,9 +444,9 @@ public class MappingTests extends AbstractIntegrationTests { Query q = query(where("ssn").is(21)); PersonWithLongDBRef p2 = template.findOne(q, PersonWithLongDBRef.class); - assertNotNull(p2); - assertNotNull(p2.getPersonPojoLongId()); - assertEquals(12L, p2.getPersonPojoLongId().getId()); + assertThat(p2).isNotNull(); + assertThat(p2.getPersonPojoLongId()).isNotNull(); + assertThat(p2.getPersonPojoLongId().getId()).isEqualTo(12L); } @Test // DATADOC-275 @@ -467,9 +467,9 @@ public class MappingTests extends AbstractIntegrationTests { template.insert(container); Container result = template.findOne(query(where("id").is(container.id)), Container.class); - assertThat(result.item.id, is(item.id)); - assertThat(result.items.size(), is(1)); - assertThat(result.items.get(0).id, is(items.id)); + assertThat(result.item.id).isEqualTo(item.id); + assertThat(result.items.size()).isEqualTo(1); + assertThat(result.items.get(0).id).isEqualTo(items.id); } @Test // DATAMONGO-805 @@ -490,8 +490,8 @@ public class MappingTests extends AbstractIntegrationTests { query.fields().exclude("item"); Container result = template.findOne(query, Container.class); - assertThat(result, is(notNullValue())); - assertThat(result.item, is(nullValue())); + assertThat(result).isNotNull(); + assertThat(result.item).isNull(); } @Test // DATAMONGO-805 @@ -512,9 +512,9 @@ public class MappingTests extends AbstractIntegrationTests { Query query = new Query(Criteria.where("id").is("foo")); Container result = template.findOne(query, Container.class); - assertThat(result, is(notNullValue())); - assertThat(result.item, is(notNullValue())); - assertThat(result.item.value, is("bar")); + assertThat(result).isNotNull(); + assertThat(result.item).isNotNull(); + assertThat(result.item.value).isEqualTo("bar"); } static class Container { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MongoPersistentPropertyComparatorUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MongoPersistentPropertyComparatorUnitTests.java index 73b52f376..cdc5fa9bd 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MongoPersistentPropertyComparatorUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MongoPersistentPropertyComparatorUnitTests.java @@ -1,7 +1,7 @@ package org.springframework.data.mongodb.core.mapping; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; +import static org.mockito.Mockito.*; import java.util.Arrays; import java.util.Collections; @@ -11,14 +11,12 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; -import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty; -import org.springframework.data.mongodb.core.mapping.BasicMongoPersistentEntity.MongoPersistentPropertyComparator; -import static org.mockito.Mockito.*; +import org.springframework.data.mongodb.core.mapping.BasicMongoPersistentEntity.MongoPersistentPropertyComparator; /** * Unit tests for {@link MongoPersistentPropertyComparator}. - * + * * @author Oliver Gierke */ @RunWith(MockitoJUnitRunner.class) @@ -43,8 +41,8 @@ public class MongoPersistentPropertyComparatorUnitTests { List properties = Arrays.asList(firstName, lastName, ssn); Collections.sort(properties, MongoPersistentPropertyComparator.INSTANCE); - assertThat(properties.get(0), is(ssn)); - assertThat(properties.get(1), is(firstName)); - assertThat(properties.get(2), is(lastName)); + assertThat(properties.get(0)).isEqualTo(ssn); + assertThat(properties.get(1)).isEqualTo(firstName); + assertThat(properties.get(2)).isEqualTo(lastName); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AbstractMongoEventListenerUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AbstractMongoEventListenerUnitTests.java index 53b8d0904..f52acbc5b 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AbstractMongoEventListenerUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AbstractMongoEventListenerUnitTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.core.mapping.event; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; + import org.springframework.context.support.AbstractApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.data.mongodb.core.mapping.Account; @@ -40,7 +40,7 @@ public class AbstractMongoEventListenerUnitTests { MongoMappingEvent event = new BeforeConvertEvent(new Person("Dave", "Matthews"), "collection-1"); SamplePersonEventListener listener = new SamplePersonEventListener(); listener.onApplicationEvent(event); - assertThat(listener.invokedOnBeforeConvert, is(true)); + assertThat(listener.invokedOnBeforeConvert).isTrue(); } @Test @@ -53,11 +53,11 @@ public class AbstractMongoEventListenerUnitTests { context.addApplicationListener(listener); context.publishEvent(new BeforeConvertEvent(new Person("Dave", "Matthews"), "collection-1")); - assertThat(listener.invokedOnBeforeConvert, is(true)); + assertThat(listener.invokedOnBeforeConvert).isTrue(); listener.invokedOnBeforeConvert = false; context.publishEvent(new BeforeConvertEvent("Test", "collection-1")); - assertThat(listener.invokedOnBeforeConvert, is(false)); + assertThat(listener.invokedOnBeforeConvert).isFalse(); context.close(); } @@ -67,7 +67,7 @@ public class AbstractMongoEventListenerUnitTests { SamplePersonEventListener listener = new SamplePersonEventListener(); listener.onApplicationEvent(new AfterLoadEvent(new Document(), Person.class, "collection-1")); - assertThat(listener.invokedOnAfterLoad, is(true)); + assertThat(listener.invokedOnAfterLoad).isTrue(); } @Test // DATAMONGO-289 @@ -78,8 +78,8 @@ public class AbstractMongoEventListenerUnitTests { personListener.onApplicationEvent(new AfterLoadEvent(new Document(), Person.class, "collection-1")); accountListener.onApplicationEvent(new AfterLoadEvent(new Document(), Person.class, "collection-1")); - assertThat(personListener.invokedOnAfterLoad, is(true)); - assertThat(accountListener.invokedOnAfterLoad, is(false)); + assertThat(personListener.invokedOnAfterLoad).isTrue(); + assertThat(accountListener.invokedOnAfterLoad).isFalse(); } @Test // DATAMONGO-289 @@ -90,8 +90,8 @@ public class AbstractMongoEventListenerUnitTests { personListener.onApplicationEvent(new AfterLoadEvent(new Document(), Person.class, "collection-1")); contactListener.onApplicationEvent(new AfterLoadEvent(new Document(), Person.class, "collection-1")); - assertThat(personListener.invokedOnAfterLoad, is(true)); - assertThat(contactListener.invokedOnAfterLoad, is(true)); + assertThat(personListener.invokedOnAfterLoad).isTrue(); + assertThat(contactListener.invokedOnAfterLoad).isTrue(); } @Test // DATAMONGO-289 @@ -102,8 +102,8 @@ public class AbstractMongoEventListenerUnitTests { personListener.onApplicationEvent(new AfterLoadEvent(new Document(), Contact.class, "collection-1")); contactListener.onApplicationEvent(new AfterLoadEvent(new Document(), Contact.class, "collection-1")); - assertThat(personListener.invokedOnAfterLoad, is(false)); - assertThat(contactListener.invokedOnAfterLoad, is(true)); + assertThat(personListener.invokedOnAfterLoad).isFalse(); + assertThat(contactListener.invokedOnAfterLoad).isTrue(); } @Test // DATAMONGO-333 @@ -121,7 +121,7 @@ public class AbstractMongoEventListenerUnitTests { SampleContactEventListener listener = new SampleContactEventListener(); listener.onApplicationEvent(event); - assertThat(listener.invokedOnBeforeDelete, is(true)); + assertThat(listener.invokedOnBeforeDelete).isTrue(); } @Test // DATAMONGO-545 @@ -131,7 +131,7 @@ public class AbstractMongoEventListenerUnitTests { SamplePersonEventListener listener = new SamplePersonEventListener(); listener.onApplicationEvent(event); - assertThat(listener.invokedOnBeforeDelete, is(true)); + assertThat(listener.invokedOnBeforeDelete).isTrue(); } @Test // DATAMONGO-545 @@ -141,7 +141,7 @@ public class AbstractMongoEventListenerUnitTests { SamplePersonEventListener listener = new SamplePersonEventListener(); listener.onApplicationEvent(event); - assertThat(listener.invokedOnBeforeDelete, is(false)); + assertThat(listener.invokedOnBeforeDelete).isFalse(); } @Test // DATAMONGO-545 @@ -151,7 +151,7 @@ public class AbstractMongoEventListenerUnitTests { SamplePersonEventListener listener = new SamplePersonEventListener(); listener.onApplicationEvent(event); - assertThat(listener.invokedOnBeforeDelete, is(false)); + assertThat(listener.invokedOnBeforeDelete).isFalse(); } class SamplePersonEventListener extends AbstractMongoEventListener { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/ApplicationContextEventTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/ApplicationContextEventTests.java index b5b586894..f489e18f4 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/ApplicationContextEventTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/ApplicationContextEventTests.java @@ -30,10 +30,10 @@ import java.util.Map; import org.junit.After; import org.junit.AfterClass; -import org.junit.Assert; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; + import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.data.annotation.Id; @@ -132,8 +132,8 @@ public class ApplicationContextEventTests { assertThat(listener.onBeforeSaveEvents.get(0).getCollectionName()).isEqualTo(COLLECTION_NAME); assertThat(listener.onAfterSaveEvents.get(0).getCollectionName()).isEqualTo(COLLECTION_NAME); - Assert.assertTrue(personBeforeSaveListener.seenEvents.get(0) instanceof BeforeSaveEvent); - Assert.assertTrue(afterSaveListener.seenEvents.get(0) instanceof AfterSaveEvent); + assertThat(personBeforeSaveListener.seenEvents.get(0) instanceof BeforeSaveEvent).isTrue(); + assertThat(afterSaveListener.seenEvents.get(0) instanceof AfterSaveEvent).isTrue(); BeforeSaveEvent beforeSaveEvent = (BeforeSaveEvent) personBeforeSaveListener.seenEvents .get(0); @@ -143,7 +143,7 @@ public class ApplicationContextEventTests { comparePersonAndDocument(p, p2, document); AfterSaveEvent afterSaveEvent = (AfterSaveEvent) afterSaveListener.seenEvents.get(0); - Assert.assertTrue(afterSaveEvent.getSource() instanceof PersonPojoStringId); + assertThat(afterSaveEvent.getSource() instanceof PersonPojoStringId).isTrue(); p2 = (PersonPojoStringId) afterSaveEvent.getSource(); document = beforeSaveEvent.getDocument(); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AuditingEntityCallbackUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AuditingEntityCallbackUnitTests.java index 5703e95bd..1b77d6fab 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AuditingEntityCallbackUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AuditingEntityCallbackUnitTests.java @@ -15,11 +15,8 @@ */ package org.springframework.data.mongodb.core.mapping.event; -import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.assertThat; +import static org.assertj.core.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; -import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.*; import lombok.AllArgsConstructor; @@ -98,8 +95,8 @@ public class AuditingEntityCallbackUnitTests { @Test // DATAMONGO-2261 public void hasExplicitOrder() { - assertThat(callback, is(instanceOf(Ordered.class))); - assertThat(callback.getOrder(), is(100)); + assertThat(callback).isInstanceOf(Ordered.class); + assertThat(callback.getOrder()).isEqualTo(100); } @Test // DATAMONGO-2261 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AuditingEventListenerUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AuditingEventListenerUnitTests.java index a29164bda..87ce43ada 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AuditingEventListenerUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/AuditingEventListenerUnitTests.java @@ -15,11 +15,8 @@ */ package org.springframework.data.mongodb.core.mapping.event; -import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.assertThat; +import static org.assertj.core.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; -import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.*; import lombok.AllArgsConstructor; @@ -35,6 +32,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.AdditionalAnswers; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.core.Ordered; import org.springframework.data.annotation.CreatedDate; import org.springframework.data.annotation.Id; @@ -98,8 +96,8 @@ public class AuditingEventListenerUnitTests { @Test public void hasExplicitOrder() { - assertThat(listener, is(instanceOf(Ordered.class))); - assertThat(listener.getOrder(), is(100)); + assertThat(listener).isInstanceOf(Ordered.class); + assertThat(listener.getOrder()).isEqualTo(100); } @Test // DATAMONGO-1992 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/LoggingEventListenerTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/LoggingEventListenerTests.java index f938f1dd1..7c08e3858 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/LoggingEventListenerTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/LoggingEventListenerTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.mapping.event; -import static org.hamcrest.core.StringStartsWith.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import ch.qos.logback.classic.Level; import ch.qos.logback.classic.spi.ILoggingEvent; @@ -78,7 +77,7 @@ public class LoggingEventListenerTests { listener.onAfterConvert(new AfterConvertEvent(new Document("foo", new Foo()), this, "collection")); - assertThat(appender.list.get(0).getFormattedMessage(), startsWith("onAfterConvert: { \"foo\"")); + assertThat(appender.list.get(0).getFormattedMessage()).startsWith("onAfterConvert: { \"foo\""); } @Test // DATAMONGO-1645 @@ -86,8 +85,8 @@ public class LoggingEventListenerTests { listener.onBeforeSave(new BeforeSaveEvent(new Foo(), new Document("foo", new Foo()), "collection")); - assertThat(appender.list.get(0).getFormattedMessage(), - startsWith("onBeforeSave: org.springframework.data.mongodb.core.")); + assertThat(appender.list.get(0).getFormattedMessage()) + .startsWith("onBeforeSave: org.springframework.data.mongodb.core."); } @Test // DATAMONGO-1645 @@ -95,8 +94,8 @@ public class LoggingEventListenerTests { listener.onAfterSave(new AfterSaveEvent(new Foo(), new Document("foo", new Foo()), "collection")); - assertThat(appender.list.get(0).getFormattedMessage(), - startsWith("onAfterSave: org.springframework.data.mongodb.core.")); + assertThat(appender.list.get(0).getFormattedMessage()) + .startsWith("onAfterSave: org.springframework.data.mongodb.core."); } @Test // DATAMONGO-1645 @@ -104,7 +103,7 @@ public class LoggingEventListenerTests { listener.onBeforeDelete(new BeforeDeleteEvent(new Document("foo", new Foo()), Object.class, "collection")); - assertThat(appender.list.get(0).getFormattedMessage(), startsWith("onBeforeDelete: { \"foo\"")); + assertThat(appender.list.get(0).getFormattedMessage()).startsWith("onBeforeDelete: { \"foo\""); } @Test // DATAMONGO-1645 @@ -112,7 +111,7 @@ public class LoggingEventListenerTests { listener.onAfterDelete(new AfterDeleteEvent(new Document("foo", new Foo()), Object.class, "collection")); - assertThat(appender.list.get(0).getFormattedMessage(), startsWith("onAfterDelete: { \"foo\"")); + assertThat(appender.list.get(0).getFormattedMessage()).startsWith("onAfterDelete: { \"foo\""); } static class Foo { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/ValidatingMongoEventListenerTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/ValidatingMongoEventListenerTests.java index d2def82fd..ebaaf7d07 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/ValidatingMongoEventListenerTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/event/ValidatingMongoEventListenerTests.java @@ -15,14 +15,14 @@ */ package org.springframework.data.mongodb.core.mapping.event; -import static org.hamcrest.core.IsEqual.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import javax.validation.ConstraintViolationException; import org.junit.ClassRule; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.test.util.MongoVersionRule; @@ -50,12 +50,10 @@ public class ValidatingMongoEventListenerTests { User user = new User("john", 17); - try { - mongoTemplate.save(user); - fail(); - } catch (ConstraintViolationException e) { - assertThat(e.getConstraintViolations().size(), equalTo(2)); - } + assertThatExceptionOfType(ConstraintViolationException.class).isThrownBy(() -> mongoTemplate.save(user)) + .satisfies(e -> { + assertThat(e.getConstraintViolations()).hasSize(2); + }); } @Test diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/GroupByTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/GroupByTests.java index 038a3245e..fb09d4547 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/GroupByTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/GroupByTests.java @@ -15,18 +15,18 @@ */ package org.springframework.data.mongodb.core.mapreduce; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.data.Offset.offset; import static org.springframework.data.mongodb.core.mapreduce.GroupBy.*; import static org.springframework.data.mongodb.core.query.Criteria.*; import org.bson.Document; import org.junit.After; -import org.junit.Assert; import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.test.util.MongoVersionRule; @@ -71,7 +71,7 @@ public class GroupByTests { Document gc = new GroupBy("a").getGroupByObject(); - assertThat(gc, is(Document.parse("{ \"key\" : { \"a\" : 1} , \"$reduce\" : null , \"initial\" : null }"))); + assertThat(gc).isEqualTo(Document.parse("{ \"key\" : { \"a\" : 1} , \"$reduce\" : null , \"initial\" : null }")); } @Test @@ -79,8 +79,8 @@ public class GroupByTests { Document gc = GroupBy.key("a", "b").getGroupByObject(); - assertThat(gc, - is(Document.parse("{ \"key\" : { \"a\" : 1 , \"b\" : 1} , \"$reduce\" : null , \"initial\" : null }"))); + assertThat(gc).isEqualTo( + Document.parse("{ \"key\" : { \"a\" : 1 , \"b\" : 1} , \"$reduce\" : null , \"initial\" : null }")); } @Test @@ -88,8 +88,8 @@ public class GroupByTests { Document gc = GroupBy.keyFunction("classpath:keyFunction.js").getGroupByObject(); - assertThat(gc, is( - Document.parse("{ \"$keyf\" : \"classpath:keyFunction.js\" , \"$reduce\" : null , \"initial\" : null }"))); + assertThat(gc).isEqualTo( + Document.parse("{ \"$keyf\" : \"classpath:keyFunction.js\" , \"$reduce\" : null , \"initial\" : null }")); } @Test @@ -145,19 +145,19 @@ public class GroupByTests { int numResults = 0; for (XObject xObject : results) { if (xObject.getX() == 1) { - Assert.assertEquals(2, xObject.getCount(), 0.001); + assertThat(xObject.getCount()).isCloseTo(2, offset(0.001f)); } if (xObject.getX() == 2) { - Assert.assertEquals(1, xObject.getCount(), 0.001); + assertThat(xObject.getCount()).isCloseTo(1, offset(0.001f)); } if (xObject.getX() == 3) { - Assert.assertEquals(3, xObject.getCount(), 0.001); + assertThat(xObject.getCount()).isCloseTo(3, offset(0.001f)); } numResults++; } - assertThat(numResults, is(3)); - assertThat(results.getKeys(), is(3)); - assertEquals(6, results.getCount(), 0.001); + assertThat(numResults).isEqualTo(3); + assertThat(results.getKeys()).isEqualTo(3); + assertThat(results.getCount()).isCloseTo(6, offset(0.001)); } private void createGroupByData() { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceCountsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceCountsUnitTests.java index 63eb9aeeb..76a6ada2c 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceCountsUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceCountsUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.mapreduce; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; @@ -33,9 +32,9 @@ public class MapReduceCountsUnitTests { MapReduceCounts left = new MapReduceCounts(1L, 1L, 1L); MapReduceCounts right = new MapReduceCounts(1L, 1L, 1L); - assertThat(left, is(right)); - assertThat(right, is(left)); - assertThat(left.hashCode(), is(right.hashCode())); + assertThat(left).isEqualTo(right); + assertThat(right).isEqualTo(left); + assertThat(left.hashCode()).isEqualTo(right.hashCode()); } @Test // DATACMNS-378 @@ -44,8 +43,8 @@ public class MapReduceCountsUnitTests { MapReduceCounts left = new MapReduceCounts(1L, 1L, 1L); MapReduceCounts right = new MapReduceCounts(1L, 2L, 1L); - assertThat(left, is(not(right))); - assertThat(right, is(not(left))); - assertThat(left.hashCode(), is(not(right.hashCode()))); + assertThat(left).isNotEqualTo(right); + assertThat(right).isNotEqualTo(left); + assertThat(left.hashCode()).isNotEqualTo(right.hashCode()); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceOptionsTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceOptionsTests.java index 79c80d694..c873fd45c 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceOptionsTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceOptionsTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.mapreduce; -import static org.junit.Assert.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import org.junit.Test; @@ -38,11 +37,11 @@ public class MapReduceOptionsTests { MapReduceOptions options = new MapReduceOptions(); options.limit(10); - assertThat(options.getOptionsObject(), isBsonObject().containing("limit", 10)); + assertThat(options.getOptionsObject()).containsEntry("limit", 10); } @Test // DATAMONGO-1334 public void limitShouldNotBePresentInDocumentWhenNotSet() { - assertThat(new MapReduceOptions().getOptionsObject(), isBsonObject().notContaining("limit")); + assertThat(new MapReduceOptions().getOptionsObject()).doesNotContainKey("limit"); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceResultsUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceResultsUnitTests.java index 69acd7f26..99ee2faa3 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceResultsUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapreduce/MapReduceResultsUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.mapreduce; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Collections; @@ -36,7 +35,7 @@ public class MapReduceResultsUnitTests { Document rawResult = new Document("result", "FOO"); MapReduceResults results = new MapReduceResults(Collections.emptyList(), rawResult); - assertThat(results.getOutputCollection(), is("FOO")); + assertThat(results.getOutputCollection()).isEqualTo("FOO"); } @Test // DATAMONGO-428 @@ -45,7 +44,7 @@ public class MapReduceResultsUnitTests { Document rawResult = new Document("result", new Document("collection", "FOO")); MapReduceResults results = new MapReduceResults(Collections.emptyList(), rawResult); - assertThat(results.getOutputCollection(), is("FOO")); + assertThat(results.getOutputCollection()).isEqualTo("FOO"); } @Test // DATAMONGO-378 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/BasicQueryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/BasicQueryUnitTests.java index 95d766b08..f9f796916 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/BasicQueryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/BasicQueryUnitTests.java @@ -15,16 +15,15 @@ */ package org.springframework.data.mongodb.core.query; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.query.Criteria.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; import nl.jqno.equalsverifier.EqualsVerifier; import nl.jqno.equalsverifier.Warning; import org.bson.Document; import org.junit.Test; + import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort.Direction; @@ -41,7 +40,7 @@ public class BasicQueryUnitTests { public void createsQueryFromPlainJson() { Query q = new BasicQuery("{ \"name\" : \"Thomas\"}"); Document reference = new Document("name", "Thomas"); - assertThat(q.getQueryObject(), is(reference)); + assertThat(q.getQueryObject()).isEqualTo(reference); } @Test @@ -49,7 +48,7 @@ public class BasicQueryUnitTests { Query q = new BasicQuery("{ \"name\" : \"Thomas\"}").addCriteria(where("age").lt(80)); Document reference = new Document("name", "Thomas"); reference.put("age", new Document("$lt", 80)); - assertThat(q.getQueryObject(), is(reference)); + assertThat(q.getQueryObject()).isEqualTo(reference); } @Test @@ -61,7 +60,7 @@ public class BasicQueryUnitTests { Document sortReference = new Document("name", -1); sortReference.put("lastname", 1); - assertThat(query.getSortObject(), is(sortReference)); + assertThat(query.getSortObject()).isEqualTo(sortReference); } @Test // DATAMONGO-1093 @@ -91,9 +90,9 @@ public class BasicQueryUnitTests { BasicQuery query2 = new BasicQuery(qry, fields); query2.setSortObject(new Document("name", -1)); - assertThat(query1, is(equalTo(query1))); - assertThat(query1, is(equalTo(query2))); - assertThat(query1.hashCode(), is(query2.hashCode())); + assertThat(query1).isEqualTo(query1); + assertThat(query1).isEqualTo(query2); + assertThat(query1.hashCode()).isEqualTo(query2.hashCode()); } @Test // DATAMONGO-1093 @@ -108,8 +107,8 @@ public class BasicQueryUnitTests { BasicQuery query2 = new BasicQuery(qry, fields); query2.setSortObject(new Document("name", 1)); - assertThat(query1, is(not(equalTo(query2)))); - assertThat(query1.hashCode(), is(not(query2.hashCode()))); + assertThat(query1).isNotEqualTo(query2); + assertThat(query1.hashCode()).isNotEqualTo(query2.hashCode()); } @Test // DATAMONGO-1093 @@ -124,8 +123,8 @@ public class BasicQueryUnitTests { BasicQuery query2 = new BasicQuery(qry, fields); query2.getMeta().setComment("bar"); - assertThat(query1, is(not(equalTo(query2)))); - assertThat(query1.hashCode(), is(not(query2.hashCode()))); + assertThat(query1).isNotEqualTo(query2); + assertThat(query1.hashCode()).isNotEqualTo(query2.hashCode()); } @Test // DATAMONGO-1387 @@ -136,7 +135,7 @@ public class BasicQueryUnitTests { BasicQuery query1 = new BasicQuery(qry, fields); - assertThat(query1.getFieldsObject(), isBsonObject().containing("name").containing("age")); + assertThat(query1.getFieldsObject()).containsKeys("name", "age"); } @Test // DATAMONGO-1387 @@ -147,7 +146,7 @@ public class BasicQueryUnitTests { BasicQuery query1 = new BasicQuery(qry); query1.fields().include("name"); - assertThat(query1.getFieldsObject(), isBsonObject().containing("name")); + assertThat(query1.getFieldsObject()).containsKey("name"); } @Test // DATAMONGO-1387 @@ -159,6 +158,6 @@ public class BasicQueryUnitTests { BasicQuery query1 = new BasicQuery(qry, fields); query1.fields().include("gender"); - assertThat(query1.getFieldsObject(), isBsonObject().containing("name").containing("age").containing("gender")); + assertThat(query1.getFieldsObject()).containsKeys("name", "age", "gender"); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/CriteriaUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/CriteriaUnitTests.java index 2c0a674bf..b1802dc44 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/CriteriaUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/CriteriaUnitTests.java @@ -15,18 +15,14 @@ */ package org.springframework.data.mongodb.core.query; -import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.CoreMatchers.*; -import static org.hamcrest.CoreMatchers.not; -import static org.junit.Assert.*; -import static org.junit.Assert.assertThat; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import java.util.Arrays; import java.util.Collections; import org.bson.Document; import org.junit.Test; + import org.springframework.data.geo.Point; import org.springframework.data.mongodb.InvalidMongoDbApiUsageException; import org.springframework.data.mongodb.core.geo.GeoJsonLineString; @@ -44,13 +40,13 @@ public class CriteriaUnitTests { @Test public void testSimpleCriteria() { Criteria c = new Criteria("name").is("Bubba"); - assertEquals(Document.parse("{ \"name\" : \"Bubba\"}"), c.getCriteriaObject()); + assertThat(c.getCriteriaObject()).isEqualTo(Document.parse("{ \"name\" : \"Bubba\"}")); } @Test public void testNotEqualCriteria() { Criteria c = new Criteria("name").ne("Bubba"); - assertEquals(Document.parse("{ \"name\" : { \"$ne\" : \"Bubba\"}}"), c.getCriteriaObject()); + assertThat(c.getCriteriaObject()).isEqualTo(Document.parse("{ \"name\" : { \"$ne\" : \"Bubba\"}}")); } @Test @@ -59,13 +55,13 @@ public class CriteriaUnitTests { Document reference = new Document("name", null); Criteria criteria = new Criteria("name").is(null); - assertThat(criteria.getCriteriaObject(), is(reference)); + assertThat(criteria.getCriteriaObject()).isEqualTo(reference); } @Test public void testChainedCriteria() { Criteria c = new Criteria("name").is("Bubba").and("age").lt(21); - assertEquals(Document.parse("{ \"name\" : \"Bubba\" , \"age\" : { \"$lt\" : 21}}"), c.getCriteriaObject()); + assertThat(c.getCriteriaObject()).isEqualTo(Document.parse("{ \"name\" : \"Bubba\" , \"age\" : { \"$lt\" : 21}}")); } @Test(expected = InvalidMongoDbApiUsageException.class) @@ -80,8 +76,8 @@ public class CriteriaUnitTests { Criteria left = new Criteria("name").is("Foo").and("lastname").is("Bar"); Criteria right = new Criteria("name").is("Bar").and("lastname").is("Bar"); - assertThat(left, is(not(right))); - assertThat(right, is(not(left))); + assertThat(left).isNotEqualTo(right); + assertThat(right).isNotEqualTo(left); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-507 @@ -114,8 +110,8 @@ public class CriteriaUnitTests { Criteria c = Criteria.where("age").not().gt(18).and("status").is("student"); Document co = c.getCriteriaObject(); - assertThat(co, is(notNullValue())); - assertThat(co, is(Document.parse("{ \"age\" : { \"$not\" : { \"$gt\" : 18}} , \"status\" : \"student\"}"))); + assertThat(co).isNotNull(); + assertThat(co).isEqualTo(Document.parse("{ \"age\" : { \"$not\" : { \"$gt\" : 18}} , \"status\" : \"student\"}")); } @Test // DATAMONGO-1068 @@ -123,7 +119,7 @@ public class CriteriaUnitTests { Document document = new Criteria().getCriteriaObject(); - assertThat(document, equalTo(new Document())); + assertThat(document).isEqualTo(new Document()); } @Test // DATAMONGO-1068 @@ -131,7 +127,7 @@ public class CriteriaUnitTests { Document document = new Criteria().lt("foo").getCriteriaObject(); - assertThat(document, equalTo(new Document().append("$lt", "foo"))); + assertThat(document).isEqualTo(new Document().append("$lt", "foo")); } @Test // DATAMONGO-1068 @@ -139,7 +135,7 @@ public class CriteriaUnitTests { Document document = new Criteria().lt("foo").gt("bar").getCriteriaObject(); - assertThat(document, equalTo(new Document().append("$lt", "foo").append("$gt", "bar"))); + assertThat(document).isEqualTo(new Document().append("$lt", "foo").append("$gt", "bar")); } @Test // DATAMONGO-1068 @@ -147,7 +143,7 @@ public class CriteriaUnitTests { Document document = new Criteria().lt("foo").not().getCriteriaObject(); - assertThat(document, equalTo(new Document().append("$not", new Document("$lt", "foo")))); + assertThat(document).isEqualTo(new Document().append("$not", new Document("$lt", "foo"))); } @Test // DATAMONGO-1135 @@ -155,7 +151,7 @@ public class CriteriaUnitTests { Document document = new Criteria("foo").near(new GeoJsonPoint(100, 200)).getCriteriaObject(); - assertThat(document, isBsonObject().containing("foo.$near.$geometry", new GeoJsonPoint(100, 200))); + assertThat(document).containsEntry("foo.$near.$geometry", new GeoJsonPoint(100, 200)); } @Test // DATAMONGO-1135 @@ -163,7 +159,7 @@ public class CriteriaUnitTests { Document document = new Criteria("foo").near(new Point(100, 200)).getCriteriaObject(); - assertThat(document, isBsonObject().notContaining("foo.$near.$geometry")); + assertThat(document).doesNotContainKey("foo.$near.$geometry"); } @Test // DATAMONGO-1135 @@ -171,7 +167,7 @@ public class CriteriaUnitTests { Document document = new Criteria("foo").near(new GeoJsonPoint(100, 200)).maxDistance(50D).getCriteriaObject(); - assertThat(document, isBsonObject().containing("foo.$near.$maxDistance", 50D)); + assertThat(document).containsEntry("foo.$near.$maxDistance", 50D); } @Test // DATAMONGO-1135 @@ -179,7 +175,7 @@ public class CriteriaUnitTests { Document document = new Criteria("foo").nearSphere(new GeoJsonPoint(100, 200)).maxDistance(50D).getCriteriaObject(); - assertThat(document, isBsonObject().containing("foo.$nearSphere.$maxDistance", 50D)); + assertThat(document).containsEntry("foo.$nearSphere.$maxDistance", 50D); } @Test // DATAMONGO-1110 @@ -187,7 +183,7 @@ public class CriteriaUnitTests { Document document = new Criteria("foo").near(new GeoJsonPoint(100, 200)).minDistance(50D).getCriteriaObject(); - assertThat(document, isBsonObject().containing("foo.$near.$minDistance", 50D)); + assertThat(document).containsEntry("foo.$near.$minDistance", 50D); } @Test // DATAMONGO-1110 @@ -195,7 +191,7 @@ public class CriteriaUnitTests { Document document = new Criteria("foo").nearSphere(new GeoJsonPoint(100, 200)).minDistance(50D).getCriteriaObject(); - assertThat(document, isBsonObject().containing("foo.$nearSphere.$minDistance", 50D)); + assertThat(document).containsEntry("foo.$nearSphere.$minDistance", 50D); } @Test // DATAMONGO-1110 @@ -204,8 +200,8 @@ public class CriteriaUnitTests { Document document = new Criteria("foo").nearSphere(new GeoJsonPoint(100, 200)).minDistance(50D).maxDistance(100D) .getCriteriaObject(); - assertThat(document, isBsonObject().containing("foo.$nearSphere.$minDistance", 50D)); - assertThat(document, isBsonObject().containing("foo.$nearSphere.$maxDistance", 100D)); + assertThat(document).containsEntry("foo.$nearSphere.$minDistance", 50D); + assertThat(document).containsEntry("foo.$nearSphere.$maxDistance", 100D); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-1134 @@ -219,7 +215,7 @@ public class CriteriaUnitTests { GeoJsonLineString lineString = new GeoJsonLineString(new Point(0, 0), new Point(10, 10)); Document document = new Criteria("foo").intersects(lineString).getCriteriaObject(); - assertThat(document, isBsonObject().containing("foo.$geoIntersects.$geometry", lineString)); + assertThat(document).containsEntry("foo.$geoIntersects.$geometry", lineString); } @Test // DATAMONGO-1835 @@ -228,8 +224,8 @@ public class CriteriaUnitTests { MongoJsonSchema schema = MongoJsonSchema.builder().required("name").build(); Criteria criteria = Criteria.where("foo").is("bar").andDocumentStructureMatches(schema); - assertThat(criteria.getCriteriaObject(), is(equalTo(new Document("foo", "bar").append("$jsonSchema", - new Document("type", "object").append("required", Collections.singletonList("name")))))); + assertThat(criteria.getCriteriaObject()).isEqualTo(new Document("foo", "bar").append("$jsonSchema", + new Document("type", "object").append("required", Collections.singletonList("name")))); } @Test // DATAMONGO-1835 @@ -238,8 +234,8 @@ public class CriteriaUnitTests { MongoJsonSchema schema = MongoJsonSchema.builder().required("name").build(); Criteria criteria = Criteria.matchingDocumentStructure(schema); - assertThat(criteria.getCriteriaObject(), is(equalTo(new Document("$jsonSchema", - new Document("type", "object").append("required", Collections.singletonList("name")))))); + assertThat(criteria.getCriteriaObject()).isEqualTo(new Document("$jsonSchema", + new Document("type", "object").append("required", Collections.singletonList("name")))); } @Test // DATAMONGO-1808 @@ -247,8 +243,8 @@ public class CriteriaUnitTests { Criteria numericBitmaskCriteria = new Criteria("field").bits().allClear(0b101); - assertThat(numericBitmaskCriteria.getCriteriaObject(), - is(equalTo(Document.parse("{ \"field\" : { \"$bitsAllClear\" : 5} }")))); + assertThat(numericBitmaskCriteria.getCriteriaObject()) + .isEqualTo(Document.parse("{ \"field\" : { \"$bitsAllClear\" : 5} }")); } @Test // DATAMONGO-1808 @@ -256,8 +252,8 @@ public class CriteriaUnitTests { Criteria bitPositionsBitmaskCriteria = new Criteria("field").bits().allClear(Arrays.asList(0, 2)); - assertThat(bitPositionsBitmaskCriteria.getCriteriaObject(), - is(equalTo(Document.parse("{ \"field\" : { \"$bitsAllClear\" : [ 0, 2 ]} }")))); + assertThat(bitPositionsBitmaskCriteria.getCriteriaObject()) + .isEqualTo(Document.parse("{ \"field\" : { \"$bitsAllClear\" : [ 0, 2 ]} }")); } @Test // DATAMONGO-1808 @@ -265,8 +261,8 @@ public class CriteriaUnitTests { Criteria numericBitmaskCriteria = new Criteria("field").bits().allSet(0b101); - assertThat(numericBitmaskCriteria.getCriteriaObject(), - is(equalTo(Document.parse("{ \"field\" : { \"$bitsAllSet\" : 5} }")))); + assertThat(numericBitmaskCriteria.getCriteriaObject()) + .isEqualTo(Document.parse("{ \"field\" : { \"$bitsAllSet\" : 5} }")); } @Test // DATAMONGO-1808 @@ -274,8 +270,8 @@ public class CriteriaUnitTests { Criteria bitPositionsBitmaskCriteria = new Criteria("field").bits().allSet(Arrays.asList(0, 2)); - assertThat(bitPositionsBitmaskCriteria.getCriteriaObject(), - is(equalTo(Document.parse("{ \"field\" : { \"$bitsAllSet\" : [ 0, 2 ]} }")))); + assertThat(bitPositionsBitmaskCriteria.getCriteriaObject()) + .isEqualTo(Document.parse("{ \"field\" : { \"$bitsAllSet\" : [ 0, 2 ]} }")); } @Test // DATAMONGO-1808 @@ -283,8 +279,8 @@ public class CriteriaUnitTests { Criteria numericBitmaskCriteria = new Criteria("field").bits().anyClear(0b101); - assertThat(numericBitmaskCriteria.getCriteriaObject(), - is(equalTo(Document.parse("{ \"field\" : { \"$bitsAnyClear\" : 5} }")))); + assertThat(numericBitmaskCriteria.getCriteriaObject()) + .isEqualTo(Document.parse("{ \"field\" : { \"$bitsAnyClear\" : 5} }")); } @Test // DATAMONGO-1808 @@ -292,8 +288,8 @@ public class CriteriaUnitTests { Criteria bitPositionsBitmaskCriteria = new Criteria("field").bits().anyClear(Arrays.asList(0, 2)); - assertThat(bitPositionsBitmaskCriteria.getCriteriaObject(), - is(equalTo(Document.parse("{ \"field\" : { \"$bitsAnyClear\" : [ 0, 2 ]} }")))); + assertThat(bitPositionsBitmaskCriteria.getCriteriaObject()) + .isEqualTo(Document.parse("{ \"field\" : { \"$bitsAnyClear\" : [ 0, 2 ]} }")); } @Test // DATAMONGO-1808 @@ -301,8 +297,8 @@ public class CriteriaUnitTests { Criteria numericBitmaskCriteria = new Criteria("field").bits().anySet(0b101); - assertThat(numericBitmaskCriteria.getCriteriaObject(), - is(equalTo(Document.parse("{ \"field\" : { \"$bitsAnySet\" : 5} }")))); + assertThat(numericBitmaskCriteria.getCriteriaObject()) + .isEqualTo(Document.parse("{ \"field\" : { \"$bitsAnySet\" : 5} }")); } @Test // DATAMONGO-1808 @@ -310,8 +306,8 @@ public class CriteriaUnitTests { Criteria bitPositionsBitmaskCriteria = new Criteria("field").bits().anySet(Arrays.asList(0, 2)); - assertThat(bitPositionsBitmaskCriteria.getCriteriaObject(), - is(equalTo(Document.parse("{ \"field\" : { \"$bitsAnySet\" : [ 0, 2 ]} }")))); + assertThat(bitPositionsBitmaskCriteria.getCriteriaObject()) + .isEqualTo(Document.parse("{ \"field\" : { \"$bitsAnySet\" : [ 0, 2 ]} }")); } @Test // DATAMONGO-2002 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/FieldUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/FieldUnitTests.java index 18b49d8d7..c4fd71da3 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/FieldUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/FieldUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.query; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; @@ -33,8 +32,8 @@ public class FieldUnitTests { Field left = new Field().elemMatch("key", Criteria.where("foo").is("bar")); Field right = new Field().elemMatch("key", Criteria.where("foo").is("bar")); - assertThat(left, is(right)); - assertThat(right, is(left)); + assertThat(left).isEqualTo(right); + assertThat(right).isEqualTo(left); } @Test @@ -43,7 +42,7 @@ public class FieldUnitTests { Field left = new Field().elemMatch("key", Criteria.where("foo").is("bar")); Field right = new Field().elemMatch("key", Criteria.where("foo").is("foo")); - assertThat(left, is(not(right))); - assertThat(right, is(not(left))); + assertThat(left).isNotEqualTo(right); + assertThat(right).isNotEqualTo(left); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IndexUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IndexUnitTests.java index d5034b6a4..5552214e3 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IndexUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IndexUnitTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.core.query; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; + import org.springframework.data.domain.Sort.Direction; import org.springframework.data.mongodb.core.index.GeoSpatialIndexType; import org.springframework.data.mongodb.core.index.GeospatialIndex; @@ -36,44 +36,44 @@ public class IndexUnitTests { @Test public void testWithAscendingIndex() { Index i = new Index().on("name", Direction.ASC); - assertEquals(Document.parse("{ \"name\" : 1}"), i.getIndexKeys()); + assertThat(i.getIndexKeys()).isEqualTo(Document.parse("{ \"name\" : 1}")); } @Test public void testWithDescendingIndex() { Index i = new Index().on("name", Direction.DESC); - assertEquals(Document.parse("{ \"name\" : -1}"), i.getIndexKeys()); + assertThat(i.getIndexKeys()).isEqualTo(Document.parse("{ \"name\" : -1}")); } @Test public void testNamedMultiFieldUniqueIndex() { Index i = new Index().on("name", Direction.ASC).on("age", Direction.DESC); i.named("test").unique(); - assertEquals(Document.parse("{ \"name\" : 1 , \"age\" : -1}"), i.getIndexKeys()); - assertEquals(Document.parse("{ \"name\" : \"test\" , \"unique\" : true}"), i.getIndexOptions()); + assertThat(i.getIndexKeys()).isEqualTo(Document.parse("{ \"name\" : 1 , \"age\" : -1}")); + assertThat(i.getIndexOptions()).isEqualTo(Document.parse("{ \"name\" : \"test\" , \"unique\" : true}")); } @Test public void testWithSparse() { Index i = new Index().on("name", Direction.ASC); i.sparse().unique(); - assertEquals(Document.parse("{ \"name\" : 1}"), i.getIndexKeys()); - assertEquals(Document.parse("{ \"unique\" : true , \"sparse\" : true}"), i.getIndexOptions()); + assertThat(i.getIndexKeys()).isEqualTo(Document.parse("{ \"name\" : 1}")); + assertThat(i.getIndexOptions()).isEqualTo(Document.parse("{ \"unique\" : true , \"sparse\" : true}")); } @Test public void testGeospatialIndex() { GeospatialIndex i = new GeospatialIndex("location").withMin(0); - assertEquals(Document.parse("{ \"location\" : \"2d\"}"), i.getIndexKeys()); - assertEquals(Document.parse("{ \"min\" : 0}"), i.getIndexOptions()); + assertThat(i.getIndexKeys()).isEqualTo(Document.parse("{ \"location\" : \"2d\"}")); + assertThat(i.getIndexOptions()).isEqualTo(Document.parse("{ \"min\" : 0}")); } @Test // DATAMONGO-778 public void testGeospatialIndex2DSphere() { GeospatialIndex i = new GeospatialIndex("location").typed(GeoSpatialIndexType.GEO_2DSPHERE); - assertEquals(Document.parse("{ \"location\" : \"2dsphere\"}"), i.getIndexKeys()); - assertEquals(Document.parse("{ }"), i.getIndexOptions()); + assertThat(i.getIndexKeys()).isEqualTo(Document.parse("{ \"location\" : \"2dsphere\"}")); + assertThat(i.getIndexOptions()).isEqualTo(Document.parse("{ }")); } @Test // DATAMONGO-778 @@ -81,14 +81,14 @@ public class IndexUnitTests { GeospatialIndex i = new GeospatialIndex("location").typed(GeoSpatialIndexType.GEO_HAYSTACK) .withAdditionalField("name").withBucketSize(40); - assertEquals(Document.parse("{ \"location\" : \"geoHaystack\" , \"name\" : 1}"), i.getIndexKeys()); - assertEquals(Document.parse("{ \"bucketSize\" : 40.0}"), i.getIndexOptions()); + assertThat(i.getIndexKeys()).isEqualTo(Document.parse("{ \"location\" : \"geoHaystack\" , \"name\" : 1}")); + assertThat(i.getIndexOptions()).isEqualTo(Document.parse("{ \"bucketSize\" : 40.0}")); } @Test public void ensuresPropertyOrder() { Index on = new Index("foo", Direction.ASC).on("bar", Direction.ASC); - assertThat(on.getIndexKeys(), is(Document.parse("{ \"foo\" : 1 , \"bar\" : 1}"))); + assertThat(on.getIndexKeys()).isEqualTo(Document.parse("{ \"foo\" : 1 , \"bar\" : 1}")); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IsQuery.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IsQuery.java deleted file mode 100644 index 715c964ef..000000000 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IsQuery.java +++ /dev/null @@ -1,151 +0,0 @@ -/* - * Copyright 2014-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. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.mongodb.core.query; - -import org.bson.Document; -import org.hamcrest.Description; -import org.hamcrest.TypeSafeMatcher; -import org.hamcrest.core.IsEqual; -import org.springframework.data.domain.Sort.Direction; -import org.springframework.util.StringUtils; - -/** - * A {@link TypeSafeMatcher} that tests whether a given {@link Query} matches a query specification. - * - * @author Christoph Strobl - * @author Mark Paluch - * @param - */ -public class IsQuery extends TypeSafeMatcher { - - protected Document query; - protected Document sort; - protected Document fields; - - private long skip; - private int limit; - private String hint; - - protected IsQuery() { - query = new Document(); - sort = new Document(); - fields = new Document(); - } - - public static IsQuery isQuery() { - return new IsQuery(); - } - - public IsQuery limitingTo(int limit) { - this.limit = limit; - return this; - } - - public IsQuery skippig(long skip) { - this.skip = skip; - return this; - } - - public IsQuery providingHint(String hint) { - this.hint = hint; - return this; - } - - public IsQuery includingField(String fieldname) { - - if (fields == null) { - fields = new Document(); - } - fields.put(fieldname, 1); - - return this; - } - - public IsQuery excludingField(String fieldname) { - - if (fields == null) { - fields = new Document(); - } - fields.put(fieldname, -1); - - return this; - } - - public IsQuery sortingBy(String fieldname, Direction direction) { - - sort.put(fieldname, Direction.ASC.equals(direction) ? 1 : -1); - - return this; - } - - public IsQuery where(Criteria criteria) { - - this.query.putAll(criteria.getCriteriaObject()); - return this; - } - - @Override - public void describeTo(Description description) { - - BasicQuery expected = new BasicQuery(this.query, this.fields); - expected.setSortObject(sort); - expected.skip(this.skip); - expected.limit(this.limit); - - if (StringUtils.hasText(this.hint)) { - expected.withHint(this.hint); - } - - description.appendValue(expected); - } - - @Override - protected boolean matchesSafely(T item) { - - if (item == null) { - return false; - } - - if (!new IsEqual(query).matches(item.getQueryObject())) { - return false; - } - - if ((item.getSortObject() == null || item.getSortObject().isEmpty()) && !sort.isEmpty()) { - if (!new IsEqual(sort).matches(item.getSortObject())) { - return false; - } - } - - if (!new IsEqual(fields).matches(item.getFieldsObject())) { - return false; - } - - if (!new IsEqual(this.hint).matches(item.getHint())) { - return false; - } - - if (!new IsEqual(this.skip).matches(item.getSkip())) { - return false; - } - - if (!new IsEqual(this.limit).matches(item.getLimit())) { - return false; - } - - return true; - } - -} diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IsTextQuery.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IsTextQuery.java deleted file mode 100644 index f38ecd01d..000000000 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/IsTextQuery.java +++ /dev/null @@ -1,141 +0,0 @@ -/* - * Copyright 2014-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. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.mongodb.core.query; - -import org.bson.Document; -import org.hamcrest.TypeSafeMatcher; -import org.springframework.util.StringUtils; - -/** - * A {@link TypeSafeMatcher} that tests whether a given {@link TextQuery} matches a query specification. - * - * @author Christoph Strobl - * @param - */ -public class IsTextQuery extends IsQuery { - - private final String SCORE_DEFAULT_FIELDNAME = "score"; - private final Document META_TEXT_SCORE = new Document("$meta", "textScore"); - - private String scoreFieldName = SCORE_DEFAULT_FIELDNAME; - - private IsTextQuery() { - super(); - } - - public static IsTextQuery isTextQuery() { - return new IsTextQuery(); - } - - public IsTextQuery searchingFor(String term) { - appendTerm(term); - return this; - } - - public IsTextQuery inLanguage(String language) { - appendLanguage(language); - return this; - } - - public IsTextQuery returningScore() { - - if (fields == null) { - fields = new Document(); - } - fields.put(scoreFieldName, META_TEXT_SCORE); - - return this; - } - - public IsTextQuery returningScoreAs(String fieldname) { - - this.scoreFieldName = fieldname != null ? fieldname : SCORE_DEFAULT_FIELDNAME; - - return this.returningScore(); - } - - public IsTextQuery sortingByScore() { - - sort.put(scoreFieldName, META_TEXT_SCORE); - - return this; - } - - @Override - public IsTextQuery where(Criteria criteria) { - - super.where(criteria); - return this; - } - - @Override - public IsTextQuery excludingField(String fieldname) { - - super.excludingField(fieldname); - return this; - } - - @Override - public IsTextQuery includingField(String fieldname) { - - super.includingField(fieldname); - return this; - } - - @Override - public IsTextQuery limitingTo(int limit) { - - super.limitingTo(limit); - return this; - } - - @Override - public IsQuery skippig(long skip) { - - super.skippig(skip); - return this; - } - - private void appendLanguage(String language) { - - Document document = getOrCreateTextDocument(); - document.put("$language", language); - } - - private Document getOrCreateTextDocument() { - - Document document = (Document) query.get("$text"); - if (document == null) { - document = new Document(); - } - - return document; - } - - private void appendTerm(String term) { - - Document document = getOrCreateTextDocument(); - String searchString = (String) document.get("$search"); - if (StringUtils.hasText(searchString)) { - searchString += (" " + term); - } else { - searchString = term; - } - document.put("$search", searchString); - query.put("$text", document); - } - -} diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/MetricConversionUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/MetricConversionUnitTests.java index 63bc10157..ee785fa0e 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/MetricConversionUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/MetricConversionUnitTests.java @@ -16,10 +16,11 @@ package org.springframework.data.mongodb.core.query; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.data.Offset.offset; import org.junit.Test; + import org.springframework.data.geo.Distance; import org.springframework.data.geo.Metrics; @@ -36,7 +37,7 @@ public class MetricConversionUnitTests { Distance distance = new Distance(1, Metrics.MILES); double distanceInMeters = MetricConversion.getDistanceInMeters(distance); - assertThat(distanceInMeters, is(closeTo(1609.3438343d, 0.000000001))); + assertThat(distanceInMeters).isCloseTo(1609.3438343d, offset(0.000000001)); } @Test // DATAMONGO-1348 @@ -45,7 +46,7 @@ public class MetricConversionUnitTests { Distance distance = new Distance(1, Metrics.KILOMETERS); double distanceInMeters = MetricConversion.getDistanceInMeters(distance); - assertThat(distanceInMeters, is(closeTo(1000, 0.000000001))); + assertThat(distanceInMeters).isCloseTo(1000, offset(0.000000001)); } @Test // DATAMONGO-1348 @@ -53,7 +54,7 @@ public class MetricConversionUnitTests { double multiplier = MetricConversion.getMetersToMetricMultiplier(Metrics.KILOMETERS); - assertThat(multiplier, is(closeTo(0.001, 0.000000001))); + assertThat(multiplier).isCloseTo(0.001, offset(0.000000001)); } @Test // DATAMONGO-1348 @@ -61,7 +62,7 @@ public class MetricConversionUnitTests { double multiplier = MetricConversion.getMetersToMetricMultiplier(Metrics.MILES); - assertThat(multiplier, is(closeTo(0.00062137, 0.000000001))); + assertThat(multiplier).isCloseTo(0.00062137, offset(0.000000001)); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/NearQueryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/NearQueryUnitTests.java index 49b8f2b48..ad5732dce 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/NearQueryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/NearQueryUnitTests.java @@ -15,14 +15,13 @@ */ package org.springframework.data.mongodb.core.query; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import static org.springframework.data.mongodb.test.util.IsBsonObject.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import java.math.BigDecimal; import java.math.RoundingMode; import org.junit.Test; + import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; import org.springframework.data.geo.Distance; @@ -54,9 +53,9 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(2.5, 2.5, Metrics.KILOMETERS).maxDistance(150); - assertThat(query.getMaxDistance(), is(ONE_FIFTY_KILOMETERS)); - assertThat(query.getMetric(), is((Metric) Metrics.KILOMETERS)); - assertThat(query.isSpherical(), is(true)); + assertThat(query.getMaxDistance()).isEqualTo(ONE_FIFTY_KILOMETERS); + assertThat(query.getMetric()).isEqualTo((Metric) Metrics.KILOMETERS); + assertThat(query.isSpherical()).isTrue(); } @Test @@ -66,27 +65,27 @@ public class NearQueryUnitTests { query.inMiles(); - assertThat(query.getMetric(), is((Metric) Metrics.MILES)); + assertThat(query.getMetric()).isEqualTo((Metric) Metrics.MILES); } @Test public void configuresResultMetricCorrectly() { NearQuery query = NearQuery.near(2.5, 2.1); - assertThat(query.getMetric(), is((Metric) Metrics.NEUTRAL)); + assertThat(query.getMetric()).isEqualTo((Metric) Metrics.NEUTRAL); query = query.maxDistance(ONE_FIFTY_KILOMETERS); - assertThat(query.getMetric(), is((Metric) Metrics.KILOMETERS)); - assertThat(query.getMaxDistance(), is(ONE_FIFTY_KILOMETERS)); - assertThat(query.isSpherical(), is(true)); + assertThat(query.getMetric()).isEqualTo((Metric) Metrics.KILOMETERS); + assertThat(query.getMaxDistance()).isEqualTo(ONE_FIFTY_KILOMETERS); + assertThat(query.isSpherical()).isTrue(); query = query.in(Metrics.MILES); - assertThat(query.getMetric(), is((Metric) Metrics.MILES)); - assertThat(query.getMaxDistance(), is(ONE_FIFTY_KILOMETERS)); - assertThat(query.isSpherical(), is(true)); + assertThat(query.getMetric()).isEqualTo((Metric) Metrics.MILES); + assertThat(query.getMaxDistance()).isEqualTo(ONE_FIFTY_KILOMETERS); + assertThat(query.isSpherical()).isTrue(); query = query.maxDistance(new Distance(200, Metrics.KILOMETERS)); - assertThat(query.getMetric(), is((Metric) Metrics.MILES)); + assertThat(query.getMetric()).isEqualTo((Metric) Metrics.MILES); } @Test // DATAMONGO-445, DATAMONGO-2264 @@ -95,8 +94,8 @@ public class NearQueryUnitTests { Pageable pageable = PageRequest.of(3, 5); NearQuery query = NearQuery.near(new Point(1, 1)).with(pageable); - assertThat(query.getSkip(), is((long) pageable.getPageNumber() * pageable.getPageSize())); - assertThat(query.toDocument().get("num"), is((long) pageable.getPageSize())); + assertThat(query.getSkip()).isEqualTo((long) pageable.getPageNumber() * pageable.getPageSize()); + assertThat(query.toDocument().get("num")).isEqualTo((long) pageable.getPageSize()); } @Test // DATAMONGO-445 @@ -107,8 +106,8 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new Point(1, 1)) .query(Query.query(Criteria.where("foo").is("bar")).limit(limit).skip(skip)); - assertThat(query.getSkip(), is(skip)); - assertThat((Long) query.toDocument().get("num"), is((long) limit)); + assertThat(query.getSkip()).isEqualTo(skip); + assertThat((Long) query.toDocument().get("num")).isEqualTo((long) limit); } @Test // DATAMONGO-445, DATAMONGO-2264 @@ -120,15 +119,15 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new Point(1, 1)) .query(Query.query(Criteria.where("foo").is("bar")).limit(limit).skip(skip)).with(pageable); - assertThat(query.getSkip(), is((long) pageable.getPageNumber() * pageable.getPageSize())); - assertThat(query.toDocument().get("num"), is((long) pageable.getPageSize())); + assertThat(query.getSkip()).isEqualTo((long) pageable.getPageNumber() * pageable.getPageSize()); + assertThat(query.toDocument().get("num")).isEqualTo((long) pageable.getPageSize()); } @Test // DATAMONGO-829 public void nearQueryShouldInoreZeroLimitFromQuery() { NearQuery query = NearQuery.near(new Point(1, 2)).query(Query.query(Criteria.where("foo").is("bar"))); - assertThat(query.toDocument().get("num"), nullValue()); + assertThat(query.toDocument().get("num")).isNull(); } @Test(expected = IllegalArgumentException.class) // DATAMONOGO-829 @@ -144,7 +143,7 @@ public class NearQueryUnitTests { query.num(num); query.query(Query.query(Criteria.where("foo").is("bar"))); - assertThat(DocumentTestUtils.getTypedValue(query.toDocument(), "num", Long.class), is(num)); + assertThat(DocumentTestUtils.getTypedValue(query.toDocument(), "num", Long.class)).isEqualTo(num); } @Test // DATAMONGO-1348 @@ -152,7 +151,7 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new Point(27.987901, 86.9165379)); - assertThat(query.toDocument(), isBsonObject().containing("spherical", false)); + assertThat(query.toDocument()).containsEntry("spherical", false); } @Test // DATAMONGO-1348 @@ -161,7 +160,7 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new Point(27.987901, 86.9165379)); query.spherical(true); - assertThat(query.toDocument(), isBsonObject().containing("spherical", true)); + assertThat(query.toDocument()).containsEntry("spherical", true); } @Test // DATAMONGO-1348 @@ -169,7 +168,7 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new GeoJsonPoint(27.987901, 86.9165379)); - assertThat(query.toDocument(), isBsonObject().containing("spherical", true)); + assertThat(query.toDocument()).containsEntry("spherical", true); } @Test // DATAMONGO-1348 @@ -178,7 +177,7 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new GeoJsonPoint(27.987901, 86.9165379)); query.spherical(false); - assertThat(query.toDocument(), isBsonObject().containing("spherical", true)); + assertThat(query.toDocument()).containsEntry("spherical", true); } @Test // DATAMONGO-1348 @@ -190,8 +189,8 @@ public class NearQueryUnitTests { double meterToRadianMultiplier = BigDecimal.valueOf(1 / Metrics.KILOMETERS.getMultiplier() / 1000).// setScale(8, RoundingMode.HALF_UP).// doubleValue(); - assertThat(query.toDocument(), isBsonObject().containing("maxDistance", Metrics.KILOMETERS.getMultiplier() * 1000) - .containing("distanceMultiplier", meterToRadianMultiplier)); + assertThat(query.toDocument()).containsEntry("maxDistance", Metrics.KILOMETERS.getMultiplier() * 1000) + .containsEntry("distanceMultiplier", meterToRadianMultiplier); } @Test // DATAMONGO-1348 @@ -200,8 +199,7 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new GeoJsonPoint(27.987901, 86.9165379)); query.maxDistance(new Distance(1, Metrics.KILOMETERS)); - assertThat(query.toDocument(), - isBsonObject().containing("maxDistance", 1000D).containing("distanceMultiplier", 0.001D)); + assertThat(query.toDocument()).containsEntry("maxDistance", 1000D).containsEntry("distanceMultiplier", 0.001D); } @Test // DATAMONGO-1348 @@ -210,8 +208,8 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new GeoJsonPoint(27.987901, 86.9165379)); query.maxDistance(new Distance(1, Metrics.MILES)); - assertThat(query.toDocument(), - isBsonObject().containing("maxDistance", 1609.3438343D).containing("distanceMultiplier", 0.00062137D)); + assertThat(query.toDocument()).containsEntry("maxDistance", 1609.3438343D).containsEntry("distanceMultiplier", + 0.00062137D); } @Test // DATAMONGO-1348 @@ -220,8 +218,8 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new GeoJsonPoint(27.987901, 86.9165379)); query.maxDistance(new Distance(1, Metrics.MILES)).in(Metrics.KILOMETERS); - assertThat(query.toDocument(), - isBsonObject().containing("maxDistance", 1609.3438343D).containing("distanceMultiplier", 0.001D)); + assertThat(query.toDocument()).containsEntry("maxDistance", 1609.3438343D).containsEntry("distanceMultiplier", + 0.001D); } @Test // DATAMONGO-1348 @@ -230,7 +228,6 @@ public class NearQueryUnitTests { NearQuery query = NearQuery.near(new GeoJsonPoint(27.987901, 86.9165379)); query.maxDistance(new Distance(1, Metrics.KILOMETERS)).in(Metrics.MILES); - assertThat(query.toDocument(), - isBsonObject().containing("maxDistance", 1000D).containing("distanceMultiplier", 0.00062137D)); + assertThat(query.toDocument()).containsEntry("maxDistance", 1000D).containsEntry("distanceMultiplier", 0.00062137D); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/QueryTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/QueryTests.java index 15ea7556b..baddb1a37 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/QueryTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/QueryTests.java @@ -20,8 +20,8 @@ import static org.springframework.data.mongodb.core.query.Criteria.*; import static org.springframework.data.mongodb.core.query.Query.*; import org.bson.Document; -import org.junit.Assert; import org.junit.Test; + import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort.Direction; import org.springframework.data.domain.Sort.Order; @@ -76,7 +76,7 @@ public class QueryTests { Query q = new Query(new Criteria().andOperator(where("name").is("Sven"), where("age").lt(50))); Document expected = Document.parse("{ \"$and\" : [ { \"name\" : \"Sven\"} , { \"age\" : { \"$lt\" : 50}}]}"); - Assert.assertEquals(expected, q.getQueryObject()); + assertThat(q.getQueryObject()).isEqualTo(expected); } @Test @@ -96,7 +96,7 @@ public class QueryTests { assertThat(q.getQueryObject()).isEqualTo(Document .parse("{ \"name\" : { \"$gte\" : \"M\" , \"$lte\" : \"T\"} , \"age\" : { \"$not\" : { \"$gt\" : 22}}}")); - Assert.assertEquals(50, q.getLimit()); + assertThat(q.getLimit()).isEqualTo(50); } @Test diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/SortTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/SortTests.java index 1efe32301..14f8061af 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/SortTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/SortTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.core.query; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.bson.Document; import org.junit.Test; + import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort.Direction; @@ -35,20 +35,20 @@ public class SortTests { public void testWithSortAscending() { Query s = new Query().with(Sort.by(Direction.ASC, "name")); - assertEquals(Document.parse("{ \"name\" : 1}"), s.getSortObject()); + assertThat(s.getSortObject()).isEqualTo(Document.parse("{ \"name\" : 1}")); } @Test public void testWithSortDescending() { Query s = new Query().with(Sort.by(Direction.DESC, "name")); - assertEquals(Document.parse("{ \"name\" : -1}"), s.getSortObject()); + assertThat(s.getSortObject()).isEqualTo(Document.parse("{ \"name\" : -1}")); } @Test // DATADOC-177 public void preservesOrderKeysOnMultipleSorts() { Query sort = new Query().with(Sort.by(Direction.DESC, "foo").and(Sort.by(Direction.DESC, "bar"))); - assertThat(sort.getSortObject(), is(Document.parse("{ \"foo\" : -1 , \"bar\" : -1}"))); + assertThat(sort.getSortObject()).isEqualTo(Document.parse("{ \"foo\" : -1 , \"bar\" : -1}")); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextCriteriaUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextCriteriaUnitTests.java index adc4e7ecb..be6a4b6c2 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextCriteriaUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextCriteriaUnitTests.java @@ -15,13 +15,11 @@ */ package org.springframework.data.mongodb.core.query; -import org.bson.Document; -import org.hamcrest.core.IsEqual; -import org.junit.Assert; -import static org.hamcrest.core.IsEqual.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; +import org.bson.Document; import org.junit.Test; + import org.springframework.data.mongodb.core.DocumentTestUtils; /** @@ -35,74 +33,74 @@ public class TextCriteriaUnitTests { public void shouldNotHaveLanguageField() { TextCriteria criteria = TextCriteria.forDefaultLanguage(); - assertThat(criteria.getCriteriaObject(), equalTo(searchObject("{ }"))); + assertThat(criteria.getCriteriaObject()).isEqualTo(searchObject("{ }")); } @Test // DATAMONGO-850 public void shouldNotHaveLanguageForNonDefaultLanguageField() { TextCriteria criteria = TextCriteria.forLanguage("spanish"); - assertThat(criteria.getCriteriaObject(), equalTo(searchObject("{ \"$language\" : \"spanish\" }"))); + assertThat(criteria.getCriteriaObject()).isEqualTo(searchObject("{ \"$language\" : \"spanish\" }")); } @Test // DATAMONGO-850 public void shouldCreateSearchFieldForSingleTermCorrectly() { TextCriteria criteria = TextCriteria.forDefaultLanguage().matching("cake"); - assertThat(criteria.getCriteriaObject(), equalTo(searchObject("{ \"$search\" : \"cake\" }"))); + assertThat(criteria.getCriteriaObject()).isEqualTo(searchObject("{ \"$search\" : \"cake\" }")); } @Test // DATAMONGO-850 public void shouldCreateSearchFieldCorrectlyForMultipleTermsCorrectly() { TextCriteria criteria = TextCriteria.forDefaultLanguage().matchingAny("bake", "coffee", "cake"); - assertThat(criteria.getCriteriaObject(), equalTo(searchObject("{ \"$search\" : \"bake coffee cake\" }"))); + assertThat(criteria.getCriteriaObject()).isEqualTo(searchObject("{ \"$search\" : \"bake coffee cake\" }")); } @Test // DATAMONGO-850 public void shouldCreateSearchFieldForPhraseCorrectly() { TextCriteria criteria = TextCriteria.forDefaultLanguage().matchingPhrase("coffee cake"); - Assert.assertThat(DocumentTestUtils.getAsDocument(criteria.getCriteriaObject(), "$text"), - IsEqual. equalTo(new Document("$search", "\"coffee cake\""))); + assertThat(DocumentTestUtils.getAsDocument(criteria.getCriteriaObject(), "$text")) + .isEqualTo(new Document("$search", "\"coffee cake\"")); } @Test // DATAMONGO-850 public void shouldCreateNotFieldCorrectly() { TextCriteria criteria = TextCriteria.forDefaultLanguage().notMatching("cake"); - assertThat(criteria.getCriteriaObject(), equalTo(searchObject("{ \"$search\" : \"-cake\" }"))); + assertThat(criteria.getCriteriaObject()).isEqualTo(searchObject("{ \"$search\" : \"-cake\" }")); } @Test // DATAMONGO-850 public void shouldCreateSearchFieldCorrectlyForNotMultipleTermsCorrectly() { TextCriteria criteria = TextCriteria.forDefaultLanguage().notMatchingAny("bake", "coffee", "cake"); - assertThat(criteria.getCriteriaObject(), equalTo(searchObject("{ \"$search\" : \"-bake -coffee -cake\" }"))); + assertThat(criteria.getCriteriaObject()).isEqualTo(searchObject("{ \"$search\" : \"-bake -coffee -cake\" }")); } @Test // DATAMONGO-850 public void shouldCreateSearchFieldForNotPhraseCorrectly() { TextCriteria criteria = TextCriteria.forDefaultLanguage().notMatchingPhrase("coffee cake"); - Assert.assertThat(DocumentTestUtils.getAsDocument(criteria.getCriteriaObject(), "$text"), - IsEqual. equalTo(new Document("$search", "-\"coffee cake\""))); + assertThat(DocumentTestUtils.getAsDocument(criteria.getCriteriaObject(), "$text")) + .isEqualTo(new Document("$search", "-\"coffee cake\"")); } @Test // DATAMONGO-1455 public void caseSensitiveOperatorShouldBeSetCorrectly() { TextCriteria criteria = TextCriteria.forDefaultLanguage().matching("coffee").caseSensitive(true); - assertThat(DocumentTestUtils.getAsDocument(criteria.getCriteriaObject(), "$text"), - equalTo(new Document("$search", "coffee").append("$caseSensitive", true))); + assertThat(DocumentTestUtils.getAsDocument(criteria.getCriteriaObject(), "$text")) + .isEqualTo(new Document("$search", "coffee").append("$caseSensitive", true)); } @Test // DATAMONGO-1456 public void diacriticSensitiveOperatorShouldBeSetCorrectly() { TextCriteria criteria = TextCriteria.forDefaultLanguage().matching("coffee").diacriticSensitive(true); - assertThat(DocumentTestUtils.getAsDocument(criteria.getCriteriaObject(), "$text"), - equalTo(new Document("$search", "coffee").append("$diacriticSensitive", true))); + assertThat(DocumentTestUtils.getAsDocument(criteria.getCriteriaObject(), "$text")) + .isEqualTo(new Document("$search", "coffee").append("$diacriticSensitive", true)); } private Document searchObject(String json) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextQueryTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextQueryTests.java index 70e712e89..732879e9a 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextQueryTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextQueryTests.java @@ -15,29 +15,25 @@ */ package org.springframework.data.mongodb.core.query; -import static org.hamcrest.collection.IsCollectionWithSize.*; -import static org.hamcrest.collection.IsEmptyCollection.*; -import static org.hamcrest.collection.IsIterableContainingInOrder.*; -import static org.hamcrest.core.AnyOf.*; -import static org.hamcrest.core.IsCollectionContaining.*; -import static org.hamcrest.core.IsEqual.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.query.Criteria.*; +import lombok.ToString; + import java.util.List; -import lombok.ToString; import org.bson.Document; import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.annotation.Id; import org.springframework.data.domain.PageRequest; import org.springframework.data.mongodb.config.AbstractIntegrationTests; -import org.springframework.data.mongodb.core.index.IndexOperations; import org.springframework.data.mongodb.core.MongoOperations; import org.springframework.data.mongodb.core.index.IndexDefinition; +import org.springframework.data.mongodb.core.index.IndexOperations; import org.springframework.data.mongodb.core.mapping.Field; import org.springframework.data.mongodb.core.mapping.Language; import org.springframework.data.mongodb.core.mapping.TextScore; @@ -107,8 +103,8 @@ public class TextQueryTests extends AbstractIntegrationTests { initWithDefaultDocuments(); List result = template.find(new TextQuery("bake coffee cake"), FullTextDoc.class); - assertThat(result, hasSize(3)); - assertThat(result, hasItems(BAKE, COFFEE, CAKE)); + assertThat(result).hasSize(3); + assertThat(result).contains(BAKE, COFFEE, CAKE); } @Test // DATAMONGO-850 @@ -117,7 +113,7 @@ public class TextQueryTests extends AbstractIntegrationTests { initWithDefaultDocuments(); List result = template.find(new TextQuery("tasmanian devil"), FullTextDoc.class); - assertThat(result, hasSize(0)); + assertThat(result).hasSize(0); } @Test // DATAMONGO-850 @@ -128,11 +124,11 @@ public class TextQueryTests extends AbstractIntegrationTests { template.insert(coffee2); List result = template.find(new TextQuery("bake coffee cake").sortByScore(), FullTextDoc.class); - assertThat(result, hasSize(4)); - assertThat(result.get(0), anyOf(equalTo(BAKE), equalTo(coffee2))); - assertThat(result.get(1), anyOf(equalTo(BAKE), equalTo(coffee2))); - assertThat(result.get(2), equalTo(COFFEE)); - assertThat(result.get(3), equalTo(CAKE)); + assertThat(result).hasSize(4); + assertThat(result.get(0)).isIn(BAKE, coffee2); + assertThat(result.get(1)).isIn(BAKE, coffee2); + assertThat(result.get(2)).isEqualTo(COFFEE); + assertThat(result.get(3)).isEqualTo(CAKE); } @Test // DATAMONGO-850 @@ -140,8 +136,8 @@ public class TextQueryTests extends AbstractIntegrationTests { initWithDefaultDocuments(); List result = template.find(new TextQuery("leche"), FullTextDoc.class); - assertThat(result, hasSize(2)); - assertThat(result, hasItems(SPANISH_MILK, FRENCH_MILK)); + assertThat(result).hasSize(2); + assertThat(result).contains(SPANISH_MILK, FRENCH_MILK); } @Test // DATAMONGO-850 @@ -150,8 +146,8 @@ public class TextQueryTests extends AbstractIntegrationTests { initWithDefaultDocuments(); List result = template.find(new TextQuery("leche").addCriteria(where("language").is("spanish")), FullTextDoc.class); - assertThat(result, hasSize(1)); - assertThat(result.get(0), equalTo(SPANISH_MILK)); + assertThat(result).hasSize(1); + assertThat(result.get(0)).isEqualTo(SPANISH_MILK); } @Test // DATAMONGO-850 @@ -160,8 +156,8 @@ public class TextQueryTests extends AbstractIntegrationTests { initWithDefaultDocuments(); List result = template.find(new TextQuery("bake coffee -cake"), FullTextDoc.class); - assertThat(result, hasSize(2)); - assertThat(result, hasItems(BAKE, COFFEE)); + assertThat(result).hasSize(2); + assertThat(result).contains(BAKE, COFFEE); } @Test // DATAMONGO-976 @@ -172,9 +168,9 @@ public class TextQueryTests extends AbstractIntegrationTests { List result = template.find(new TextQuery("bake coffee -cake").includeScore().sortByScore(), FullTextDoc.class); - assertThat(result, hasSize(2)); + assertThat(result).hasSize(2); for (FullTextDoc scoredDoc : result) { - assertTrue(scoredDoc.score > 0F); + assertThat(scoredDoc.score > 0F).isTrue(); } } @@ -186,8 +182,8 @@ public class TextQueryTests extends AbstractIntegrationTests { TextQuery query = TextQuery.queryText(TextCriteria.forDefaultLanguage().matchingPhrase("milk and sugar")); List result = template.find(query, FullTextDoc.class); - assertThat(result, hasSize(1)); - assertThat(result, contains(MILK_AND_SUGAR)); + assertThat(result).hasSize(1); + assertThat(result).containsExactly(MILK_AND_SUGAR); } @Test // DATAMONGO-850 @@ -198,7 +194,7 @@ public class TextQueryTests extends AbstractIntegrationTests { TextQuery query = TextQuery.queryText(TextCriteria.forDefaultLanguage().matchingPhrase("milk no sugar")); List result = template.find(query, FullTextDoc.class); - assertThat(result, empty()); + assertThat(result).isEmpty(); } @Test // DATAMONGO-850 @@ -209,14 +205,14 @@ public class TextQueryTests extends AbstractIntegrationTests { // page 1 List result = template .find(new TextQuery("bake coffee cake").sortByScore().with(PageRequest.of(0, 2)), FullTextDoc.class); - assertThat(result, hasSize(2)); - assertThat(result, contains(BAKE, COFFEE)); + assertThat(result).hasSize(2); + assertThat(result).containsExactly(BAKE, COFFEE); // page 2 result = template.find(new TextQuery("bake coffee cake").sortByScore().with(PageRequest.of(1, 2)), FullTextDoc.class); - assertThat(result, hasSize(1)); - assertThat(result, contains(CAKE)); + assertThat(result).hasSize(1); + assertThat(result).containsExactly(CAKE); } private void initWithDefaultDocuments() { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextQueryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextQueryUnitTests.java index 82d2adb0a..9141d8ada 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextQueryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/TextQueryUnitTests.java @@ -15,10 +15,10 @@ */ package org.springframework.data.mongodb.core.query; -import static org.junit.Assert.*; -import static org.springframework.data.mongodb.core.query.IsTextQuery.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import org.junit.Test; + import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort.Direction; @@ -35,17 +35,21 @@ public class TextQueryUnitTests { @Test // DATAMONGO-850 public void shouldCreateQueryObjectCorrectly() { - assertThat(new TextQuery(QUERY), isTextQuery().searchingFor(QUERY)); + assertThat(new TextQuery(QUERY).getQueryObject()).containsEntry("$text.$search", QUERY); } @Test // DATAMONGO-850 public void shouldIncludeLanguageInQueryObjectWhenNotNull() { - assertThat(new TextQuery(QUERY, LANGUAGE_SPANISH), isTextQuery().searchingFor(QUERY).inLanguage(LANGUAGE_SPANISH)); + assertThat(new TextQuery(QUERY, LANGUAGE_SPANISH).getQueryObject()).containsEntry("$text.$search", QUERY) + .containsEntry("$text.$language", LANGUAGE_SPANISH); } @Test // DATAMONGO-850 public void shouldIncludeScoreFieldCorrectly() { - assertThat(new TextQuery(QUERY).includeScore(), isTextQuery().searchingFor(QUERY).returningScore()); + + TextQuery textQuery = new TextQuery(QUERY).includeScore(); + assertThat(textQuery.getQueryObject()).containsEntry("$text.$search", QUERY); + assertThat(textQuery.getFieldsObject()).containsKey("score"); } @Test // DATAMONGO-850 @@ -54,12 +58,18 @@ public class TextQueryUnitTests { TextQuery query = new TextQuery(TextCriteria.forDefaultLanguage().matching(QUERY)).includeScore(); query.fields().include("foo"); - assertThat(query, isTextQuery().searchingFor(QUERY).returningScore().includingField("foo")); + assertThat(query.getQueryObject()).containsEntry("$text.$search", QUERY); + assertThat(query.getFieldsObject()).containsKeys("score", "foo"); } @Test // DATAMONGO-850 public void shouldIncludeSortingByScoreCorrectly() { - assertThat(new TextQuery(QUERY).sortByScore(), isTextQuery().searchingFor(QUERY).returningScore().sortingByScore()); + + TextQuery textQuery = new TextQuery(QUERY).sortByScore(); + + assertThat(textQuery.getQueryObject()).containsEntry("$text.$search", QUERY); + assertThat(textQuery.getFieldsObject()).containsKey("score"); + assertThat(textQuery.getSortObject()).containsKey("score"); } @Test // DATAMONGO-850 @@ -69,15 +79,19 @@ public class TextQueryUnitTests { query.with(Sort.by(Direction.DESC, "foo")); query.sortByScore(); - assertThat(query, - isTextQuery().searchingFor(QUERY).returningScore().sortingByScore().sortingBy("foo", Direction.DESC)); + assertThat(query.getQueryObject()).containsEntry("$text.$search", QUERY); + assertThat(query.getFieldsObject()).containsKeys("score"); + assertThat(query.getSortObject()).containsEntry("foo", -1).containsKey("score"); } @Test // DATAMONGO-850 public void shouldUseCustomFieldnameForScoring() { + TextQuery query = new TextQuery(QUERY).includeScore("customFieldForScore").sortByScore(); - assertThat(query, isTextQuery().searchingFor(QUERY).returningScoreAs("customFieldForScore").sortingByScore()); + assertThat(query.getQueryObject()).containsEntry("$text.$search", QUERY); + assertThat(query.getFieldsObject()).containsKeys("customFieldForScore"); + assertThat(query.getSortObject()).containsKey("customFieldForScore"); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/UntypedExampleMatcherUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/UntypedExampleMatcherUnitTests.java index f0792c341..ff2511785 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/UntypedExampleMatcherUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/UntypedExampleMatcherUnitTests.java @@ -16,7 +16,6 @@ package org.springframework.data.mongodb.core.query; import static org.assertj.core.api.Assertions.*; -import static org.hamcrest.Matchers.*; import org.junit.Before; import org.junit.Test; @@ -32,7 +31,7 @@ public class UntypedExampleMatcherUnitTests { ExampleMatcher matcher; @Before - public void setUp() throws Exception { + public void setUp() { matcher = UntypedExampleMatcher.matching(); } @@ -125,7 +124,7 @@ public class UntypedExampleMatcherUnitTests { matcher = UntypedExampleMatcher.matching().withIgnorePaths("foo", "bar", "foo"); ExampleMatcher configuredExampleSpec = matcher.withIgnoreCase(); - assertThat(matcher).isNotEqualTo(sameInstance(configuredExampleSpec)); + assertThat(matcher).isNotSameAs(configuredExampleSpec); assertThat(matcher.getIgnoredPaths()).hasSize(2); assertThat(matcher.isIgnoreCaseEnabled()).isFalse(); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/script/ExecutableMongoScriptUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/script/ExecutableMongoScriptUnitTests.java index 403bd746a..341be5a5e 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/script/ExecutableMongoScriptUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/script/ExecutableMongoScriptUnitTests.java @@ -15,13 +15,12 @@ */ package org.springframework.data.mongodb.core.script; -import static org.hamcrest.core.IsEqual.*; -import static org.hamcrest.core.IsNull.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; + import org.springframework.util.ObjectUtils; /** @@ -54,8 +53,8 @@ public class ExecutableMongoScriptUnitTests { ExecutableMongoScript script = new ExecutableMongoScript(jsFunction); - assertThat(script.getCode(), notNullValue()); - assertThat(script.getCode().toString(), equalTo(jsFunction)); + assertThat(script.getCode()).isNotNull(); + assertThat(script.getCode().toString()).isEqualTo(jsFunction); } private void expectException(Class type, String... messageFragments) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/script/NamedMongoScriptUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/script/NamedMongoScriptUnitTests.java index 0599d7923..711dbde44 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/script/NamedMongoScriptUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/script/NamedMongoScriptUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.script; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; @@ -49,6 +48,6 @@ public class NamedMongoScriptUnitTests { String jsFunction = "function(x) { return x; }"; - assertThat(new NamedMongoScript("echo", jsFunction).getCode(), is(jsFunction)); + assertThat(new NamedMongoScript("echo", jsFunction).getCode()).isEqualTo(jsFunction); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/spel/ExpressionNodeUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/spel/ExpressionNodeUnitTests.java index ea74433cf..169f0d23f 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/spel/ExpressionNodeUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/spel/ExpressionNodeUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.core.spel; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Arrays; import java.util.Collection; @@ -26,6 +25,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.expression.spel.ExpressionState; import org.springframework.expression.spel.SpelNode; import org.springframework.expression.spel.ast.OpDivide; @@ -59,7 +59,7 @@ public class ExpressionNodeUnitTests { public void createsOperatorNodeForOperations() { for (SpelNode operator : operators) { - assertThat(ExpressionNode.from(operator, state), is(instanceOf(OperatorNode.class))); + assertThat(ExpressionNode.from(operator, state)).isInstanceOf(OperatorNode.class); } } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/gridfs/AntPathUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/gridfs/AntPathUnitTests.java index 4a606062b..88c684253 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/gridfs/AntPathUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/gridfs/AntPathUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.gridfs; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.regex.Pattern; @@ -35,8 +34,8 @@ public class AntPathUnitTests { AntPath path = new AntPath("**/foo/*-bar.xml"); String regex = path.toRegex(); - assertThat(Pattern.matches(regex, "foo/bar/foo/foo-bar.xml"), is(true)); - assertThat(Pattern.matches(regex, "foo/bar/foo/bar/foo-bar.xml"), is(false)); - assertThat(regex, is(".*\\Q/foo/\\E[^/]*\\Q-bar.xml\\E")); + assertThat(Pattern.matches(regex, "foo/bar/foo/foo-bar.xml")).isTrue(); + assertThat(Pattern.matches(regex, "foo/bar/foo/bar/foo-bar.xml")).isFalse(); + assertThat(regex).isEqualTo(".*\\Q/foo/\\E[^/]*\\Q-bar.xml\\E"); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/monitor/MongoMonitorIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/monitor/MongoMonitorIntegrationTests.java index 4402579a2..3fa4bf582 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/monitor/MongoMonitorIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/monitor/MongoMonitorIntegrationTests.java @@ -15,13 +15,13 @@ */ package org.springframework.data.mongodb.monitor; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.net.UnknownHostException; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @@ -59,8 +59,8 @@ public class MongoMonitorIntegrationTests { throw e; } - assertThat(hostName, is(notNullValue())); - assertThat(hostName, is("127.0.0.1")); + assertThat(hostName).isNotNull(); + assertThat(hostName).isEqualTo("127.0.0.1"); } @Test diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java index 444d8e902..1011b6b7d 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java @@ -16,10 +16,7 @@ package org.springframework.data.mongodb.repository; import static java.util.Arrays.*; -import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.Matchers.*; -import static org.hamcrest.Matchers.not; -import static org.junit.Assert.assertThat; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.geo.Metrics.*; import java.util.ArrayList; @@ -27,7 +24,6 @@ import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.List; -import java.util.Optional; import java.util.Set; import java.util.UUID; import java.util.regex.Pattern; @@ -36,12 +32,12 @@ import java.util.stream.IntStream; import java.util.stream.Stream; import org.bson.Document; -import org.hamcrest.Matchers; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DuplicateKeyException; import org.springframework.dao.IncorrectResultSizeDataAccessException; @@ -119,35 +115,32 @@ public abstract class AbstractPersonRepositoryIntegrationTests { } @Test - public void findsPersonById() throws Exception { + public void findsPersonById() { - assertThat(repository.findById(dave.getId().toString()), is(Optional.of(dave))); + assertThat(repository.findById(dave.getId())).contains(dave); } @Test - public void findsAllMusicians() throws Exception { + public void findsAllMusicians() { List result = repository.findAll(); - assertThat(result.size(), is(all.size())); - assertThat(result.containsAll(all), is(true)); + assertThat(result).hasSameSizeAs(all).containsAll(all); } @Test public void findsAllWithGivenIds() { - Iterable result = repository.findAllById(Arrays.asList(dave.id, boyd.id)); - assertThat(result, hasItems(dave, boyd)); - assertThat(result, not(hasItems(oliver, carter, stefan, leroi, alicia))); + Iterable result = repository.findAllById(asList(dave.id, boyd.id)); + assertThat(result).contains(dave, boyd).doesNotContain(oliver, carter, stefan, leroi, alicia); } @Test - public void deletesPersonCorrectly() throws Exception { + public void deletesPersonCorrectly() { repository.delete(dave); List result = repository.findAll(); - assertThat(result.size(), is(all.size() - 1)); - assertThat(result, not(hasItem(dave))); + assertThat(result).hasSize(all.size() - 1).doesNotContain(dave); } @Test @@ -157,33 +150,29 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List result = repository.findAll(); - assertThat(result.size(), is(all.size() - 1)); - assertThat(result, not(hasItem(dave))); + assertThat(result).hasSize(all.size() - 1).doesNotContain(dave); } @Test - public void findsPersonsByLastname() throws Exception { + public void findsPersonsByLastname() { List result = repository.findByLastname("Beauford"); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(carter)); + assertThat(result).hasSize(1).contains(carter); } @Test public void findsPersonsByFirstname() { List result = repository.findByThePersonsFirstname("Leroi"); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(leroi)); - assertThat(result.get(0).getAge(), is(nullValue())); + assertThat(result).hasSize(1).contains(leroi); + assertThat(result.get(0).getAge()).isNull(); } @Test - public void findsPersonsByFirstnameLike() throws Exception { + public void findsPersonsByFirstnameLike() { List result = repository.findByFirstnameLike("Bo*"); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(boyd)); + assertThat(result).hasSize(1).contains(boyd); } @Test // DATAMONGO-1608 @@ -196,96 +185,91 @@ public abstract class AbstractPersonRepositoryIntegrationTests { } @Test - public void findsPagedPersons() throws Exception { + public void findsPagedPersons() { Page result = repository.findAll(PageRequest.of(1, 2, Direction.ASC, "lastname", "firstname")); - assertThat(result.isFirst(), is(false)); - assertThat(result.isLast(), is(false)); - assertThat(result, hasItems(dave, stefan)); + assertThat(result.isFirst()).isFalse(); + assertThat(result.isLast()).isFalse(); + assertThat(result).contains(dave, stefan); } @Test - public void executesPagedFinderCorrectly() throws Exception { + public void executesPagedFinderCorrectly() { Page page = repository.findByLastnameLike("*a*", PageRequest.of(0, 2, Direction.ASC, "lastname", "firstname")); - assertThat(page.isFirst(), is(true)); - assertThat(page.isLast(), is(false)); - assertThat(page.getNumberOfElements(), is(2)); - assertThat(page, hasItems(carter, stefan)); + assertThat(page.isFirst()).isTrue(); + assertThat(page.isLast()).isFalse(); + assertThat(page.getNumberOfElements()).isEqualTo(2); + assertThat(page).contains(carter, stefan); } @Test - public void executesPagedFinderWithAnnotatedQueryCorrectly() throws Exception { + public void executesPagedFinderWithAnnotatedQueryCorrectly() { Page page = repository.findByLastnameLikeWithPageable(".*a.*", PageRequest.of(0, 2, Direction.ASC, "lastname", "firstname")); - assertThat(page.isFirst(), is(true)); - assertThat(page.isLast(), is(false)); - assertThat(page.getNumberOfElements(), is(2)); - assertThat(page, hasItems(carter, stefan)); + assertThat(page.isFirst()).isTrue(); + assertThat(page.isLast()).isFalse(); + assertThat(page.getNumberOfElements()).isEqualTo(2); + assertThat(page).contains(carter, stefan); } @Test - public void findsPersonInAgeRangeCorrectly() throws Exception { + public void findsPersonInAgeRangeCorrectly() { List result = repository.findByAgeBetween(40, 45); - assertThat(result.size(), is(2)); - assertThat(result, hasItems(dave, leroi)); + assertThat(result).hasSize(2).contains(dave, leroi); } @Test - public void findsPersonByShippingAddressesCorrectly() throws Exception { + public void findsPersonByShippingAddressesCorrectly() { Address address = new Address("Foo Street 1", "C0123", "Bar"); dave.setShippingAddresses(new HashSet
(asList(address))); repository.save(dave); - assertThat(repository.findByShippingAddresses(address), is(dave)); + assertThat(repository.findByShippingAddresses(address)).isEqualTo(dave); } @Test - public void findsPersonByAddressCorrectly() throws Exception { + public void findsPersonByAddressCorrectly() { Address address = new Address("Foo Street 1", "C0123", "Bar"); dave.setAddress(address); repository.save(dave); List result = repository.findByAddress(address); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test - public void findsPeopleByZipCode() throws Exception { + public void findsPeopleByZipCode() { Address address = new Address("Foo Street 1", "C0123", "Bar"); dave.setAddress(address); repository.save(dave); List result = repository.findByAddressZipCode(address.getZipCode()); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test - public void findsPeopleByQueryDslLastnameSpec() throws Exception { + public void findsPeopleByQueryDslLastnameSpec() { Iterable result = repository.findAll(person.lastname.eq("Matthews")); - assertThat(result, hasItem(dave)); - assertThat(result, not(hasItems(carter, boyd, stefan, leroi, alicia))); + assertThat(result).contains(dave).doesNotContain(carter, boyd, stefan, leroi, alicia); } @Test - public void findsPeopleByzipCodePredicate() throws Exception { + public void findsPeopleByzipCodePredicate() { Address address = new Address("Foo Street 1", "C0123", "Bar"); dave.setAddress(address); repository.save(dave); Iterable result = repository.findAll(person.address.zipCode.eq("C0123")); - assertThat(result, hasItem(dave)); - assertThat(result, not(hasItems(carter, boyd, stefan, leroi, alicia))); + assertThat(result).contains(dave).doesNotContain(carter, boyd, stefan, leroi, alicia); } @Test @@ -295,8 +279,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.save(dave); List result = repository.findByLocationNear(point); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test // DATAMONGO-1588 @@ -307,8 +290,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.save(dave); List result = repository.findByLocationNear(point); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test @@ -318,8 +300,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.save(dave); List result = repository.findByLocationWithin(new Circle(-78.99171, 45.738868, 170)); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test @@ -331,8 +312,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Box box = new Box(new Point(-78.99171, 35.738868), new Point(-68.99171, 45.738868)); List result = repository.findByLocationWithin(box); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test @@ -348,56 +328,54 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Point fourth = new Point(-68.99171, 35.738868); List result = repository.findByLocationWithin(new Polygon(first, second, third, fourth)); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test - public void findsPagedPeopleByPredicate() throws Exception { + public void findsPagedPeopleByPredicate() { Page page = repository.findAll(person.lastname.contains("a"), PageRequest.of(0, 2, Direction.ASC, "lastname")); - assertThat(page.isFirst(), is(true)); - assertThat(page.isLast(), is(false)); - assertThat(page.getNumberOfElements(), is(2)); - assertThat(page.getTotalElements(), is(4L)); - assertThat(page, hasItems(carter, stefan)); + assertThat(page.isFirst()).isTrue(); + assertThat(page.isLast()).isFalse(); + assertThat(page.getNumberOfElements()).isEqualTo(2); + assertThat(page.getTotalElements()).isEqualTo(4L); + assertThat(page).contains(carter, stefan); } @Test // DATADOC-136 public void findsPeopleBySexCorrectly() { List females = repository.findBySex(Sex.FEMALE); - assertThat(females.size(), is(1)); - assertThat(females.get(0), is(alicia)); + assertThat(females).hasSize(1); + assertThat(females.get(0)).isEqualTo(alicia); } @Test // DATAMONGO-446 public void findsPeopleBySexPaginated() { List males = repository.findBySex(Sex.MALE, PageRequest.of(0, 2)); - assertThat(males.size(), is(2)); + assertThat(males).hasSize(2); } @Test public void findsPeopleByNamedQuery() { List result = repository.findByNamedQuery("Dave"); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test // DATADOC-190 public void existsWorksCorrectly() { - assertThat(repository.existsById(dave.getId()), is(true)); + assertThat(repository.existsById(dave.getId())).isTrue(); } @Test(expected = DuplicateKeyException.class) public void rejectsDuplicateEmailAddressOnSave() { - assertThat(dave.getEmail(), is("dave@dmband.com")); + assertThat(dave.getEmail()).isEqualTo("dave@dmband.com"); Person daveSyer = new Person("Dave", "Syer"); - assertThat(daveSyer.getEmail(), is("dave@dmband.com")); + assertThat(daveSyer.getEmail()).isEqualTo("dave@dmband.com"); repository.save(daveSyer); } @@ -405,20 +383,20 @@ public abstract class AbstractPersonRepositoryIntegrationTests { @Test // DATADOC-236 public void findsPeopleByLastnameAndOrdersCorrectly() { List result = repository.findByLastnameOrderByFirstnameAsc("Matthews"); - assertThat(result.size(), is(2)); - assertThat(result.get(0), is(dave)); - assertThat(result.get(1), is(oliver)); + assertThat(result).hasSize(2); + assertThat(result.get(0)).isEqualTo(dave); + assertThat(result.get(1)).isEqualTo(oliver); } @Test // DATADOC-236 public void appliesStaticAndDynamicSorting() { List result = repository.findByFirstnameLikeOrderByLastnameAsc("*e*", Sort.by("age")); - assertThat(result.size(), is(5)); - assertThat(result.get(0), is(carter)); - assertThat(result.get(1), is(stefan)); - assertThat(result.get(2), is(oliver)); - assertThat(result.get(3), is(dave)); - assertThat(result.get(4), is(leroi)); + assertThat(result).hasSize(5); + assertThat(result.get(0)).isEqualTo(carter); + assertThat(result.get(1)).isEqualTo(stefan); + assertThat(result.get(2)).isEqualTo(oliver); + assertThat(result.get(3)).isEqualTo(dave); + assertThat(result.get(4)).isEqualTo(leroi); } @Test @@ -430,7 +408,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { GeoResults results = repository.findByLocationNear(new Point(-73.99, 40.73), new Distance(2000, Metrics.KILOMETERS)); - assertThat(results.getContent().isEmpty(), is(false)); + assertThat(results.getContent()).isNotEmpty(); } @Test @@ -442,10 +420,10 @@ public abstract class AbstractPersonRepositoryIntegrationTests { GeoPage results = repository.findByLocationNear(new Point(-73.99, 40.73), new Distance(2000, Metrics.KILOMETERS), PageRequest.of(0, 20)); - assertThat(results.getContent().isEmpty(), is(false)); + assertThat(results.getContent()).isNotEmpty(); // DATAMONGO-607 - assertThat(results.getAverageDistance().getMetric(), is((Metric) Metrics.KILOMETERS)); + assertThat(results.getAverageDistance().getMetric()).isEqualTo((Metric) Metrics.KILOMETERS); } @Test // DATAMONGO-323 @@ -453,20 +431,20 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List result = repository.findByAgeLessThan(60, Sort.by("firstname")); - assertThat(result.size(), is(7)); - assertThat(result.get(0), is(alicia)); - assertThat(result.get(1), is(boyd)); - assertThat(result.get(2), is(carter)); - assertThat(result.get(3), is(dave)); - assertThat(result.get(4), is(leroi)); - assertThat(result.get(5), is(oliver)); - assertThat(result.get(6), is(stefan)); + assertThat(result).hasSize(7); + assertThat(result.get(0)).isEqualTo(alicia); + assertThat(result.get(1)).isEqualTo(boyd); + assertThat(result.get(2)).isEqualTo(carter); + assertThat(result.get(3)).isEqualTo(dave); + assertThat(result.get(4)).isEqualTo(leroi); + assertThat(result.get(5)).isEqualTo(oliver); + assertThat(result.get(6)).isEqualTo(stefan); } @Test // DATAMONGO-347 public void executesQueryWithDBRefReferenceCorrectly() { - operations.remove(new org.springframework.data.mongodb.core.query.Query(), User.class); + operations.remove(new Query(), User.class); User user = new User(); user.username = "Oliver"; @@ -477,55 +455,49 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.save(dave); List result = repository.findByCreator(user); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test // DATAMONGO-425 public void bindsDateParameterForLessThanPredicateCorrectly() { List result = repository.findByCreatedAtLessThan(boyd.createdAt); - assertThat(result.size(), is(3)); - assertThat(result, hasItems(dave, oliver, carter)); + assertThat(result).hasSize(3).contains(dave, oliver, carter); } @Test // DATAMONGO-425 public void bindsDateParameterForGreaterThanPredicateCorrectly() { List result = repository.findByCreatedAtGreaterThan(carter.createdAt); - assertThat(result.size(), is(4)); - assertThat(result, hasItems(boyd, stefan, leroi, alicia)); + assertThat(result).hasSize(4).contains(boyd, stefan, leroi, alicia); } @Test // DATAMONGO-427 public void bindsDateParameterToBeforePredicateCorrectly() { List result = repository.findByCreatedAtBefore(boyd.createdAt); - assertThat(result.size(), is(3)); - assertThat(result, hasItems(dave, oliver, carter)); + assertThat(result).hasSize(3).contains(dave, oliver, carter); } @Test // DATAMONGO-427 public void bindsDateParameterForAfterPredicateCorrectly() { List result = repository.findByCreatedAtAfter(carter.createdAt); - assertThat(result.size(), is(4)); - assertThat(result, hasItems(boyd, stefan, leroi, alicia)); + assertThat(result).hasSize(4).contains(boyd, stefan, leroi, alicia); } @Test // DATAMONGO-425 public void bindsDateParameterForManuallyDefinedQueryCorrectly() { List result = repository.findByCreatedAtLessThanManually(boyd.createdAt); - assertThat(result.isEmpty(), is(false)); + assertThat(result).isNotEmpty(); } @Test // DATAMONGO-472 public void findsPeopleUsingNotPredicate() { List result = repository.findByLastnameNot("Matthews"); - assertThat(result, not(hasItem(dave))); - assertThat(result, hasSize(5)); + assertThat(result).doesNotContain(dave).hasSize(5); } @Test // DATAMONGO-521 @@ -533,13 +505,11 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List result = repository.findByFirstnameAndLastname("Dave", "Matthews"); - assertThat(result, hasSize(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); result = repository.findByFirstnameAndLastname("Oliver August", "Matthews"); - assertThat(result, hasSize(1)); - assertThat(result, hasItem(oliver)); + assertThat(result).hasSize(1).contains(oliver); } @Test // DATAMONGO-600 @@ -554,51 +524,48 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.save(dave); List result = repository.findByCredentials(usernameAndPassword); - assertThat(result, hasSize(1)); - assertThat(result, hasItem(dave)); + assertThat(result).hasSize(1).contains(dave); } @Test // DATAMONGO-636 public void executesDerivedCountProjection() { - assertThat(repository.countByLastname("Matthews"), is(2L)); + assertThat(repository.countByLastname("Matthews")).isEqualTo(2L); } @Test // DATAMONGO-636 public void executesDerivedCountProjectionToInt() { - assertThat(repository.countByFirstname("Oliver August"), is(1)); + assertThat(repository.countByFirstname("Oliver August")).isEqualTo(1); } @Test // DATAMONGO-636 public void executesAnnotatedCountProjection() { - assertThat(repository.someCountQuery("Matthews"), is(2L)); + assertThat(repository.someCountQuery("Matthews")).isEqualTo(2L); } @Test // DATAMONGO-1454 public void executesDerivedExistsProjectionToBoolean() { - assertThat(repository.existsByFirstname("Oliver August"), is(true)); - assertThat(repository.existsByFirstname("Hans Peter"), is(false)); + assertThat(repository.existsByFirstname("Oliver August")).isTrue(); + assertThat(repository.existsByFirstname("Hans Peter")).isFalse(); } @Test // DATAMONGO-1454 public void executesAnnotatedExistProjection() { - assertThat(repository.someExistQuery("Matthews"), is(true)); + assertThat(repository.someExistQuery("Matthews")).isTrue(); } @Test // DATAMONGO-701 public void executesDerivedStartsWithQueryCorrectly() { List result = repository.findByLastnameStartsWith("Matt"); - assertThat(result, hasSize(2)); - assertThat(result, hasItems(dave, oliver)); + assertThat(result).hasSize(2).contains(dave, oliver); } @Test // DATAMONGO-701 public void executesDerivedEndsWithQueryCorrectly() { List result = repository.findByLastnameEndsWith("thews"); - assertThat(result, hasSize(2)); - assertThat(result, hasItems(dave, oliver)); + assertThat(result).hasSize(2).contains(dave, oliver); } @Test // DATAMONGO-445 @@ -618,12 +585,12 @@ public abstract class AbstractPersonRepositoryIntegrationTests { GeoPage results = repository.findByLocationNear(new Point(-73.99, 40.73), new Distance(2000, Metrics.KILOMETERS), PageRequest.of(1, 2)); - assertThat(results.getContent().isEmpty(), is(false)); - assertThat(results.getNumberOfElements(), is(2)); - assertThat(results.isFirst(), is(false)); - assertThat(results.isLast(), is(false)); - assertThat(results.getAverageDistance().getMetric(), is((Metric) Metrics.KILOMETERS)); - assertThat(results.getAverageDistance().getNormalizedValue(), is(0.0)); + assertThat(results.getContent()).isNotEmpty(); + assertThat(results.getNumberOfElements()).isEqualTo(2); + assertThat(results.isFirst()).isFalse(); + assertThat(results.isLast()).isFalse(); + assertThat(results.getAverageDistance().getMetric()).isEqualTo((Metric) Metrics.KILOMETERS); + assertThat(results.getAverageDistance().getNormalizedValue()).isEqualTo(0.0); } @Test // DATAMONGO-445 @@ -639,11 +606,11 @@ public abstract class AbstractPersonRepositoryIntegrationTests { GeoPage results = repository.findByLocationNear(new Point(-73.99, 40.73), new Distance(2000, Metrics.KILOMETERS), PageRequest.of(1, 2)); - assertThat(results.getContent().isEmpty(), is(false)); - assertThat(results.getNumberOfElements(), is(1)); - assertThat(results.isFirst(), is(false)); - assertThat(results.isLast(), is(true)); - assertThat(results.getAverageDistance().getMetric(), is((Metric) Metrics.KILOMETERS)); + assertThat(results.getContent()).isNotEmpty(); + assertThat(results.getNumberOfElements()).isEqualTo(1); + assertThat(results.isFirst()).isFalse(); + assertThat(results.isLast()).isTrue(); + assertThat(results.getAverageDistance().getMetric()).isEqualTo((Metric) Metrics.KILOMETERS); } @Test // DATAMONGO-445 @@ -656,11 +623,11 @@ public abstract class AbstractPersonRepositoryIntegrationTests { GeoPage results = repository.findByLocationNear(new Point(-73.99, 40.73), new Distance(2000, Metrics.KILOMETERS), PageRequest.of(0, 2)); - assertThat(results.getContent().isEmpty(), is(false)); - assertThat(results.getNumberOfElements(), is(1)); - assertThat(results.isFirst(), is(true)); - assertThat(results.isLast(), is(true)); - assertThat(results.getAverageDistance().getMetric(), is((Metric) Metrics.KILOMETERS)); + assertThat(results.getContent()).isNotEmpty(); + assertThat(results.getNumberOfElements()).isEqualTo(1); + assertThat(results.isFirst()).isTrue(); + assertThat(results.isLast()).isTrue(); + assertThat(results.getAverageDistance().getMetric()).isEqualTo((Metric) Metrics.KILOMETERS); } @Test // DATAMONGO-445 @@ -672,11 +639,11 @@ public abstract class AbstractPersonRepositoryIntegrationTests { GeoPage results = repository.findByLocationNear(new Point(-73.99, 40.73), new Distance(2000, Metrics.KILOMETERS), PageRequest.of(1, 2)); - assertThat(results.getContent().isEmpty(), is(true)); - assertThat(results.getNumberOfElements(), is(0)); - assertThat(results.isFirst(), is(false)); - assertThat(results.isLast(), is(true)); - assertThat(results.getAverageDistance().getMetric(), is((Metric) Metrics.KILOMETERS)); + assertThat(results.getContent()).isEmpty(); + assertThat(results.getNumberOfElements()).isEqualTo(0); + assertThat(results.isFirst()).isFalse(); + assertThat(results.isLast()).isTrue(); + assertThat(results.getAverageDistance().getMetric()).isEqualTo((Metric) Metrics.KILOMETERS); } @Test // DATAMONGO-1608 @@ -693,8 +660,8 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List result = repository.findByFirstnameIgnoreCase("dave"); - assertThat(result.size(), is(1)); - assertThat(result.get(0), is(dave)); + assertThat(result).hasSize(1); + assertThat(result.get(0)).isEqualTo(dave); } @Test // DATAMONGO-770 @@ -702,32 +669,31 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List result = repository.findByFirstnameNotIgnoreCase("dave"); - assertThat(result.size(), is(6)); - assertThat(result, not(hasItem(dave))); + assertThat(result).hasSize(6).doesNotContain(dave); } @Test // DATAMONGO-770 public void findByFirstnameStartingWithIgnoreCase() { List result = repository.findByFirstnameStartingWithIgnoreCase("da"); - assertThat(result.size(), is(1)); - assertThat(result.get(0), is(dave)); + assertThat(result).hasSize(1); + assertThat(result.get(0)).isEqualTo(dave); } @Test // DATAMONGO-770 public void findByFirstnameEndingWithIgnoreCase() { List result = repository.findByFirstnameEndingWithIgnoreCase("VE"); - assertThat(result.size(), is(1)); - assertThat(result.get(0), is(dave)); + assertThat(result).hasSize(1); + assertThat(result.get(0)).isEqualTo(dave); } @Test // DATAMONGO-770 public void findByFirstnameContainingIgnoreCase() { List result = repository.findByFirstnameContainingIgnoreCase("AV"); - assertThat(result.size(), is(1)); - assertThat(result.get(0), is(dave)); + assertThat(result).hasSize(1); + assertThat(result.get(0)).isEqualTo(dave); } @Test // DATAMONGO-870 @@ -735,7 +701,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Slice result = repository.findByAgeGreaterThan(40, PageRequest.of(0, 2, Direction.DESC, "firstname")); - assertThat(result.hasNext(), is(true)); + assertThat(result.hasNext()).isTrue(); } @Test // DATAMONGO-871 @@ -743,8 +709,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Person[] result = repository.findByThePersonsFirstnameAsArray("Leroi"); - assertThat(result, is(arrayWithSize(1))); - assertThat(result, is(arrayContaining(leroi))); + assertThat(result).hasSize(1).containsExactly(leroi); } @Test // DATAMONGO-821 @@ -761,8 +726,8 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Page result = repository.findByHavingCreator(PageRequest.of(0, 100)); - assertThat(result.getNumberOfElements(), is(1)); - assertThat(result.getContent().get(0), is(alicia)); + assertThat(result.getNumberOfElements()).isEqualTo(1); + assertThat(result.getContent().get(0)).isEqualTo(alicia); } @Test // DATAMONGO-566 @@ -770,8 +735,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List result = repository.deleteByLastname("Beauford"); - assertThat(result, hasItem(carter)); - assertThat(result, hasSize(1)); + assertThat(result).contains(carter).hasSize(1); } @Test // DATAMONGO-566 @@ -779,22 +743,22 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.deleteByLastname("Beauford"); - assertThat(operations.count(new BasicQuery("{'lastname':'Beauford'}"), Person.class), is(0L)); + assertThat(operations.count(new BasicQuery("{'lastname':'Beauford'}"), Person.class)).isEqualTo(0L); } @Test // DATAMONGO-566 public void deleteByShouldReturnNumberOfDocumentsRemovedIfReturnTypeIsLong() { - assertThat(repository.deletePersonByLastname("Beauford"), is(1L)); + assertThat(repository.deletePersonByLastname("Beauford")).isEqualTo(1L); } @Test // DATAMONGO-566 public void deleteByShouldReturnZeroInCaseNoDocumentHasBeenRemovedAndReturnTypeIsNumber() { - assertThat(repository.deletePersonByLastname("dorfuaeB"), is(0L)); + assertThat(repository.deletePersonByLastname("dorfuaeB")).isEqualTo(0L); } @Test // DATAMONGO-566 public void deleteByShouldReturnEmptyListInCaseNoDocumentHasBeenRemovedAndReturnTypeIsCollectionLike() { - assertThat(repository.deleteByLastname("dorfuaeB"), empty()); + assertThat(repository.deleteByLastname("dorfuaeB")).isEmpty(); } @Test // DATAMONGO-566 @@ -802,8 +766,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List result = repository.removeByLastnameUsingAnnotatedQuery("Beauford"); - assertThat(result, hasItem(carter)); - assertThat(result, hasSize(1)); + assertThat(result).contains(carter).hasSize(1); } @Test // DATAMONGO-566 @@ -811,12 +774,12 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.removeByLastnameUsingAnnotatedQuery("Beauford"); - assertThat(operations.count(new BasicQuery("{'lastname':'Beauford'}"), Person.class), is(0L)); + assertThat(operations.count(new BasicQuery("{'lastname':'Beauford'}"), Person.class)).isEqualTo(0L); } @Test // DATAMONGO-566 public void deleteByUsingAnnotatedQueryShouldReturnNumberOfDocumentsRemovedIfReturnTypeIsLong() { - assertThat(repository.removePersonByLastnameUsingAnnotatedQuery("Beauford"), is(1L)); + assertThat(repository.removePersonByLastnameUsingAnnotatedQuery("Beauford")).isEqualTo(1L); } @Test // DATAMONGO-893 @@ -830,7 +793,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Page result = repository.findByAddressIn(Arrays.asList(adr), PageRequest.of(0, 10)); - assertThat(result.getContent(), hasSize(1)); + assertThat(result.getContent()).hasSize(1); } @Test // DATAMONGO-745 @@ -844,9 +807,9 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Page result = repository.findByCustomQueryFirstnamesAndLastname(Arrays.asList("bar", "foo", "fuu"), "bar", PageRequest.of(0, 2)); - assertThat(result.getContent(), hasSize(2)); - assertThat(result.getTotalPages(), is(2)); - assertThat(result.getTotalElements(), is(3L)); + assertThat(result.getContent()).hasSize(2); + assertThat(result.getTotalPages()).isEqualTo(2); + assertThat(result.getTotalElements()).isEqualTo(3L); } @Test // DATAMONGO-745 @@ -860,9 +823,9 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Page result = repository.findByCustomQueryLastnameAndAddressStreetInList("bar", Arrays.asList("street1", "street2"), PageRequest.of(0, 2)); - assertThat(result.getContent(), hasSize(2)); - assertThat(result.getTotalPages(), is(2)); - assertThat(result.getTotalElements(), is(3L)); + assertThat(result.getContent()).hasSize(2); + assertThat(result.getTotalPages()).isEqualTo(2); + assertThat(result.getTotalElements()).isEqualTo(3L); } @@ -872,7 +835,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.saveAll(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), new Person("Bob-3", "Dylan"), new Person("Bob-4", "Dylan"), new Person("Bob-5", "Dylan"))); List result = repository.findTop3ByLastnameStartingWith("Dylan"); - assertThat(result.size(), is(3)); + assertThat(result).hasSize(3); } @Test // DATAMONGO-950, DATAMONGO-1464 @@ -881,8 +844,8 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.saveAll(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), new Person("Bob-3", "Dylan"), new Person("Bob-4", "Dylan"), new Person("Bob-5", "Dylan"))); Page result = repository.findTop3ByLastnameStartingWith("Dylan", PageRequest.of(0, 2)); - assertThat(result.getContent().size(), is(2)); - assertThat(result.getTotalElements(), is(3L)); + assertThat(result.getContent()).hasSize(2); + assertThat(result.getTotalElements()).isEqualTo(3L); } @Test // DATAMONGO-950 @@ -891,7 +854,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.saveAll(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), new Person("Bob-3", "Dylan"), new Person("Bob-4", "Dylan"), new Person("Bob-5", "Dylan"))); Page result = repository.findTop3ByLastnameStartingWith("Dylan", PageRequest.of(1, 2)); - assertThat(result.getContent().size(), is(1)); + assertThat(result.getContent()).hasSize(1); } @Test // DATAMONGO-950, DATAMONGO-1464 @@ -900,8 +863,8 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.saveAll(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), new Person("Bob-3", "Dylan"), new Person("Bob-4", "Dylan"), new Person("Bob-5", "Dylan"))); Page result = repository.findTop3ByLastnameStartingWith("Dylan", PageRequest.of(100, 2)); - assertThat(result.getContent().size(), is(0)); - assertThat(result.getTotalElements(), is(3L)); + assertThat(result.getContent()).isEmpty(); + assertThat(result.getTotalElements()).isEqualTo(3L); } @Test // DATAMONGO-996, DATAMONGO-950, DATAMONGO-1464 @@ -909,10 +872,10 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Page slice = repository.findByLastnameLike("Matthews", PageRequest.of(1, 1)); - assertThat(slice.getContent(), hasSize(1)); - assertThat(slice.hasPrevious(), is(true)); - assertThat(slice.hasNext(), is(false)); - assertThat(slice.getTotalElements(), is(2L)); + assertThat(slice.getContent()).hasSize(1); + assertThat(slice.hasPrevious()).isTrue(); + assertThat(slice.hasNext()).isFalse(); + assertThat(slice.getTotalElements()).isEqualTo(2L); } @Test // DATAMONGO-972 @@ -928,12 +891,12 @@ public abstract class AbstractPersonRepositoryIntegrationTests { dave.setCreator(user); operations.save(dave); - assertThat(repository.findOne(QPerson.person.creator.eq(user)).get(), is(dave)); + assertThat(repository.findOne(QPerson.person.creator.eq(user)).get()).isEqualTo(dave); } @Test // DATAMONGO-969 public void shouldFindPersonsWhenUsingQueryDslPerdicatedOnIdProperty() { - assertThat(repository.findAll(person.id.in(Arrays.asList(dave.id, carter.id))), containsInAnyOrder(dave, carter)); + assertThat(repository.findAll(person.id.in(Arrays.asList(dave.id, carter.id)))).contains(dave, carter); } @Test // DATAMONGO-1030 @@ -941,9 +904,9 @@ public abstract class AbstractPersonRepositoryIntegrationTests { PersonSummaryDto result = repository.findSummaryByLastname("Beauford"); - assertThat(result, is(notNullValue())); - assertThat(result.firstname, is("Carter")); - assertThat(result.lastname, is("Beauford")); + assertThat(result).isNotNull(); + assertThat(result.firstname).isEqualTo("Carter"); + assertThat(result.lastname).isEqualTo("Beauford"); } @Test // DATAMONGO-1057 @@ -960,10 +923,10 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.saveAll(persons); Slice slice = repository.findByAgeGreaterThan(50, PageRequest.of(0, 20, Direction.ASC, "firstname")); - assertThat(slice, contains(persons.subList(0, 20).toArray())); + assertThat(slice).containsExactlyElementsOf(persons.subList(0, 20)); slice = repository.findByAgeGreaterThan(50, slice.nextPageable()); - assertThat(slice, contains(persons.subList(20, 40).toArray())); + assertThat(slice).containsExactlyElementsOf(persons.subList(20, 40)); } @Test // DATAMONGO-1072 @@ -971,8 +934,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List persons = repository.findByKeyValue("firstname", alicia.getFirstname()); - assertThat(persons, hasSize(1)); - assertThat(persons, hasItem(alicia)); + assertThat(persons).hasSize(1).contains(alicia); } @Test // DATAMONGO-1105 @@ -980,7 +942,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Iterable result = repository.findAll(person.firstname.asc()); - assertThat(result, contains(alicia, boyd, carter, dave, leroi, oliver, stefan)); + assertThat(result).containsExactly(alicia, boyd, carter, dave, leroi, oliver, stefan); } @Test // DATAMONGO-1085 @@ -1002,12 +964,12 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Iterable result = repository.findAll(person.firstname.isNotNull(), person.address.street.desc()); - assertThat(result, is(Matchers. iterableWithSize(persons.size()))); - assertThat(result.iterator().next().getFirstname(), is(persons.get(2).getFirstname())); + assertThat(result).hasSize(persons.size()); + assertThat(result.iterator().next().getFirstname()).isEqualTo(persons.get(2).getFirstname()); } @Test // DATAMONGO-1085 - public void shouldSupportSortingWithQSortByQueryDslOrderSpecifier() throws Exception { + public void shouldSupportSortingWithQSortByQueryDslOrderSpecifier() { repository.deleteAll(); @@ -1024,12 +986,12 @@ public abstract class AbstractPersonRepositoryIntegrationTests { PageRequest pageRequest = PageRequest.of(0, 2, new QSort(person.address.street.desc())); Iterable result = repository.findAll(pageRequest); - assertThat(result, is(Matchers. iterableWithSize(2))); - assertThat(result.iterator().next().getFirstname(), is("Siggi 2")); + assertThat(result).hasSize(2); + assertThat(result.iterator().next().getFirstname()).isEqualTo("Siggi 2"); } @Test // DATAMONGO-1085 - public void shouldSupportSortingWithQSort() throws Exception { + public void shouldSupportSortingWithQSort() { repository.deleteAll(); @@ -1045,17 +1007,17 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Iterable result = repository.findAll(new QSort(person.address.street.desc())); - assertThat(result, is(Matchers. iterableWithSize(persons.size()))); - assertThat(result.iterator().next().getFirstname(), is("Siggi 2")); + assertThat(result).hasSize(persons.size()); + assertThat(result.iterator().next().getFirstname()).isEqualTo("Siggi 2"); } @Test // DATAMONGO-1165 - public void shouldAllowReturningJava8StreamInCustomQuery() throws Exception { + public void shouldAllowReturningJava8StreamInCustomQuery() { Stream result = repository.findByCustomQueryWithStreamingCursorByFirstnames(Arrays.asList("Dave")); try { - assertThat(result.collect(Collectors. toList()), hasItems(dave)); + assertThat(result.collect(Collectors. toList())).contains(dave); } finally { result.close(); } @@ -1071,7 +1033,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Range range = Distance.between(new Distance(0.01, KILOMETERS), new Distance(2000, KILOMETERS)); GeoResults results = repository.findPersonByLocationNear(new Point(-73.99, 40.73), range); - assertThat(results.getContent().isEmpty(), is(false)); + assertThat(results.getContent()).isNotEmpty(); } @Test // DATAMONGO-990 @@ -1079,8 +1041,8 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List users = repository.findWithSpelByFirstnameForSpELExpressionWithParameterIndexOnly("Dave"); - assertThat(users, hasSize(1)); - assertThat(users.get(0), is(dave)); + assertThat(users).hasSize(1); + assertThat(users.get(0)).isEqualTo(dave); } @Test // DATAMONGO-990 @@ -1089,8 +1051,8 @@ public abstract class AbstractPersonRepositoryIntegrationTests { SampleSecurityContextHolder.getCurrent().setPrincipal(dave); List users = repository.findWithSpelByFirstnameAndCurrentUserWithCustomQuery("Dave"); - assertThat(users, hasSize(1)); - assertThat(users.get(0), is(dave)); + assertThat(users).hasSize(1); + assertThat(users.get(0)).isEqualTo(dave); } @Test // DATAMONGO-990 @@ -1098,8 +1060,8 @@ public abstract class AbstractPersonRepositoryIntegrationTests { List users = repository.findWithSpelByFirstnameForSpELExpressionWithParameterVariableOnly("Dave"); - assertThat(users, hasSize(1)); - assertThat(users.get(0), is(dave)); + assertThat(users).hasSize(1); + assertThat(users.get(0)).isEqualTo(dave); } @Test // DATAMONGO-1911 @@ -1110,7 +1072,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { Person dave = repository.findByUniqueId(this.dave.getUniqueId()); - assertThat(dave, is(equalTo(dave))); + assertThat(dave).isEqualTo(dave); } @Test // DATAMONGO-1245 @@ -1125,7 +1087,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { ReflectionTestUtils.setField(sample, "email", null); Page result = repository.findAll(Example.of(sample), PageRequest.of(0, 10)); - assertThat(result.getNumberOfElements(), is(2)); + assertThat(result.getNumberOfElements()).isEqualTo(2); } @Test // DATAMONGO-1245 @@ -1140,44 +1102,43 @@ public abstract class AbstractPersonRepositoryIntegrationTests { ReflectionTestUtils.setField(sample, "email", null); List result = repository.findAll(Example.of(sample)); - assertThat(result.size(), is(2)); + assertThat(result).hasSize(2); } @Test // DATAMONGO-1425 - public void findsPersonsByFirstnameNotContains() throws Exception { + public void findsPersonsByFirstnameNotContains() { List result = repository.findByFirstnameNotContains("Boyd"); - assertThat(result.size(), is((int) (repository.count() - 1))); - assertThat(result, not(hasItem(boyd))); + assertThat(result).hasSize((int) (repository.count() - 1)); + assertThat(result).doesNotContain(boyd); } @Test // DATAMONGO-1425 - public void findBySkillsContains() throws Exception { + public void findBySkillsContains() { - List result = repository.findBySkillsContains(Arrays.asList("Drums")); - assertThat(result.size(), is(1)); - assertThat(result, hasItem(carter)); + List result = repository.findBySkillsContains(asList("Drums")); + assertThat(result).hasSize(1).contains(carter); } @Test // DATAMONGO-1425 - public void findBySkillsNotContains() throws Exception { + public void findBySkillsNotContains() { List result = repository.findBySkillsNotContains(Arrays.asList("Drums")); - assertThat(result.size(), is((int) (repository.count() - 1))); - assertThat(result, not(hasItem(carter))); + assertThat(result).hasSize((int) (repository.count() - 1)); + assertThat(result).doesNotContain(carter); } @Test // DATAMONGO-1424 - public void findsPersonsByFirstnameNotLike() throws Exception { + public void findsPersonsByFirstnameNotLike() { List result = repository.findByFirstnameNotLike("Bo*"); - assertThat(result.size(), is((int) (repository.count() - 1))); - assertThat(result, not(hasItem(boyd))); + assertThat(result).hasSize((int) (repository.count() - 1)); + assertThat(result).doesNotContain(boyd); } @Test // DATAMONGO-1539 public void countsPersonsByFirstname() { - assertThat(repository.countByThePersonsFirstname("Dave"), is(1L)); + assertThat(repository.countByThePersonsFirstname("Dave")).isEqualTo(1L); } @Test // DATAMONGO-1539 @@ -1185,7 +1146,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { repository.deleteByThePersonsFirstname("Dave"); - assertThat(repository.countByThePersonsFirstname("Dave"), is(0L)); + assertThat(repository.countByThePersonsFirstname("Dave")).isEqualTo(0L); } @Test // DATAMONGO-1752 @@ -1258,7 +1219,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { operations.save(alicia); Person target = repository.findWithSliceInProjection(alicia.getId(), 0, 5); - assertThat(target.getFans().size()).isEqualTo(5); + assertThat(target.getFans()).hasSize(5); } @Test // DATAMONGO-2149 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ComplexIdRepositoryIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ComplexIdRepositoryIntegrationTests.java index 135cc7e17..07bccd127 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ComplexIdRepositoryIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ComplexIdRepositoryIntegrationTests.java @@ -15,19 +15,18 @@ */ package org.springframework.data.mongodb.repository; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Optional; -import org.hamcrest.Matchers; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.data.mongodb.config.AbstractMongoConfiguration; @@ -92,7 +91,7 @@ public class ComplexIdRepositoryIntegrationTests { repo.save(userWithId); - assertThat(repo.getUserByComplexId(id), is(userWithId)); + assertThat(repo.getUserByComplexId(id)).isEqualTo(userWithId); } @Test // DATAMONGO-1078 @@ -102,8 +101,8 @@ public class ComplexIdRepositoryIntegrationTests { List loaded = repo.findByUserIds(Collections.singleton(id)); - assertThat(loaded, hasSize(1)); - assertThat(loaded, contains(userWithId)); + assertThat(loaded).hasSize(1); + assertThat(loaded).containsExactly(userWithId); } @Test // DATAMONGO-1078 @@ -111,7 +110,7 @@ public class ComplexIdRepositoryIntegrationTests { repo.save(userWithId); - assertThat(repo.findById(id), is(Optional.of(userWithId))); + assertThat(repo.findById(id)).isEqualTo(Optional.of(userWithId)); } @Test // DATAMONGO-1078 @@ -121,8 +120,8 @@ public class ComplexIdRepositoryIntegrationTests { Iterable loaded = repo.findAllById(Collections.singleton(id)); - assertThat(loaded, is(Matchers. iterableWithSize(1))); - assertThat(loaded, contains(userWithId)); + assertThat(loaded).hasSize(1); + assertThat(loaded).containsExactly(userWithId); } @Test // DATAMONGO-1373 @@ -130,7 +129,7 @@ public class ComplexIdRepositoryIntegrationTests { repo.save(userWithId); - assertThat(repo.getUserUsingComposedAnnotationByComplexId(id), is(userWithId)); + assertThat(repo.getUserUsingComposedAnnotationByComplexId(id)).isEqualTo(userWithId); } @Test // DATAMONGO-1373 @@ -139,7 +138,7 @@ public class ComplexIdRepositoryIntegrationTests { repo.save(userWithId); - assertThat(repo.findUsersUsingComposedMetaAnnotationByUserIds(Arrays.asList(id)), hasSize(0)); + assertThat(repo.findUsersUsingComposedMetaAnnotationByUserIds(Arrays.asList(id))).hasSize(0); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ConvertingReactiveMongoRepositoryTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ConvertingReactiveMongoRepositoryTests.java index 5d4751943..3061548a6 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ConvertingReactiveMongoRepositoryTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ConvertingReactiveMongoRepositoryTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import io.reactivex.Flowable; import io.reactivex.Maybe; @@ -36,6 +35,7 @@ import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.reactivestreams.Publisher; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.ComponentScan.Filter; import org.springframework.context.annotation.ImportResource; @@ -143,7 +143,7 @@ public class ConvertingReactiveMongoRepositoryTests { .getOnNextEvents(); ProjectedPerson projectedPerson = people.get(0); - assertThat(projectedPerson.getFirstname(), is(equalTo(carter.getFirstname()))); + assertThat(projectedPerson.getFirstname()).isEqualTo(carter.getFirstname()); } @Test // DATAMONGO-1444 @@ -204,7 +204,7 @@ public class ConvertingReactiveMongoRepositoryTests { testObserver.assertNoErrors(); testObserver.assertValue(actual -> { - assertThat(actual.getFirstname(), is(equalTo(carter.getFirstname()))); + assertThat(actual.getFirstname()).isEqualTo(carter.getFirstname()); return true; }); } @@ -220,7 +220,7 @@ public class ConvertingReactiveMongoRepositoryTests { testObserver.assertNoErrors(); testObserver.assertValue(actual -> { - assertThat(actual.getFirstname(), is(equalTo(carter.getFirstname()))); + assertThat(actual.getFirstname()).isEqualTo(carter.getFirstname()); return true; }); } @@ -275,7 +275,7 @@ public class ConvertingReactiveMongoRepositoryTests { .assertCompleted() // .getOnNextEvents(); - assertThat(people, hasItems(carter, dave)); + assertThat(people).contains(carter, dave); } @Repository diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/MongoRepositoryTextSearchIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/MongoRepositoryTextSearchIntegrationTests.java index 6eab4a3be..b1bf524fc 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/MongoRepositoryTextSearchIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/MongoRepositoryTextSearchIntegrationTests.java @@ -15,11 +15,7 @@ */ package org.springframework.data.mongodb.repository; -import static org.hamcrest.collection.IsCollectionWithSize.*; -import static org.hamcrest.core.Is.*; -import static org.hamcrest.core.IsCollectionContaining.*; -import static org.hamcrest.core.IsEqual.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Arrays; import java.util.List; @@ -29,6 +25,7 @@ import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.annotation.Id; import org.springframework.data.domain.Page; @@ -95,8 +92,8 @@ public class MongoRepositoryTextSearchIntegrationTests { List result = repo.findAllBy(TextCriteria.forDefaultLanguage().matchingAny("stallone", "payne")); - assertThat(result, hasSize(2)); - assertThat(result, hasItems(PASSENGER_57, DEMOLITION_MAN)); + assertThat(result).hasSize(2); + assertThat(result).contains(PASSENGER_57, DEMOLITION_MAN); } @Test // DATAMONGO-973 @@ -111,8 +108,8 @@ public class MongoRepositoryTextSearchIntegrationTests { List result = repo.findByNonTextIndexProperty("foo", TextCriteria.forDefaultLanguage().matching("snipes")); - assertThat(result, hasSize(1)); - assertThat(result, hasItems(blade)); + assertThat(result).hasSize(1); + assertThat(result).contains(blade); } @Test // DATAMONGO-973 @@ -123,10 +120,10 @@ public class MongoRepositoryTextSearchIntegrationTests { Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("film"), PageRequest.of(1, 1, Direction.ASC, "id")); - assertThat(page.hasNext(), is(true)); - assertThat(page.hasPrevious(), is(true)); - assertThat(page.getTotalElements(), is(3L)); - assertThat(page.getContent().get(0), equalTo(DEMOLITION_MAN)); + assertThat(page.hasNext()).isTrue(); + assertThat(page.hasPrevious()).isTrue(); + assertThat(page.getTotalElements()).isEqualTo(3L); + assertThat(page.getContent().get(0)).isEqualTo(DEMOLITION_MAN); } @Test // DATAMONGO-973 @@ -139,8 +136,8 @@ public class MongoRepositoryTextSearchIntegrationTests { List result = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), Sort.by("score")); - assertThat(result.size(), is(4)); - assertThat(result.get(0), equalTo(snipes)); + assertThat(result.size()).isEqualTo(4); + assertThat(result.get(0)).isEqualTo(snipes); } @Test // DATAMONGO-973 @@ -153,8 +150,8 @@ public class MongoRepositoryTextSearchIntegrationTests { Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), PageRequest.of(0, 10, Direction.ASC, "score")); - assertThat(page.getTotalElements(), is(4L)); - assertThat(page.getContent().get(0), equalTo(snipes)); + assertThat(page.getTotalElements()).isEqualTo(4L); + assertThat(page.getContent().get(0)).isEqualTo(snipes); } @Test // DATAMONGO-973 @@ -167,8 +164,8 @@ public class MongoRepositoryTextSearchIntegrationTests { Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), PageRequest.of(0, 10, Direction.ASC, "id")); - assertThat(page.getTotalElements(), is(4L)); - assertThat(page.getContent().get(0), equalTo(PASSENGER_57)); + assertThat(page.getTotalElements()).isEqualTo(4L); + assertThat(page.getContent().get(0)).isEqualTo(PASSENGER_57); } @Test // DATAMONGO-973 @@ -180,7 +177,7 @@ public class MongoRepositoryTextSearchIntegrationTests { List result = repo .findByNonTextIndexPropertyIsNullOrderByScoreDesc(TextCriteria.forDefaultLanguage().matching("snipes")); - assertThat(result.get(0), equalTo(snipes)); + assertThat(result.get(0)).isEqualTo(snipes); } @Test // DATAMONGO-973 @@ -188,8 +185,8 @@ public class MongoRepositoryTextSearchIntegrationTests { initRepoWithDefaultDocuments(); List result = repo.findByTitle(DROP_ZONE.getTitle()); - assertThat(result.get(0), equalTo(DROP_ZONE)); - assertThat(result.get(0).score, equalTo(0.0F)); + assertThat(result.get(0)).isEqualTo(DROP_ZONE); + assertThat(result.get(0).score).isEqualTo(0.0F); } private void initRepoWithDefaultDocuments() { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepositoryLazyLoadingIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepositoryLazyLoadingIntegrationTests.java index 100de791e..51e567e35 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepositoryLazyLoadingIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepositoryLazyLoadingIntegrationTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.mongodb.core.convert.LazyLoadingTestUtils.*; import java.util.ArrayList; @@ -26,6 +25,7 @@ import java.util.List; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.core.MongoOperations; import org.springframework.test.context.ContextConfiguration; @@ -71,7 +71,7 @@ public class PersonRepositoryLazyLoadingIntegrationTests { User user = fans.get(0); assertProxyIsResolved(fans, true); - assertThat(user.getUsername(), is(thomas.getUsername())); + assertThat(user.getUsername()).isEqualTo(thomas.getUsername()); } @Test // DATAMONGO-348 @@ -93,13 +93,13 @@ public class PersonRepositoryLazyLoadingIntegrationTests { assertProxyIsResolved(realFans, false); User realFan = realFans.get(0); assertProxyIsResolved(realFans, true); - assertThat(realFan.getUsername(), is(thomas.getUsername())); + assertThat(realFan.getUsername()).isEqualTo(thomas.getUsername()); realFans = oliver.getRealFans(); assertProxyIsResolved(realFans, true); realFan = realFans.get(0); - assertThat(realFan.getUsername(), is(thomas.getUsername())); + assertThat(realFan.getUsername()).isEqualTo(thomas.getUsername()); } @Test // DATAMONGO-348 @@ -119,8 +119,8 @@ public class PersonRepositoryLazyLoadingIntegrationTests { User coworker = oliver.getCoworker(); assertProxyIsResolved(coworker, false); - assertThat(coworker.getUsername(), is(thomas.getUsername())); + assertThat(coworker.getUsername()).isEqualTo(thomas.getUsername()); assertProxyIsResolved(coworker, true); - assertThat(coworker.getUsername(), is(thomas.getUsername())); + assertThat(coworker.getUsername()).isEqualTo(thomas.getUsername()); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/RedeclaringRepositoryMethodsTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/RedeclaringRepositoryMethodsTests.java index 0598b2269..4a65e5400 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/RedeclaringRepositoryMethodsTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/RedeclaringRepositoryMethodsTests.java @@ -15,12 +15,12 @@ */ package org.springframework.data.mongodb.repository; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.List; import org.junit.Test; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.domain.Page; import org.springframework.data.domain.PageRequest; @@ -40,8 +40,8 @@ public class RedeclaringRepositoryMethodsTests extends AbstractPersonRepositoryI Page page = repository.findAll(PageRequest.of(0, 2)); - assertThat(page.getNumberOfElements(), is(1)); - assertThat(page.getContent().get(0).getFirstname(), is(oliver.getFirstname())); + assertThat(page.getNumberOfElements()).isEqualTo(1); + assertThat(page.getContent().get(0).getFirstname()).isEqualTo(oliver.getFirstname()); } @Test // DATAMONGO-760 @@ -49,6 +49,6 @@ public class RedeclaringRepositoryMethodsTests extends AbstractPersonRepositoryI List result = repository.findAll(); - assertThat(result.isEmpty(), is(true)); + assertThat(result.isEmpty()).isTrue(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/RepositoryIndexCreationIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/RepositoryIndexCreationIntegrationTests.java index 239c030e1..e8017daa2 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/RepositoryIndexCreationIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/RepositoryIndexCreationIntegrationTests.java @@ -15,15 +15,17 @@ */ package org.springframework.data.mongodb.repository; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.ArrayList; import java.util.Arrays; import java.util.List; +import org.bson.Document; import org.junit.After; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessException; import org.springframework.data.mongodb.core.CollectionCallback; @@ -32,7 +34,6 @@ import org.springframework.data.mongodb.core.index.IndexInfo; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import org.bson.Document; import com.mongodb.MongoException; import com.mongodb.client.MongoCollection; diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/SimpleReactiveMongoRepositoryTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/SimpleReactiveMongoRepositoryTests.java index 2a47f48df..4d252c086 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/SimpleReactiveMongoRepositoryTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/SimpleReactiveMongoRepositoryTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.springframework.data.domain.ExampleMatcher.*; import lombok.Data; @@ -30,6 +29,7 @@ import java.util.Arrays; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanClassLoaderAware; import org.springframework.beans.factory.BeanFactory; @@ -197,7 +197,7 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.insert(person)).expectNext(person).verifyComplete(); - assertThat(person.getId(), is(notNullValue())); + assertThat(person.getId()).isNotNull(); } @Test // DATAMONGO-1444 @@ -207,7 +207,7 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, repository.insert(person); - assertThat(person.getId(), is(nullValue())); + assertThat(person.getId()).isNull(); } @Test // DATAMONGO-1444 @@ -223,9 +223,9 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, .expectNext(dave, oliver, boyd) // .verifyComplete(); - assertThat(dave.getId(), is(notNullValue())); - assertThat(oliver.getId(), is(notNullValue())); - assertThat(boyd.getId(), is(notNullValue())); + assertThat(dave.getId()).isNotNull(); + assertThat(oliver.getId()).isNotNull(); + assertThat(boyd.getId()).isNotNull(); } @Test // DATAMONGO-1444 @@ -239,9 +239,9 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.insert(Flux.just(dave, oliver, boyd))).expectNextCount(3).verifyComplete(); - assertThat(dave.getId(), is(notNullValue())); - assertThat(oliver.getId(), is(notNullValue())); - assertThat(boyd.getId(), is(notNullValue())); + assertThat(dave.getId()).isNotNull(); + assertThat(oliver.getId()).isNotNull(); + assertThat(boyd.getId()).isNotNull(); } @Test // DATAMONGO-1444 @@ -256,8 +256,8 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.findById(dave.id)).consumeNextWith(actual -> { - assertThat(actual.getFirstname(), is(equalTo(dave.getFirstname()))); - assertThat(actual.getLastname(), is(equalTo(dave.getLastname()))); + assertThat(actual.getFirstname()).isEqualTo(dave.getFirstname()); + assertThat(actual.getLastname()).isEqualTo(dave.getLastname()); }).verifyComplete(); } @@ -270,8 +270,8 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.findById(person.id)).consumeNextWith(actual -> { - assertThat(actual.getFirstname(), is(equalTo(person.getFirstname()))); - assertThat(actual.getLastname(), is(equalTo(person.getLastname()))); + assertThat(actual.getFirstname()).isEqualTo(person.getFirstname()); + assertThat(actual.getLastname()).isEqualTo(person.getLastname()); }).verifyComplete(); } @@ -286,9 +286,9 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.saveAll(Arrays.asList(dave, oliver, boyd))).expectNextCount(3).verifyComplete(); - assertThat(dave.getId(), is(notNullValue())); - assertThat(oliver.getId(), is(notNullValue())); - assertThat(boyd.getId(), is(notNullValue())); + assertThat(dave.getId()).isNotNull(); + assertThat(oliver.getId()).isNotNull(); + assertThat(boyd.getId()).isNotNull(); } @Test // DATAMONGO-1444 @@ -303,7 +303,7 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.findById(dave.id)).expectNext(dave).verifyComplete(); - assertThat(person.id, is(notNullValue())); + assertThat(person.id).isNotNull(); StepVerifier.create(repository.findById(person.id)).expectNext(person).verifyComplete(); } @@ -318,9 +318,9 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.saveAll(Flux.just(dave, oliver, boyd))).expectNextCount(3).verifyComplete(); - assertThat(dave.getId(), is(notNullValue())); - assertThat(oliver.getId(), is(notNullValue())); - assertThat(boyd.getId(), is(notNullValue())); + assertThat(dave.getId()).isNotNull(); + assertThat(oliver.getId()).isNotNull(); + assertThat(boyd.getId()).isNotNull(); } @Test // DATAMONGO-1444 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiExtensionIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiExtensionIntegrationTests.java index df3fb3bed..4dee786e6 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiExtensionIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiExtensionIntegrationTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.cdi; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import javax.enterprise.inject.se.SeContainer; import javax.enterprise.inject.se.SeContainerInitializer; @@ -24,6 +23,7 @@ import javax.enterprise.inject.se.SeContainerInitializer; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; + import org.springframework.data.mongodb.repository.Person; /** @@ -56,21 +56,21 @@ public class CdiExtensionIntegrationTests { RepositoryClient client = container.select(RepositoryClient.class).get(); CdiPersonRepository repository = client.getRepository(); - assertThat(repository, is(notNullValue())); + assertThat(repository).isNotNull(); repository.deleteAll(); Person person = new Person("Dave", "Matthews"); Person result = repository.save(person); - assertThat(result, is(notNullValue())); - assertThat(repository.findById(person.getId()).get().getId(), is(result.getId())); + assertThat(result).isNotNull(); + assertThat(repository.findById(person.getId()).get().getId()).isEqualTo(result.getId()); } @Test // DATAMONGO-1017, DATAMONGO-1785 public void returnOneFromCustomImpl() { RepositoryClient repositoryConsumer = container.select(RepositoryClient.class).get(); - assertThat(repositoryConsumer.getSamplePersonRepository().returnOne(), is(1)); + assertThat(repositoryConsumer.getSamplePersonRepository().returnOne()).isEqualTo(1); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/MongoNamespaceIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/MongoNamespaceIntegrationTests.java index 3bef7bbdc..d911485f0 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/MongoNamespaceIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/MongoNamespaceIntegrationTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.repository.config; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Before; import org.junit.Test; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionReader; @@ -60,7 +60,7 @@ public class MongoNamespaceIntegrationTests extends AbstractPersonRepositoryInte reader.loadBeanDefinitions(new ClassPathResource("MongoNamespaceIntegrationTests-context.xml", getClass())); BeanDefinition definition = factory.getBeanDefinition("personRepository"); - assertThat(definition, is(notNullValue())); + assertThat(definition).isNotNull(); } @Test // DATAMONGO-581 @@ -68,7 +68,7 @@ public class MongoNamespaceIntegrationTests extends AbstractPersonRepositoryInte Repositories repositories = new Repositories(context); PersistentEntity entity = repositories.getPersistentEntity(Person.class); - assertThat(entity, is(notNullValue())); - assertThat(entity, is(instanceOf(MongoPersistentEntity.class))); + assertThat(entity).isNotNull(); + assertThat(entity).isInstanceOf(MongoPersistentEntity.class); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/MongoRepositoryConfigurationExtensionUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/MongoRepositoryConfigurationExtensionUnitTests.java index 916eed838..dafe97a2b 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/MongoRepositoryConfigurationExtensionUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/MongoRepositoryConfigurationExtensionUnitTests.java @@ -15,11 +15,12 @@ */ package org.springframework.data.mongodb.repository.config; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Collection; import org.junit.Test; + import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.core.env.Environment; diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/ReactiveMongoRepositoryConfigurationExtensionUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/ReactiveMongoRepositoryConfigurationExtensionUnitTests.java index 2ffc59f44..3722635ef 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/ReactiveMongoRepositoryConfigurationExtensionUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/ReactiveMongoRepositoryConfigurationExtensionUnitTests.java @@ -15,11 +15,12 @@ */ package org.springframework.data.mongodb.repository.config; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.Collection; import org.junit.Test; + import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.core.env.Environment; diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/lazy/AllowNestedMongoRepositoriesRepositoryConfigTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/lazy/AllowNestedMongoRepositoriesRepositoryConfigTests.java index 71b9661aa..dddfced0a 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/lazy/AllowNestedMongoRepositoriesRepositoryConfigTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/lazy/AllowNestedMongoRepositoriesRepositoryConfigTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.repository.config.lazy; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.repository.config.lazy.ClassWithNestedRepository.NestedUserRepository; import org.springframework.test.context.ContextConfiguration; @@ -38,6 +38,6 @@ public class AllowNestedMongoRepositoriesRepositoryConfigTests { @Test // DATAMONGO-780 public void shouldFindNestedRepository() { - assertThat(fooRepository, is(notNullValue())); + assertThat(fooRepository).isNotNull(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/lazy/NestedMongoRepositoriesJavaConfigTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/lazy/NestedMongoRepositoriesJavaConfigTests.java index 432bd7264..9a39c5f27 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/lazy/NestedMongoRepositoriesJavaConfigTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/config/lazy/NestedMongoRepositoriesJavaConfigTests.java @@ -15,11 +15,11 @@ */ package org.springframework.data.mongodb.repository.config.lazy; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.ImportResource; @@ -47,6 +47,6 @@ public class NestedMongoRepositoriesJavaConfigTests { @Test // DATAMONGO-780 public void shouldSupportNestedRepositories() { - assertThat(nestedUserRepository, is(notNullValue())); + assertThat(nestedUserRepository).isNotNull(); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/custom/CustomReactiveRepositoryImplementationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/custom/CustomReactiveRepositoryImplementationTests.java index 79cca5100..6e8626f3f 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/custom/CustomReactiveRepositoryImplementationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/custom/CustomReactiveRepositoryImplementationTests.java @@ -15,13 +15,13 @@ */ package org.springframework.data.mongodb.repository.custom; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.List; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.ImportResource; @@ -52,8 +52,8 @@ public class CustomReactiveRepositoryImplementationTests { String username = "bubu"; List users = customMongoRepository.findByUsernameCustom(username); - assertThat(users.size(), is(1)); - assertThat(users.get(0), is(notNullValue())); - assertThat(users.get(0).getUsername(), is(username)); + assertThat(users.size()).isEqualTo(1); + assertThat(users.get(0)).isNotNull(); + assertThat(users.get(0).getUsername()).isEqualTo(username); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/custom/CustomRepositoryImplementationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/custom/CustomRepositoryImplementationTests.java index 42c40c7ab..c68a8d2d0 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/custom/CustomRepositoryImplementationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/custom/CustomRepositoryImplementationTests.java @@ -15,13 +15,13 @@ */ package org.springframework.data.mongodb.repository.custom; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.util.List; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.ImportResource; @@ -52,8 +52,8 @@ public class CustomRepositoryImplementationTests { String username = "bubu"; List users = customMongoRepository.findByUsernameCustom(username); - assertThat(users.size(), is(1)); - assertThat(users.get(0), is(notNullValue())); - assertThat(users.get(0).getUsername(), is(username)); + assertThat(users.size()).isEqualTo(1); + assertThat(users.get(0)).isNotNull(); + assertThat(users.get(0).getUsername()).isEqualTo(username); } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ConvertingParameterAccessorUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ConvertingParameterAccessorUnitTests.java index a559c1783..a5e85e538 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ConvertingParameterAccessorUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ConvertingParameterAccessorUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.query; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import java.util.Arrays; @@ -27,6 +26,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.MongoDbFactory; import org.springframework.data.mongodb.core.convert.DbRefResolver; import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver; @@ -84,7 +84,7 @@ public class ConvertingParameterAccessorUnitTests { BasicDBList reference = new BasicDBList(); reference.add("Foo"); - assertThat(result, is((Object) reference)); + assertThat(result).isEqualTo((Object) reference); } @Test // DATAMONGO-505 @@ -95,10 +95,10 @@ public class ConvertingParameterAccessorUnitTests { Object result = setupAndConvert(property); - assertThat(result, is(instanceOf(com.mongodb.DBRef.class))); + assertThat(result).isInstanceOf(com.mongodb.DBRef.class); com.mongodb.DBRef dbRef = (com.mongodb.DBRef) result; - assertThat(dbRef.getCollectionName(), is("property")); - assertThat(dbRef.getId(), is((Object) 5L)); + assertThat(dbRef.getCollectionName()).isEqualTo("property"); + assertThat(dbRef.getId()).isEqualTo((Object) 5L); } @Test // DATAMONGO-505 @@ -109,16 +109,16 @@ public class ConvertingParameterAccessorUnitTests { Object result = setupAndConvert(Arrays.asList(property)); - assertThat(result, is(instanceOf(Collection.class))); + assertThat(result).isInstanceOf(Collection.class); Collection collection = (Collection) result; - assertThat(collection, hasSize(1)); + assertThat(collection).hasSize(1); Object element = collection.iterator().next(); - assertThat(element, is(instanceOf(com.mongodb.DBRef.class))); + assertThat(element).isInstanceOf(com.mongodb.DBRef.class); com.mongodb.DBRef dbRef = (com.mongodb.DBRef) element; - assertThat(dbRef.getCollectionName(), is("property")); - assertThat(dbRef.getId(), is((Object) 5L)); + assertThat(dbRef.getCollectionName()).isEqualTo("property"); + assertThat(dbRef.getId()).isEqualTo((Object) 5L); } private Object setupAndConvert(Object... parameters) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/MappingMongoEntityInformationUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/MappingMongoEntityInformationUnitTests.java index 778e2e6b4..aaa464ea1 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/MappingMongoEntityInformationUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/MappingMongoEntityInformationUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.query; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import lombok.Value; @@ -25,6 +24,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.domain.Persistable; import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity; import org.springframework.data.mongodb.repository.Person; @@ -48,14 +48,14 @@ public class MappingMongoEntityInformationUnitTests { when(info.getCollection()).thenReturn("Person"); MongoEntityInformation information = new MappingMongoEntityInformation(info); - assertThat(information.getCollectionName(), is("Person")); + assertThat(information.getCollectionName()).isEqualTo("Person"); } @Test // DATAMONGO-248 public void usesCustomCollectionIfGiven() { MongoEntityInformation information = new MappingMongoEntityInformation(info, "foobar"); - assertThat(information.getCollectionName(), is("foobar")); + assertThat(information.getCollectionName()).isEqualTo("foobar"); } @Test // DATAMONGO-1590 @@ -64,7 +64,7 @@ public class MappingMongoEntityInformationUnitTests { EntityInformation information = new MappingMongoEntityInformation<>( persistableImplementingEntityTypeInfo); - assertThat(information.isNew(new TypeImplementingPersistable(100L, false)), is(false)); + assertThat(information.isNew(new TypeImplementingPersistable(100L, false))).isFalse(); } @Value diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/MongoQueryMethodUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/MongoQueryMethodUnitTests.java index b7fa605df..cf061d3d9 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/MongoQueryMethodUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/MongoQueryMethodUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.query; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import java.lang.reflect.Method; import java.util.Collection; @@ -25,6 +24,7 @@ import java.util.List; import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; + import org.springframework.data.domain.Pageable; import org.springframework.data.geo.Distance; import org.springframework.data.geo.GeoPage; @@ -65,8 +65,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod queryMethod = queryMethod(SampleRepository.class, "method"); MongoEntityMetadata metadata = queryMethod.getEntityInformation(); - assertThat(metadata.getJavaType(), is(typeCompatibleWith(Address.class))); - assertThat(metadata.getCollectionName(), is("contact")); + assertThat(metadata.getJavaType()).isAssignableFrom(Address.class); + assertThat(metadata.getCollectionName()).isEqualTo("contact"); } @Test @@ -75,8 +75,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod queryMethod = queryMethod(SampleRepository2.class, "method"); MongoEntityMetadata entityInformation = queryMethod.getEntityInformation(); - assertThat(entityInformation.getJavaType(), is(typeCompatibleWith(Person.class))); - assertThat(entityInformation.getCollectionName(), is("person")); + assertThat(entityInformation.getJavaType()).isAssignableFrom(Person.class); + assertThat(entityInformation.getCollectionName()).isEqualTo("person"); } @Test @@ -84,20 +84,20 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod queryMethod = queryMethod(PersonRepository.class, "findByLocationNear", Point.class, Distance.class, Pageable.class); - assertThat(queryMethod.isGeoNearQuery(), is(true)); - assertThat(queryMethod.isPageQuery(), is(true)); + assertThat(queryMethod.isGeoNearQuery()).isTrue(); + assertThat(queryMethod.isPageQuery()).isTrue(); queryMethod = queryMethod(PersonRepository.class, "findByFirstname", String.class, Point.class); - assertThat(queryMethod.isGeoNearQuery(), is(true)); - assertThat(queryMethod.isPageQuery(), is(false)); - assertThat(queryMethod.getEntityInformation().getJavaType(), is(typeCompatibleWith(User.class))); + assertThat(queryMethod.isGeoNearQuery()).isTrue(); + assertThat(queryMethod.isPageQuery()).isFalse(); + assertThat(queryMethod.getEntityInformation().getJavaType()).isAssignableFrom(User.class); - assertThat(queryMethod(PersonRepository.class, "findByEmailAddress", String.class, Point.class).isGeoNearQuery(), - is(true)); - assertThat(queryMethod(PersonRepository.class, "findByFirstname", String.class, Point.class).isGeoNearQuery(), - is(true)); - assertThat(queryMethod(PersonRepository.class, "findByLastname", String.class, Point.class).isGeoNearQuery(), - is(true)); + assertThat(queryMethod(PersonRepository.class, "findByEmailAddress", String.class, Point.class).isGeoNearQuery()) + .isTrue(); + assertThat(queryMethod(PersonRepository.class, "findByFirstname", String.class, Point.class).isGeoNearQuery()) + .isTrue(); + assertThat(queryMethod(PersonRepository.class, "findByLastname", String.class, Point.class).isGeoNearQuery()) + .isTrue(); } @Test(expected = IllegalArgumentException.class) @@ -120,8 +120,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "findByLocationNear", Point.class, Distance.class, Pageable.class); - assertThat(method.isPageQuery(), is(true)); - assertThat(method.isCollectionQuery(), is(false)); + assertThat(method.isPageQuery()).isTrue(); + assertThat(method.isCollectionQuery()).isFalse(); } @Test @@ -135,8 +135,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "emptyMetaAnnotation"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().hasValues(), is(false)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().hasValues()).isFalse(); } @Test // DATAMONGO-957 @@ -144,8 +144,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "metaWithMaxExecutionTime"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getMaxTimeMsec(), is(100L)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getMaxTimeMsec()).isEqualTo(100L); } @Test // DATAMONGO-1311 @@ -153,8 +153,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "batchSize"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getCursorBatchSize(), is(100)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getCursorBatchSize()).isEqualTo(100); } @Test // DATAMONGO-1311 @@ -162,8 +162,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "negativeBatchSize"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getCursorBatchSize(), is(-200)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getCursorBatchSize()).isEqualTo(-200); } @Test // DATAMONGO-1403 @@ -171,8 +171,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "metaWithSpellFixedMaxExecutionTime"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getMaxTimeMsec(), is(100L)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getMaxTimeMsec()).isEqualTo(100L); } @Test // DATAMONGO-957 @@ -180,8 +180,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "metaWithMaxScan"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getMaxScan(), is(10L)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getMaxScan()).isEqualTo(10L); } @Test // DATAMONGO-957 @@ -189,8 +189,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "metaWithComment"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getComment(), is("foo bar")); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getComment()).isEqualTo("foo bar"); } @Test // DATAMONGO-957 @@ -198,8 +198,8 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "metaWithSnapshotUsage"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getSnapshot(), is(true)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getSnapshot()).isTrue(); } @Test // DATAMONGO-1480 @@ -207,9 +207,9 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "metaWithNoCursorTimeout"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getFlags(), - containsInAnyOrder(org.springframework.data.mongodb.core.query.Meta.CursorOption.NO_TIMEOUT)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getFlags()) + .contains(org.springframework.data.mongodb.core.query.Meta.CursorOption.NO_TIMEOUT); } @Test // DATAMONGO-1480 @@ -217,10 +217,10 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "metaWithMultipleFlags"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getFlags(), - containsInAnyOrder(org.springframework.data.mongodb.core.query.Meta.CursorOption.NO_TIMEOUT, - org.springframework.data.mongodb.core.query.Meta.CursorOption.SLAVE_OK)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getFlags()).contains( + org.springframework.data.mongodb.core.query.Meta.CursorOption.NO_TIMEOUT, + org.springframework.data.mongodb.core.query.Meta.CursorOption.SLAVE_OK); } @Test // DATAMONGO-1266 @@ -228,7 +228,7 @@ public class MongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "deleteByUserName", String.class); - assertThat(method.getEntityInformation().getJavaType(), is(typeCompatibleWith(User.class))); + assertThat(method.getEntityInformation().getJavaType()).isAssignableFrom(User.class); } @Test // DATAMONGO-2153 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/PartTreeMongoQueryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/PartTreeMongoQueryUnitTests.java index 5759fcce4..1ab7542cd 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/PartTreeMongoQueryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/PartTreeMongoQueryUnitTests.java @@ -15,11 +15,9 @@ */ package org.springframework.data.mongodb.repository.query; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; -import static org.springframework.data.mongodb.core.query.IsTextQuery.*; +import static org.springframework.data.mongodb.test.util.Assertions.*; import java.lang.reflect.Method; import java.util.List; @@ -43,7 +41,6 @@ import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver; import org.springframework.data.mongodb.core.convert.MappingMongoConverter; import org.springframework.data.mongodb.core.convert.MongoConverter; import org.springframework.data.mongodb.core.mapping.MongoMappingContext; -import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.data.mongodb.core.query.TextCriteria; import org.springframework.data.mongodb.repository.MongoRepository; import org.springframework.data.mongodb.repository.Person; @@ -98,7 +95,7 @@ public class PartTreeMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findByFirstname", "foo"); - assertThat(query.getFieldsObject(), is(new Document().append("firstname", 1))); + assertThat(query.getFieldsObject()).isEqualTo(new Document().append("firstname", 1)); } @Test // DATAMOGO-952 @@ -107,7 +104,7 @@ public class PartTreeMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findByFirstnameAndLastname", "foo", "bar"); - assertThat(query.getFieldsObject(), is(new Document().append("firstname", 1).append("lastname", 1))); + assertThat(query.getFieldsObject()).isEqualTo(new Document().append("firstname", 1).append("lastname", 1)); } @Test // DATAMOGO-952 @@ -116,7 +113,7 @@ public class PartTreeMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findPersonByFirstnameAndLastname", "foo", "bar"); - assertThat(query.getFieldsObject(), is(new Document().append("firstname", 0).append("lastname", 0))); + assertThat(query.getFieldsObject()).isEqualTo(new Document().append("firstname", 0).append("lastname", 0)); } @Test // DATAMOGO-973 @@ -125,21 +122,19 @@ public class PartTreeMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findPersonByFirstname", "text", TextCriteria.forDefaultLanguage().matching("search")); - assertThat(query, isTextQuery().searchingFor("search").where(new Criteria("firstname").is("text"))); + assertThat(query.getQueryObject()).containsEntry("$text.$search", "search").containsEntry("firstname", "text"); } @Test // DATAMONGO-1180 public void propagatesRootExceptionForInvalidQuery() { - exception.expect(IllegalStateException.class); - exception.expectCause(is(instanceOf(JsonParseException.class))); - - deriveQueryFromMethod("findByAge", 1); + assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> deriveQueryFromMethod("findByAge", 1)) + .withCauseInstanceOf(JsonParseException.class); } @Test // DATAMONGO-1345, DATAMONGO-1735 public void doesNotDeriveFieldSpecForNormalDomainType() { - assertThat(deriveQueryFromMethod("findPersonBy", new Object[0]).getFieldsObject(), is(new Document())); + assertThat(deriveQueryFromMethod("findPersonBy", new Object[0]).getFieldsObject()).isEqualTo(new Document()); } @Test // DATAMONGO-1345 @@ -147,8 +142,8 @@ public class PartTreeMongoQueryUnitTests { Document fieldsObject = deriveQueryFromMethod("findPersonProjectedBy", new Object[0]).getFieldsObject(); - assertThat(fieldsObject.get("firstname"), is(1)); - assertThat(fieldsObject.get("lastname"), is(1)); + assertThat(fieldsObject.get("firstname")).isEqualTo(1); + assertThat(fieldsObject.get("lastname")).isEqualTo(1); } @Test // DATAMONGO-1345 @@ -156,8 +151,8 @@ public class PartTreeMongoQueryUnitTests { Document fieldsObject = deriveQueryFromMethod("findPersonDtoByAge", new Object[] { 42 }).getFieldsObject(); - assertThat(fieldsObject.get("firstname"), is(1)); - assertThat(fieldsObject.get("lastname"), is(1)); + assertThat(fieldsObject.get("firstname")).isEqualTo(1); + assertThat(fieldsObject.get("lastname")).isEqualTo(1); } @Test // DATAMONGO-1345 @@ -165,9 +160,9 @@ public class PartTreeMongoQueryUnitTests { Document fields = deriveQueryFromMethod("findDynamicallyProjectedBy", ExtendedProjection.class).getFieldsObject(); - assertThat(fields.get("firstname"), is(1)); - assertThat(fields.get("lastname"), is(1)); - assertThat(fields.get("age"), is(1)); + assertThat(fields.get("firstname")).isEqualTo(1); + assertThat(fields.get("lastname")).isEqualTo(1); + assertThat(fields.get("age")).isEqualTo(1); } @Test // DATAMONGO-1500 @@ -175,8 +170,8 @@ public class PartTreeMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findBySex", Sex.FEMALE); - assertThat(query.getQueryObject().get("sex"), is(Sex.FEMALE)); - assertThat(query.getFieldsObject().get("firstname"), is(1)); + assertThat(query.getQueryObject().get("sex")).isEqualTo(Sex.FEMALE); + assertThat(query.getFieldsObject().get("firstname")).isEqualTo(1); } @Test // DATAMONGO-1729, DATAMONGO-1735 @@ -184,17 +179,17 @@ public class PartTreeMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = deriveQueryFromMethod("findAllBy"); - assertThat(query.getFieldsObject(), is(new Document())); + assertThat(query.getFieldsObject()).isEqualTo(new Document()); } @Test // DATAMONGO-1865 public void limitingReturnsTrueIfTreeIsLimiting() { - assertThat(createQueryForMethod("findFirstBy").isLimiting(), is(true)); + assertThat(createQueryForMethod("findFirstBy").isLimiting()).isTrue(); } @Test // DATAMONGO-1865 public void limitingReturnsFalseIfTreeIsNotLimiting() { - assertThat(createQueryForMethod("findPersonBy").isLimiting(), is(false)); + assertThat(createQueryForMethod("findPersonBy").isLimiting()).isFalse(); } private org.springframework.data.mongodb.core.query.Query deriveQueryFromMethod(String method, Object... args) { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryExecutionUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryExecutionUnitTests.java index d88573148..4ac249af6 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryExecutionUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryExecutionUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.query; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; @@ -30,6 +29,7 @@ import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Range; @@ -73,10 +73,10 @@ public class ReactiveMongoQueryExecutionUnitTests { verify(operations).geoNear(queryArgumentCaptor.capture(), eq(Person.class), eq("person")); NearQuery nearQuery = queryArgumentCaptor.getValue(); - assertThat(nearQuery.toDocument().get("near"), is(equalTo(Arrays.asList(1d, 2d)))); - assertThat(nearQuery.getSkip(), is(10L)); - assertThat(nearQuery.getMinDistance(), is(equalTo(new Distance(10)))); - assertThat(nearQuery.getMaxDistance(), is(equalTo(new Distance(15)))); + assertThat(nearQuery.toDocument().get("near")).isEqualTo(Arrays.asList(1d, 2d)); + assertThat(nearQuery.getSkip()).isEqualTo(10L); + assertThat(nearQuery.getMinDistance()).isEqualTo(new Distance(10)); + assertThat(nearQuery.getMaxDistance()).isEqualTo(new Distance(15)); } @Test // DATAMONGO-1444 @@ -95,10 +95,10 @@ public class ReactiveMongoQueryExecutionUnitTests { verify(operations).geoNear(queryArgumentCaptor.capture(), eq(Person.class), eq("person")); NearQuery nearQuery = queryArgumentCaptor.getValue(); - assertThat(nearQuery.toDocument().get("near"), is(equalTo(Arrays.asList(1d, 2d)))); - assertThat(nearQuery.getSkip(), is(0L)); - assertThat(nearQuery.getMinDistance(), is(nullValue())); - assertThat(nearQuery.getMaxDistance(), is(nullValue())); + assertThat(nearQuery.toDocument().get("near")).isEqualTo(Arrays.asList(1d, 2d)); + assertThat(nearQuery.getSkip()).isEqualTo(0L); + assertThat(nearQuery.getMinDistance()).isNull(); + assertThat(nearQuery.getMaxDistance()).isNull(); } interface GeoRepo { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryMethodUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryMethodUnitTests.java index 1230f7748..a001030dc 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryMethodUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryMethodUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.query; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @@ -27,6 +26,7 @@ import java.util.List; import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; + import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; @@ -66,8 +66,8 @@ public class ReactiveMongoQueryMethodUnitTests { ReactiveMongoQueryMethod queryMethod = queryMethod(SampleRepository.class, "method"); MongoEntityMetadata metadata = queryMethod.getEntityInformation(); - assertThat(metadata.getJavaType(), is(typeCompatibleWith(Address.class))); - assertThat(metadata.getCollectionName(), is("contact")); + assertThat(metadata.getJavaType()).isAssignableFrom(Address.class); + assertThat(metadata.getCollectionName()).isEqualTo("contact"); } @Test // DATAMONGO-1444 @@ -76,8 +76,8 @@ public class ReactiveMongoQueryMethodUnitTests { MongoQueryMethod queryMethod = queryMethod(SampleRepository2.class, "method"); MongoEntityMetadata entityInformation = queryMethod.getEntityInformation(); - assertThat(entityInformation.getJavaType(), is(typeCompatibleWith(Person.class))); - assertThat(entityInformation.getCollectionName(), is("person")); + assertThat(entityInformation.getJavaType()).isAssignableFrom(Person.class); + assertThat(entityInformation.getCollectionName()).isEqualTo("person"); } @Test // DATAMONGO-1444 @@ -85,20 +85,20 @@ public class ReactiveMongoQueryMethodUnitTests { MongoQueryMethod queryMethod = queryMethod(PersonRepository.class, "findByLocationNear", Point.class, Distance.class, Pageable.class); - assertThat(queryMethod.isGeoNearQuery(), is(false)); - assertThat(queryMethod.isPageQuery(), is(false)); + assertThat(queryMethod.isGeoNearQuery()).isFalse(); + assertThat(queryMethod.isPageQuery()).isFalse(); queryMethod = queryMethod(PersonRepository.class, "findByFirstname", String.class, Point.class); - assertThat(queryMethod.isGeoNearQuery(), is(false)); - assertThat(queryMethod.isPageQuery(), is(false)); - assertThat(queryMethod.getEntityInformation().getJavaType(), is(typeCompatibleWith(User.class))); + assertThat(queryMethod.isGeoNearQuery()).isFalse(); + assertThat(queryMethod.isPageQuery()).isFalse(); + assertThat(queryMethod.getEntityInformation().getJavaType()).isAssignableFrom(User.class); - assertThat(queryMethod(PersonRepository.class, "findByEmailAddress", String.class, Point.class).isGeoNearQuery(), - is(true)); - assertThat(queryMethod(PersonRepository.class, "findByFirstname", String.class, Point.class).isGeoNearQuery(), - is(false)); - assertThat(queryMethod(PersonRepository.class, "findByLastname", String.class, Point.class).isGeoNearQuery(), - is(true)); + assertThat(queryMethod(PersonRepository.class, "findByEmailAddress", String.class, Point.class).isGeoNearQuery()) + .isTrue(); + assertThat(queryMethod(PersonRepository.class, "findByFirstname", String.class, Point.class).isGeoNearQuery()) + .isFalse(); + assertThat(queryMethod(PersonRepository.class, "findByLastname", String.class, Point.class).isGeoNearQuery()) + .isTrue(); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-1444 @@ -125,8 +125,8 @@ public class ReactiveMongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "emptyMetaAnnotation"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().hasValues(), is(false)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().hasValues()).isFalse(); } @Test // DATAMONGO-1444 @@ -134,8 +134,8 @@ public class ReactiveMongoQueryMethodUnitTests { MongoQueryMethod method = queryMethod(PersonRepository.class, "metaWithMaxExecutionTime"); - assertThat(method.hasQueryMetaAttributes(), is(true)); - assertThat(method.getQueryMetaAttributes().getMaxTimeMsec(), is(100L)); + assertThat(method.hasQueryMetaAttributes()).isTrue(); + assertThat(method.getQueryMetaAttributes().getMaxTimeMsec()).isEqualTo(100L); } @Test(expected = InvalidDataAccessApiUsageException.class) // DATAMONGO-1444 @@ -153,7 +153,7 @@ public class ReactiveMongoQueryMethodUnitTests { ReactiveMongoQueryMethod method = queryMethod(PersonRepository.class, "deleteByUserName", String.class); - assertThat(method.getEntityInformation().getJavaType(), is(typeCompatibleWith(User.class))); + assertThat(method.getEntityInformation().getJavaType()).isAssignableFrom(User.class); } @Test // DATAMONGO-2153 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveStringBasedMongoQueryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveStringBasedMongoQueryUnitTests.java index f0a2fe83d..453523faa 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveStringBasedMongoQueryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/ReactiveStringBasedMongoQueryUnitTests.java @@ -15,9 +15,8 @@ */ package org.springframework.data.mongodb.repository.query; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; -import static org.mockito.ArgumentMatchers.any; +import static org.assertj.core.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; import reactor.core.publisher.Flux; @@ -27,13 +26,13 @@ import java.lang.reflect.Method; import java.util.Collections; import java.util.Map; -import org.bson.BSON; import org.bson.Document; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mongodb.core.ReactiveFindOperation.ReactiveFind; import org.springframework.data.mongodb.core.ReactiveMongoOperations; import org.springframework.data.mongodb.core.convert.DbRefResolver; @@ -87,7 +86,7 @@ public class ReactiveStringBasedMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = mongoQuery.createQuery(accesor); org.springframework.data.mongodb.core.query.Query reference = new BasicQuery("{'lastname' : 'Matthews'}"); - assertThat(query.getQueryObject(), is(reference.getQueryObject())); + assertThat(query.getQueryObject()).isEqualTo(reference.getQueryObject()); } @Test // DATAMONGO-1444 @@ -106,14 +105,14 @@ public class ReactiveStringBasedMongoQueryUnitTests { Document queryObject = new Document("address", dbObject); org.springframework.data.mongodb.core.query.Query reference = new BasicQuery(queryObject); - assertThat(query.getQueryObject().toJson(), is(reference.getQueryObject().toJson())); + assertThat(query.getQueryObject().toJson()).isEqualTo(reference.getQueryObject().toJson()); } @Test // DATAMONGO-1444 public void constructsDeleteQueryCorrectly() throws Exception { ReactiveStringBasedMongoQuery mongoQuery = createQueryForMethod("removeByLastname", String.class); - assertThat(mongoQuery.isDeleteQuery(), is(true)); + assertThat(mongoQuery.isDeleteQuery()).isTrue(); } @Test(expected = IllegalArgumentException.class) // DATAMONGO-1444 @@ -126,7 +125,7 @@ public class ReactiveStringBasedMongoQueryUnitTests { ReactiveStringBasedMongoQuery mongoQuery = createQueryForMethod("existsByLastname", String.class); - assertThat(mongoQuery.isExistsQuery(), is(true)); + assertThat(mongoQuery.isExistsQuery()).isTrue(); } @Test // DATAMONGO-1444 @@ -139,9 +138,9 @@ public class ReactiveStringBasedMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = mongoQuery.createQuery(accessor); - assertThat(query.getQueryObject(), - is(new BasicQuery("{ \"firstname\": \"first\", \"lastname\": \"last\"}").getQueryObject())); - assertThat(query.getFieldsObject(), is(new BasicQuery(null, "{ \"lastname\": 1}").getFieldsObject())); + assertThat(query.getQueryObject()) + .isEqualTo(new BasicQuery("{ \"firstname\": \"first\", \"lastname\": \"last\"}").getQueryObject()); + assertThat(query.getFieldsObject()).isEqualTo(new BasicQuery(null, "{ \"lastname\": 1}").getFieldsObject()); } @Test // DATAMONGO-1444 @@ -153,9 +152,9 @@ public class ReactiveStringBasedMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = mongoQuery.createQuery(accessor); - assertThat(query.getQueryObject(), - is(new BasicQuery("{$where: 'return this.date.getUTCMonth() == 3 && this.date.getUTCDay() == 4;'}") - .getQueryObject())); + assertThat(query.getQueryObject()) + .isEqualTo(new BasicQuery("{$where: 'return this.date.getUTCMonth() == 3 && this.date.getUTCDay() == 4;'}") + .getQueryObject()); } @Test // DATAMONGO-1444 @@ -167,7 +166,7 @@ public class ReactiveStringBasedMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = mongoQuery.createQuery(parameterAccessor); - assertThat(query.getQueryObject(), is(new Document().append("key", "value"))); + assertThat(query.getQueryObject()).isEqualTo(new Document().append("key", "value")); } @Test // DATAMONGO-1444 @@ -179,7 +178,7 @@ public class ReactiveStringBasedMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = mongoQuery.createQuery(accesor); org.springframework.data.mongodb.core.query.Query reference = new BasicQuery("{'lastname' : 'Matthews'}"); - assertThat(query.getQueryObject(), is(reference.getQueryObject())); + assertThat(query.getQueryObject()).isEqualTo(reference.getQueryObject()); } @Test // DATAMONGO-1444 @@ -192,7 +191,7 @@ public class ReactiveStringBasedMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query query = mongoQuery.createQuery(accesor); org.springframework.data.mongodb.core.query.Query reference = new BasicQuery("{ \"id\" : { \"$exists\" : true}}"); - assertThat(query.getQueryObject(), is(reference.getQueryObject())); + assertThat(query.getQueryObject()).isEqualTo(reference.getQueryObject()); } @Test // DATAMONGO-1444 @@ -206,7 +205,7 @@ public class ReactiveStringBasedMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query reference = new BasicQuery( "{ \"id\" : { \"$exists\" : true} , \"foo\" : 42 , \"bar\" : { \"$exists\" : false}}"); - assertThat(query.getQueryObject(), is(reference.getQueryObject())); + assertThat(query.getQueryObject()).isEqualTo(reference.getQueryObject()); } @Test // DATAMONGO-1444 @@ -220,7 +219,7 @@ public class ReactiveStringBasedMongoQueryUnitTests { org.springframework.data.mongodb.core.query.Query reference = new BasicQuery("{'lastname' : { '$binary' : '" + Base64Utils.encodeToString(binaryData) + "', '$type' : '" + 0 + "'}}"); - assertThat(query.getQueryObject().toJson(), is(reference.getQueryObject().toJson())); + assertThat(query.getQueryObject().toJson()).isEqualTo(reference.getQueryObject().toJson()); } private ReactiveStringBasedMongoQuery createQueryForMethod(String name, Class... parameters) throws Exception { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactoryBeanUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactoryBeanUnitTests.java index 537656048..c6a61584b 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactoryBeanUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactoryBeanUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.support; -import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import java.util.List; @@ -25,6 +24,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mapping.context.MappingContext; import org.springframework.data.mongodb.core.MongoOperations; import org.springframework.data.mongodb.core.convert.MongoConverter; @@ -52,8 +52,8 @@ public class MongoRepositoryFactoryBeanUnitTests { factory.setCreateIndexesForQueryMethods(true); List listeners = getListenersFromFactory(factory); - assertThat(listeners.isEmpty(), is(false)); - assertThat(listeners, hasItem(instanceOf(IndexEnsuringQueryCreationListener.class))); + assertThat(listeners.isEmpty()).isFalse(); + assertThat(listeners.stream().filter(IndexEnsuringQueryCreationListener.class::isInstance)).isNotEmpty(); } @Test @@ -61,7 +61,7 @@ public class MongoRepositoryFactoryBeanUnitTests { public void doesNotAddIndexEnsuringQueryCreationListenerByDefault() { List listeners = getListenersFromFactory(new MongoRepositoryFactoryBean(ContactRepository.class)); - assertThat(listeners.size(), is(1)); + assertThat(listeners.size()).isEqualTo(1); } @SuppressWarnings({ "unchecked", "rawtypes" }) diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactoryUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactoryUnitTests.java index ffaae8cfc..78b8f152f 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactoryUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactoryUnitTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.support; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; import java.io.Serializable; @@ -26,6 +25,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; + import org.springframework.data.mapping.context.MappingContext; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.core.convert.MongoConverter; @@ -65,7 +65,7 @@ public class MongoRepositoryFactoryUnitTests { MongoRepositoryFactory factory = new MongoRepositoryFactory(template); MongoEntityInformation entityInformation = factory.getEntityInformation(Person.class); - assertTrue(entityInformation instanceof MappingMongoEntityInformation); + assertThat(entityInformation instanceof MappingMongoEntityInformation).isTrue(); } @Test // DATAMONGO-385 @@ -76,7 +76,7 @@ public class MongoRepositoryFactoryUnitTests { MongoRepositoryFactory factory = new MongoRepositoryFactory(template); MyPersonRepository repository = factory.getRepository(MyPersonRepository.class); - assertThat(repository, is(notNullValue())); + assertThat(repository).isNotNull(); } interface MyPersonRepository extends Repository { diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/QuerydslRepositorySupportTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/QuerydslRepositorySupportTests.java index fa7b8b085..b36084729 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/QuerydslRepositorySupportTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/QuerydslRepositorySupportTests.java @@ -15,8 +15,7 @@ */ package org.springframework.data.mongodb.repository.support; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.assertj.core.api.Assertions.*; import lombok.Data; @@ -26,13 +25,14 @@ import org.bson.types.ObjectId; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; + import org.springframework.beans.DirectFieldAccessor; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.annotation.Id; -import org.springframework.data.mongodb.core.mapping.MongoId; import org.springframework.data.mongodb.core.MongoOperations; import org.springframework.data.mongodb.core.mapping.Document; import org.springframework.data.mongodb.core.mapping.FieldType; +import org.springframework.data.mongodb.core.mapping.MongoId; import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.mongodb.repository.Person; import org.springframework.data.mongodb.repository.QPerson; @@ -73,7 +73,7 @@ public class QuerydslRepositorySupportTests { QPerson p = QPerson.person; QuerydslRepositorySupport support = new QuerydslRepositorySupport(operations) {}; SpringDataMongodbQuery query = support.from(p).where(p.lastname.eq("Matthews")); - assertThat(query.fetchOne(), is(person)); + assertThat(query.fetchOne()).isEqualTo(person); } @Test // DATAMONGO-1063 @@ -87,7 +87,7 @@ public class QuerydslRepositorySupportTests { SpringDataMongodbQuery query = repoSupport.from(p).where(p.skills.any().in("guitarist")); - assertThat(query.fetchOne(), is(person)); + assertThat(query.fetchOne()).isEqualTo(person); } @Test // DATAMONGO-1394 @@ -105,8 +105,8 @@ public class QuerydslRepositorySupportTests { SpringDataMongodbQuery queryUsingIdField = repoSupport.from(p).where(p.coworker.id.eq(bart.getId())); SpringDataMongodbQuery queryUsingRefObject = repoSupport.from(p).where(p.coworker.eq(bart)); - assertThat(queryUsingIdField.fetchOne(), equalTo(person)); - assertThat(queryUsingIdField.fetchOne(), equalTo(queryUsingRefObject.fetchOne())); + assertThat(queryUsingIdField.fetchOne()).isEqualTo(person); + assertThat(queryUsingIdField.fetchOne()).isEqualTo(queryUsingRefObject.fetchOne()); } @Test // DATAMONGO-1998 @@ -123,7 +123,7 @@ public class QuerydslRepositorySupportTests { QQuerydslRepositorySupportTests_Outer o = QQuerydslRepositorySupportTests_Outer.outer; SpringDataMongodbQuery query = repoSupport.from(o).where(o.inner.id.eq(outer.inner.id)); - assertThat(query.fetchOne(), equalTo(outer)); + assertThat(query.fetchOne()).isEqualTo(outer); } @Test // DATAMONGO-1998 @@ -140,7 +140,7 @@ public class QuerydslRepositorySupportTests { QQuerydslRepositorySupportTests_Outer o = QQuerydslRepositorySupportTests_Outer.outer; SpringDataMongodbQuery query = repoSupport.from(o).where(o.inner.id.eq(outer.inner.id)); - assertThat(query.fetchOne(), equalTo(outer)); + assertThat(query.fetchOne()).isEqualTo(outer); } @Test // DATAMONGO-1810, DATAMONGO-1848 @@ -170,8 +170,8 @@ public class QuerydslRepositorySupportTests { SpringDataMongodbQuery queryUsingRefObject = repoSupport.from(p).where(p.coworker.eq(bart)); - assertThat(queryUsingIdFieldWithinInClause.fetchOne(), equalTo(person)); - assertThat(queryUsingIdFieldWithinInClause.fetchOne(), equalTo(queryUsingRefObject.fetchOne())); + assertThat(queryUsingIdFieldWithinInClause.fetchOne()).isEqualTo(person); + assertThat(queryUsingIdFieldWithinInClause.fetchOne()).isEqualTo(queryUsingRefObject.fetchOne()); } @Test // DATAMONGO-1810, DATAMONGO-1848 @@ -195,8 +195,8 @@ public class QuerydslRepositorySupportTests { SpringDataMongodbQuery queryUsingRefObject = repoSupport.from(p).where(p.coworker.eq(bart)); - assertThat(queryUsingIdFieldWithinInClause.fetchOne(), equalTo(person)); - assertThat(queryUsingIdFieldWithinInClause.fetchOne(), equalTo(queryUsingRefObject.fetchOne())); + assertThat(queryUsingIdFieldWithinInClause.fetchOne()).isEqualTo(person); + assertThat(queryUsingIdFieldWithinInClause.fetchOne()).isEqualTo(queryUsingRefObject.fetchOne()); } @Test // DATAMONGO-1848, DATAMONGO-2010 @@ -213,7 +213,7 @@ public class QuerydslRepositorySupportTests { QQuerydslRepositorySupportTests_Outer o = QQuerydslRepositorySupportTests_Outer.outer; SpringDataMongodbQuery query = repoSupport.from(o).where(o.inner.id.in(outer.inner.id, outer.inner.id)); - assertThat(query.fetchOne(), equalTo(outer)); + assertThat(query.fetchOne()).isEqualTo(outer); } @Test // DATAMONGO-1798 @@ -227,7 +227,7 @@ public class QuerydslRepositorySupportTests { QQuerydslRepositorySupportTests_Outer o = QQuerydslRepositorySupportTests_Outer.outer; SpringDataMongodbQuery query = repoSupport.from(o).where(o.id.eq(outer.id)); - assertThat(query.fetchOne(), equalTo(outer)); + assertThat(query.fetchOne()).isEqualTo(outer); } @Test // DATAMONGO-1798 @@ -241,11 +241,11 @@ public class QuerydslRepositorySupportTests { QQuerydslRepositorySupportTests_WithMongoId o = QQuerydslRepositorySupportTests_WithMongoId.withMongoId; SpringDataMongodbQuery eqQuery = repoSupport.from(o).where(o.id.eq(document.id)); - assertThat(eqQuery.fetchOne(), equalTo(document)); + assertThat(eqQuery.fetchOne()).isEqualTo(document); SpringDataMongodbQuery inQuery = repoSupport.from(o).where(o.id.in(document.id)); - assertThat(inQuery.fetchOne(), equalTo(document)); + assertThat(inQuery.fetchOne()).isEqualTo(document); } @Data diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/test/util/IsBsonObject.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/test/util/IsBsonObject.java deleted file mode 100644 index 0f3879508..000000000 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/test/util/IsBsonObject.java +++ /dev/null @@ -1,217 +0,0 @@ -/* - * 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. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.springframework.data.mongodb.test.util; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Iterator; -import java.util.List; -import java.util.NoSuchElementException; - -import org.bson.Document; -import org.bson.conversions.Bson; -import org.hamcrest.Description; -import org.hamcrest.TypeSafeMatcher; -import org.hamcrest.core.IsEqual; -import org.springframework.data.mongodb.core.query.SerializationUtils; -import org.springframework.util.ClassUtils; - -/** - * @author Christoph Strobl - * @param - */ -public class IsBsonObject extends TypeSafeMatcher { - - private List expectations = new ArrayList<>(); - private Integer expectedSize; - - public static IsBsonObject isBsonObject() { - return new IsBsonObject(); - } - - @Override - protected void describeMismatchSafely(T item, Description mismatchDescription) { - mismatchDescription.appendText("was ").appendValue(SerializationUtils.serializeToJsonSafely(item)); - } - - @Override - public void describeTo(Description description) { - - if (expectedSize != null) { - description.appendText(String.format("Expected to contain %s fields. ", expectedSize)); - } - - for (ExpectedBsonContent expectation : expectations) { - - if (expectation.not) { - description.appendText(String.format("Path %s should not be present. ", expectation.path)); - } else if (expectation.value == null) { - description.appendText(String.format("Expected to find path %s. ", expectation.path)); - } else { - description.appendText(String.format("Expected to find %s for path %s. ", expectation.value, expectation.path)); - } - } - } - - @Override - protected boolean matchesSafely(T item) { - - if (expectedSize != null && item instanceof Document) { - - Document document = (Document) item; - if (expectedSize != document.keySet().size()) { - return false; - } - } - - if (expectations.isEmpty()) { - return true; - } - - for (ExpectedBsonContent expectation : expectations) { - - Object o = getValue(item, expectation.path); - - if (o == null && expectation.not) { - return true; - } - - if (o == null) { - return false; - } - - if (expectation.type != null) { - - if (ClassUtils.isAssignable(List.class, expectation.type) - && ClassUtils.isAssignable(List.class, o.getClass())) { - return true; - } - - return ClassUtils.isAssignable(expectation.type, o.getClass()); - } - - if (expectation.value != null && !new IsEqual(expectation.value).matches(o)) { - return false; - } - - if (o != null && expectation.not) { - return false; - } - - } - return true; - } - - public IsBsonObject containing(String key) { - - ExpectedBsonContent expected = new ExpectedBsonContent(); - expected.path = key; - - this.expectations.add(expected); - return this; - } - - public IsBsonObject containing(String key, Class type) { - - ExpectedBsonContent expected = new ExpectedBsonContent(); - expected.path = key; - expected.type = type; - - this.expectations.add(expected); - return this; - } - - public IsBsonObject containing(String key, Object value) { - - if (value == null) { - return notContaining(key); - } - - ExpectedBsonContent expected = new ExpectedBsonContent(); - expected.path = key; - expected.type = ClassUtils.getUserClass(value); - expected.value = value; - - this.expectations.add(expected); - return this; - } - - public IsBsonObject notContaining(String key) { - - ExpectedBsonContent expected = new ExpectedBsonContent(); - expected.path = key; - expected.not = true; - - this.expectations.add(expected); - return this; - } - - public IsBsonObject withSize(int size) { - - this.expectedSize = Integer.valueOf(size); - return this; - } - - static class ExpectedBsonContent { - String path; - Class type; - Object value; - boolean not = false; - } - - Object getValue(Bson source, String path) { - - String[] fragments = path.split("(? it = Arrays.asList(fragments).iterator(); - - Object current = source; - while (it.hasNext()) { - - String key = it.next().replace("\\.", "."); - - if (!(current instanceof Bson) && !key.startsWith("[")) { - return null; - } - - if (key.startsWith("[")) { - String indexNumber = key.substring(1, key.indexOf("]")); - if (current instanceof List) { - current = ((List) current).get(Integer.valueOf(indexNumber)); - } - if (!it.hasNext()) { - return current; - } - } else { - - if (current instanceof Document) { - current = ((Document) current).get(key); - } - - if (!it.hasNext()) { - return current; - } - - } - } - - throw new NoSuchElementException(String.format("Unable to find '%s' in %s.", path, source)); - } -}