From ca02cc1194011ae008cbf96b86eb5ff3c6ec804b Mon Sep 17 00:00:00 2001 From: Sebastien Deleuze Date: Mon, 2 Sep 2019 15:59:26 +0200 Subject: [PATCH] Migrate to AssertJ in Kotlin tests Closes gh-23475 --- .../beans/KotlinBeanUtilsTests.kt | 26 ++++---- .../annotation/KotlinAutowiredTests.kt | 56 ++++++++--------- ...ConfigApplicationContextExtensionsTests.kt | 6 +- .../KotlinConfigurationClassTests.kt | 13 ++-- .../context/annotation/Spr16022Tests.kt | 8 +-- .../context/support/BeanDefinitionDslTests.kt | 39 +++++------- ...enericApplicationContextExtensionsTests.kt | 17 +++-- .../ui/ModelExtensionsTests.kt | 7 +-- .../ui/ModelMapExtensionsTests.kt | 7 +-- ...tlinDefaultParameterNameDiscovererTests.kt | 4 +- .../core/KotlinGenericTypeResolverTests.kt | 18 +++--- .../core/KotlinMethodParameterTests.kt | 63 +++++++++---------- .../KotlinReactiveAdapterRegistryTests.kt | 24 +++---- ...nReflectionParameterNameDiscovererTests.kt | 9 ++- .../core/JdbcOperationsExtensionsTests.kt | 29 +++++---- .../MapSqlParameterSourceExtensionsTests.kt | 14 ++--- .../rsocket/RSocketRequesterExtensions.kt | 3 - .../RSocketRequesterExtensionsTests.kt | 42 ++++++++----- ...notationMethodMessageHandlerKotlinTests.kt | 30 ++++----- .../server/WebTestClientExtensionsTests.kt | 6 +- .../web/servlet/MockMvcExtensionsTests.kt | 38 ++++++----- .../client/RestOperationsExtensionsTests.kt | 53 ++++++++-------- ...tParamMethodArgumentResolverKotlinTests.kt | 54 ++++++---------- .../client/ClientResponseExtensionsTests.kt | 11 ++-- .../client/WebClientExtensionsTests.kt | 6 +- .../server/CoRouterFunctionDslTests.kt | 10 ++- .../function/server/RouterFunctionDslTests.kt | 10 ++- .../server/ServerRequestExtensionsTests.kt | 15 +++-- .../server/ServerResponseExtensionsTests.kt | 4 +- .../KotlinInvocableHandlerMethodTests.kt | 8 +-- .../annotation/CoroutinesIntegrationTests.kt | 31 ++++----- .../function/RouterFunctionDslTests.kt | 30 ++++----- .../function/ServerRequestExtensionsTests.kt | 31 +++++---- .../function/ServerResponseExtensionsTests.kt | 7 +-- ...ationControllerHandlerMethodKotlinTests.kt | 10 +-- 35 files changed, 336 insertions(+), 403 deletions(-) diff --git a/spring-beans/src/test/kotlin/org/springframework/beans/KotlinBeanUtilsTests.kt b/spring-beans/src/test/kotlin/org/springframework/beans/KotlinBeanUtilsTests.kt index fd49701af7..948292bd83 100644 --- a/spring-beans/src/test/kotlin/org/springframework/beans/KotlinBeanUtilsTests.kt +++ b/spring-beans/src/test/kotlin/org/springframework/beans/KotlinBeanUtilsTests.kt @@ -16,7 +16,7 @@ package org.springframework.beans -import org.junit.jupiter.api.Assertions.* +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test /** @@ -31,47 +31,47 @@ class KotlinBeanUtilsTests { fun `Instantiate immutable class`() { val constructor = BeanUtils.findPrimaryConstructor(Foo::class.java)!! val foo = BeanUtils.instantiateClass(constructor, "a", 3) - assertEquals("a", foo.param1) - assertEquals(3, foo.param2) + assertThat(foo.param1).isEqualTo("a") + assertThat(foo.param2).isEqualTo(3) } @Test fun `Instantiate immutable class with optional parameter and all parameters specified`() { val constructor = BeanUtils.findPrimaryConstructor(Bar::class.java)!! val bar = BeanUtils.instantiateClass(constructor, "a", 8) - assertEquals("a", bar.param1) - assertEquals(8, bar.param2) + assertThat(bar.param1).isEqualTo("a") + assertThat(bar.param2).isEqualTo(8) } @Test fun `Instantiate immutable class with optional parameter and only mandatory parameters specified by position`() { val constructor = BeanUtils.findPrimaryConstructor(Bar::class.java)!! val bar = BeanUtils.instantiateClass(constructor, "a") - assertEquals("a", bar.param1) - assertEquals(12, bar.param2) + assertThat(bar.param1).isEqualTo("a") + assertThat(bar.param2).isEqualTo(12) } @Test fun `Instantiate immutable class with optional parameter specified with null value`() { val constructor = BeanUtils.findPrimaryConstructor(Bar::class.java)!! val bar = BeanUtils.instantiateClass(constructor, "a", null) - assertEquals("a", bar.param1) - assertEquals(12, bar.param2) + assertThat(bar.param1).isEqualTo("a") + assertThat(bar.param2).isEqualTo(12) } @Test // gh-22531 fun `Instantiate immutable class with nullable parameter`() { val constructor = BeanUtils.findPrimaryConstructor(Qux::class.java)!! val bar = BeanUtils.instantiateClass(constructor, "a", null) - assertEquals("a", bar.param1) - assertNull(bar.param2) + assertThat(bar.param1).isEqualTo("a") + assertThat(bar.param2).isNull() } @Test // SPR-15851 fun `Instantiate mutable class with declared constructor and default values for all parameters`() { val baz = BeanUtils.instantiateClass(Baz::class.java.getDeclaredConstructor()) - assertEquals("a", baz.param1) - assertEquals(12, baz.param2) + assertThat(baz.param1).isEqualTo("a") + assertThat(baz.param2).isEqualTo(12) } class Foo(val param1: String, val param2: Int) diff --git a/spring-beans/src/test/kotlin/org/springframework/beans/factory/annotation/KotlinAutowiredTests.kt b/spring-beans/src/test/kotlin/org/springframework/beans/factory/annotation/KotlinAutowiredTests.kt index d994970276..a254900fa3 100644 --- a/spring-beans/src/test/kotlin/org/springframework/beans/factory/annotation/KotlinAutowiredTests.kt +++ b/spring-beans/src/test/kotlin/org/springframework/beans/factory/annotation/KotlinAutowiredTests.kt @@ -16,16 +16,14 @@ package org.springframework.beans.factory.annotation +import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.jupiter.api.Test - +import org.springframework.beans.factory.BeanCreationException import org.springframework.beans.factory.support.DefaultListableBeanFactory import org.springframework.beans.factory.support.RootBeanDefinition -import org.springframework.tests.sample.beans.TestBean - -import org.junit.jupiter.api.Assertions.* -import org.junit.jupiter.api.fail -import org.springframework.beans.factory.BeanCreationException import org.springframework.tests.sample.beans.Colour +import org.springframework.tests.sample.beans.TestBean /** * Tests for Kotlin support with [Autowired]. @@ -48,9 +46,9 @@ class KotlinAutowiredTests { bf.registerSingleton("testBean", tb) val kb = bf.getBean("annotatedBean", KotlinBean::class.java) - assertSame(tb, kb.injectedFromConstructor) - assertSame(tb, kb.injectedFromMethod) - assertSame(tb, kb.injectedField) + assertThat(kb.injectedFromConstructor).isSameAs(tb) + assertThat(kb.injectedFromMethod).isSameAs(tb) + assertThat(kb.injectedField).isSameAs(tb) } @Test @@ -64,9 +62,9 @@ class KotlinAutowiredTests { bf.registerBeanDefinition("annotatedBean", bd) val kb = bf.getBean("annotatedBean", KotlinBean::class.java) - assertNull(kb.injectedFromConstructor) - assertNull(kb.injectedFromMethod) - assertNull(kb.injectedField) + assertThat(kb.injectedFromConstructor).isNull() + assertThat(kb.injectedFromMethod).isNull() + assertThat(kb.injectedField).isNull() } @Test // SPR-15847 @@ -82,9 +80,9 @@ class KotlinAutowiredTests { bf.registerSingleton("testBean", tb) val kb = bf.getBean("bean", KotlinBeanWithMandatoryAndOptionalParameters::class.java) - assertSame(tb, kb.injectedFromConstructor) - assertEquals("foo", kb.optional) - assertEquals("bar", kb.initializedField) + assertThat(kb.injectedFromConstructor).isSameAs(tb) + assertThat(kb.optional).isEqualTo("foo") + assertThat(kb.initializedField).isEqualTo("bar") } @Test @@ -98,9 +96,9 @@ class KotlinAutowiredTests { bf.registerBeanDefinition("bean", bd) val kb = bf.getBean("bean", KotlinBeanWithOptionalParameters::class.java) - assertNotNull(kb.optional1) - assertEquals("foo", kb.optional2) - assertEquals("bar", kb.initializedField) + assertThat(kb.optional1).isNotNull() + assertThat(kb.optional2).isEqualTo("foo") + assertThat(kb.initializedField).isEqualTo("bar") } @Test // SPR-15847 @@ -116,8 +114,8 @@ class KotlinAutowiredTests { bf.registerSingleton("testBean", tb) val kb = bf.getBean("bean", KotlinBeanWithOptionalParameterAndExplicitConstructor::class.java) - assertSame(tb, kb.injectedFromConstructor) - assertEquals("foo", kb.optional) + assertThat(kb.injectedFromConstructor).isSameAs(tb) + assertThat(kb.optional).isEqualTo("foo") } @Test // SPR-15847 @@ -135,9 +133,9 @@ class KotlinAutowiredTests { bf.registerSingleton("colour", colour) val kb = bf.getBean("bean", KotlinBeanWithAutowiredSecondaryConstructor::class.java) - assertSame(tb, kb.injectedFromConstructor) - assertEquals("bar", kb.optional) - assertSame(colour, kb.injectedFromSecondaryConstructor) + assertThat(kb.injectedFromConstructor).isSameAs(tb) + assertThat(kb.optional).isEqualTo("bar") + assertThat(kb.injectedFromSecondaryConstructor).isSameAs(colour) } @Test // SPR-16012 @@ -151,7 +149,7 @@ class KotlinAutowiredTests { bf.registerBeanDefinition("bean", bd) val kb = bf.getBean("bean", KotlinBeanWithPrimaryAndDefaultConstructors::class.java) - assertNotNull(kb.testBean) + assertThat(kb.testBean).isNotNull() } @Test // SPR-16012 @@ -167,7 +165,7 @@ class KotlinAutowiredTests { bf.registerSingleton("testBean", tb) val kb = bf.getBean("bean", KotlinBeanWithPrimaryAndDefaultConstructors::class.java) - assertEquals(tb, kb.testBean) + assertThat(kb.testBean).isEqualTo(tb) } @Test // SPR-16289 @@ -197,13 +195,9 @@ class KotlinAutowiredTests { bf.registerSingleton("testBean", tb) val colour = Colour.BLUE bf.registerSingleton("colour", colour) - - try { + + assertThatExceptionOfType(BeanCreationException::class.java).isThrownBy { bf.getBean("bean", KotlinBeanWithSecondaryConstructor::class.java) - fail("should have thrown a BeanCreationException") - } - catch (e: BeanCreationException) { - // expected } } diff --git a/spring-context/src/test/kotlin/org/springframework/context/annotation/AnnotationConfigApplicationContextExtensionsTests.kt b/spring-context/src/test/kotlin/org/springframework/context/annotation/AnnotationConfigApplicationContextExtensionsTests.kt index b248dc6531..98a10faf81 100644 --- a/spring-context/src/test/kotlin/org/springframework/context/annotation/AnnotationConfigApplicationContextExtensionsTests.kt +++ b/spring-context/src/test/kotlin/org/springframework/context/annotation/AnnotationConfigApplicationContextExtensionsTests.kt @@ -16,7 +16,7 @@ package org.springframework.context.annotation -import org.junit.jupiter.api.Assertions.assertNotNull +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.beans.factory.getBean import org.springframework.context.support.registerBean @@ -34,9 +34,9 @@ class AnnotationConfigApplicationContextExtensionsTests { val applicationContext = AnnotationConfigApplicationContext { registerBean() } + assertThat(applicationContext).isNotNull() applicationContext.refresh() - assertNotNull(applicationContext) - assertNotNull(applicationContext.getBean()) + applicationContext.getBean() } class Foo diff --git a/spring-context/src/test/kotlin/org/springframework/context/annotation/KotlinConfigurationClassTests.kt b/spring-context/src/test/kotlin/org/springframework/context/annotation/KotlinConfigurationClassTests.kt index 3f892bfcb3..72d411e06b 100644 --- a/spring-context/src/test/kotlin/org/springframework/context/annotation/KotlinConfigurationClassTests.kt +++ b/spring-context/src/test/kotlin/org/springframework/context/annotation/KotlinConfigurationClassTests.kt @@ -16,8 +16,9 @@ package org.springframework.context.annotation -import org.junit.jupiter.api.Assertions.* -import org.junit.jupiter.api.fail + +import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.jupiter.api.Test import org.springframework.beans.factory.getBean import org.springframework.beans.factory.parsing.BeanDefinitionParsingException @@ -26,12 +27,8 @@ class KotlinConfigurationClassTests { @Test fun `Final configuration with default proxyBeanMethods value`() { - try { + assertThatExceptionOfType(BeanDefinitionParsingException::class.java).isThrownBy { AnnotationConfigApplicationContext(FinalConfigurationWithProxy::class.java) - fail("should have thrown a BeanDefinitionParsingException") - } - catch (e: BeanDefinitionParsingException) { - // expected } } @@ -39,7 +36,7 @@ class KotlinConfigurationClassTests { fun `Final configuration with proxyBeanMethods set to false`() { val context = AnnotationConfigApplicationContext(FinalConfigurationWithoutProxy::class.java) val foo = context.getBean() - assertEquals(foo, context.getBean().foo) + assertThat(context.getBean().foo).isEqualTo(foo) } diff --git a/spring-context/src/test/kotlin/org/springframework/context/annotation/Spr16022Tests.kt b/spring-context/src/test/kotlin/org/springframework/context/annotation/Spr16022Tests.kt index ff2ecf1489..a65bf313c5 100644 --- a/spring-context/src/test/kotlin/org/springframework/context/annotation/Spr16022Tests.kt +++ b/spring-context/src/test/kotlin/org/springframework/context/annotation/Spr16022Tests.kt @@ -16,7 +16,7 @@ package org.springframework.context.annotation -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.beans.factory.BeanFactory import org.springframework.beans.factory.getBean @@ -39,11 +39,11 @@ class Spr16022Tests { private fun assert(context: BeanFactory) { val bean1 = context.getBean("bean1") - assertEquals(0, bean1.foo) + assertThat(bean1.foo).isEqualTo(0) val bean2 = context.getBean("bean2") - assertEquals(1, bean2.foo) + assertThat(bean2.foo).isEqualTo(1) val bean3 = context.getBean("bean3") - assertEquals(3, bean3.foo) + assertThat(bean3.foo).isEqualTo(3) } diff --git a/spring-context/src/test/kotlin/org/springframework/context/support/BeanDefinitionDslTests.kt b/spring-context/src/test/kotlin/org/springframework/context/support/BeanDefinitionDslTests.kt index c244d4ed41..f54c7c9462 100644 --- a/spring-context/src/test/kotlin/org/springframework/context/support/BeanDefinitionDslTests.kt +++ b/spring-context/src/test/kotlin/org/springframework/context/support/BeanDefinitionDslTests.kt @@ -16,9 +16,8 @@ package org.springframework.context.support -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertNotNull -import org.junit.jupiter.api.Assertions.assertTrue +import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.jupiter.api.fail import org.junit.jupiter.api.Test import org.springframework.beans.factory.NoSuchBeanDefinitionException @@ -45,10 +44,10 @@ class BeanDefinitionDslTests { refresh() } - assertNotNull(context.getBean()) - assertNotNull(context.getBean("bar")) - assertTrue(context.isPrototype("bar")) - assertNotNull(context.getBean()) + context.getBean() + context.getBean("bar") + assertThat(context.isPrototype("bar")).isTrue() + context.getBean() } @Test @@ -72,13 +71,9 @@ class BeanDefinitionDslTests { refresh() } - assertNotNull(context.getBean()) - assertNotNull(context.getBean("bar")) - try { - context.getBean() - fail("Expect NoSuchBeanDefinitionException to be thrown") - } - catch(ex: NoSuchBeanDefinitionException) { null } + context.getBean() + context.getBean("bar") + assertThatExceptionOfType(NoSuchBeanDefinitionException::class.java).isThrownBy { context.getBean() } } @Test @@ -100,14 +95,10 @@ class BeanDefinitionDslTests { refresh() } - assertNotNull(context.getBean()) - assertNotNull(context.getBean("bar")) - assertEquals("foofoo", context.getBean().name) - try { - context.getBean() - fail("Expect NoSuchBeanDefinitionException to be thrown") - } - catch(ex: NoSuchBeanDefinitionException) { null } + context.getBean() + context.getBean("bar") + assertThat(context.getBean().name).isEqualTo("foofoo") + assertThatExceptionOfType(NoSuchBeanDefinitionException::class.java).isThrownBy { context.getBean() } } @Test // SPR-16412 @@ -126,7 +117,7 @@ class BeanDefinitionDslTests { } for (i in 1..5) { - assertNotNull(context.getBean("string$i")) + context.getBean("string$i") } } @@ -144,7 +135,7 @@ class BeanDefinitionDslTests { } val barbar = context.getBean() - assertEquals(2, barbar.foos.size) + assertThat(barbar.foos.size).isEqualTo(2) } @Test // SPR-17292 diff --git a/spring-context/src/test/kotlin/org/springframework/context/support/GenericApplicationContextExtensionsTests.kt b/spring-context/src/test/kotlin/org/springframework/context/support/GenericApplicationContextExtensionsTests.kt index 15120ded96..f39108ec57 100644 --- a/spring-context/src/test/kotlin/org/springframework/context/support/GenericApplicationContextExtensionsTests.kt +++ b/spring-context/src/test/kotlin/org/springframework/context/support/GenericApplicationContextExtensionsTests.kt @@ -16,7 +16,6 @@ package org.springframework.context.support -import org.junit.jupiter.api.Assertions.assertNotNull import org.junit.jupiter.api.Test import org.springframework.beans.factory.getBean @@ -32,7 +31,7 @@ class GenericApplicationContextExtensionsTests { val context = GenericApplicationContext() context.registerBean() context.refresh() - assertNotNull(context.getBean()) + context.getBean() } @Test @@ -40,7 +39,7 @@ class GenericApplicationContextExtensionsTests { val context = GenericApplicationContext() context.registerBean("a") context.refresh() - assertNotNull(context.getBean("a")) + context.getBean("a") } @Test @@ -48,7 +47,7 @@ class GenericApplicationContextExtensionsTests { val context = GenericApplicationContext() context.registerBean { BeanA() } context.refresh() - assertNotNull(context.getBean()) + context.getBean() } @Test @@ -56,7 +55,7 @@ class GenericApplicationContextExtensionsTests { val context = GenericApplicationContext() context.registerBean("a") { BeanA() } context.refresh() - assertNotNull(context.getBean("a")) + context.getBean("a") } @Test @@ -65,8 +64,8 @@ class GenericApplicationContextExtensionsTests { context.registerBean() context.registerBean { BeanB(it.getBean()) } context.refresh() - assertNotNull(context.getBean()) - assertNotNull(context.getBean()) + context.getBean() + context.getBean() } @Test @@ -75,8 +74,8 @@ class GenericApplicationContextExtensionsTests { context.registerBean("a") context.registerBean("b") { BeanB(it.getBean()) } context.refresh() - assertNotNull(context.getBean("a")) - assertNotNull(context.getBean("b")) + context.getBean("a") + context.getBean("b") } class BeanA diff --git a/spring-context/src/test/kotlin/org/springframework/ui/ModelExtensionsTests.kt b/spring-context/src/test/kotlin/org/springframework/ui/ModelExtensionsTests.kt index 21dcc9f03d..6ef6b32017 100644 --- a/spring-context/src/test/kotlin/org/springframework/ui/ModelExtensionsTests.kt +++ b/spring-context/src/test/kotlin/org/springframework/ui/ModelExtensionsTests.kt @@ -16,8 +16,7 @@ package org.springframework.ui -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertTrue +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test /** @@ -31,7 +30,7 @@ class ModelExtensionsTests { fun setAttribute() { val model:Model = ConcurrentModel() model["foo"] = "bing" - assertTrue(model.containsAttribute("foo")) - assertEquals("bing", model.asMap()["foo"]) + assertThat(model.containsAttribute("foo")).isTrue() + assertThat(model.asMap()["foo"]).isEqualTo("bing") } } diff --git a/spring-context/src/test/kotlin/org/springframework/ui/ModelMapExtensionsTests.kt b/spring-context/src/test/kotlin/org/springframework/ui/ModelMapExtensionsTests.kt index 5aece4718c..23eb3c4d08 100644 --- a/spring-context/src/test/kotlin/org/springframework/ui/ModelMapExtensionsTests.kt +++ b/spring-context/src/test/kotlin/org/springframework/ui/ModelMapExtensionsTests.kt @@ -16,8 +16,7 @@ package org.springframework.ui -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertTrue +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test /** @@ -31,8 +30,8 @@ class ModelMapExtensionsTests { fun setAttribute() { val model = ModelMap() model["foo"] = "bing" - assertTrue(model.containsAttribute("foo")) - assertEquals("bing", model["foo"]) + assertThat(model.containsAttribute("foo")) + assertThat(model["foo"]).isEqualTo("bing") } } diff --git a/spring-core/src/test/kotlin/org/springframework/core/KotlinDefaultParameterNameDiscovererTests.kt b/spring-core/src/test/kotlin/org/springframework/core/KotlinDefaultParameterNameDiscovererTests.kt index 4c7ffceef7..7fe1992484 100644 --- a/spring-core/src/test/kotlin/org/springframework/core/KotlinDefaultParameterNameDiscovererTests.kt +++ b/spring-core/src/test/kotlin/org/springframework/core/KotlinDefaultParameterNameDiscovererTests.kt @@ -16,7 +16,7 @@ package org.springframework.core -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test class KotlinDefaultParameterNameDiscovererTests { @@ -31,6 +31,6 @@ class KotlinDefaultParameterNameDiscovererTests { fun getParameterNamesOnEnum() { val constructor = MyEnum::class.java.declaredConstructors[0] val actualParams = parameterNameDiscoverer.getParameterNames(constructor) - assertEquals(2, actualParams!!.size) + assertThat(actualParams!!.size).isEqualTo(2) } } diff --git a/spring-core/src/test/kotlin/org/springframework/core/KotlinGenericTypeResolverTests.kt b/spring-core/src/test/kotlin/org/springframework/core/KotlinGenericTypeResolverTests.kt index f3f5b903e2..9780a4f757 100644 --- a/spring-core/src/test/kotlin/org/springframework/core/KotlinGenericTypeResolverTests.kt +++ b/spring-core/src/test/kotlin/org/springframework/core/KotlinGenericTypeResolverTests.kt @@ -16,7 +16,7 @@ package org.springframework.core -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.core.GenericTypeResolver.resolveReturnTypeArgument import java.lang.reflect.Method @@ -31,14 +31,14 @@ class KotlinGenericTypeResolverTests { @Test fun methodReturnTypes() { - assertEquals(Integer::class.java, resolveReturnTypeArgument(findMethod(MyTypeWithMethods::class.java, "integer")!!, - MyInterfaceType::class.java)) - assertEquals(String::class.java, resolveReturnTypeArgument(findMethod(MyTypeWithMethods::class.java, "string")!!, - MyInterfaceType::class.java)) - assertEquals(null, resolveReturnTypeArgument(findMethod(MyTypeWithMethods::class.java, "raw")!!, - MyInterfaceType::class.java)) - assertEquals(null, resolveReturnTypeArgument(findMethod(MyTypeWithMethods::class.java, "object")!!, - MyInterfaceType::class.java)) + assertThat(resolveReturnTypeArgument(findMethod(MyTypeWithMethods::class.java, "integer")!!, + MyInterfaceType::class.java)).isEqualTo(Integer::class.java) + assertThat(resolveReturnTypeArgument(findMethod(MyTypeWithMethods::class.java, "string")!!, + MyInterfaceType::class.java)).isEqualTo(String::class.java) + assertThat(resolveReturnTypeArgument(findMethod(MyTypeWithMethods::class.java, "raw")!!, + MyInterfaceType::class.java)).isNull() + assertThat(resolveReturnTypeArgument(findMethod(MyTypeWithMethods::class.java, "object")!!, + MyInterfaceType::class.java)).isNull() } private fun findMethod(clazz: Class<*>, name: String): Method? = diff --git a/spring-core/src/test/kotlin/org/springframework/core/KotlinMethodParameterTests.kt b/spring-core/src/test/kotlin/org/springframework/core/KotlinMethodParameterTests.kt index df7ebd7af1..b88fbaa64b 100644 --- a/spring-core/src/test/kotlin/org/springframework/core/KotlinMethodParameterTests.kt +++ b/spring-core/src/test/kotlin/org/springframework/core/KotlinMethodParameterTests.kt @@ -16,9 +16,7 @@ package org.springframework.core -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertFalse -import org.junit.jupiter.api.Assertions.assertTrue +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import java.lang.reflect.Method import java.lang.reflect.TypeVariable @@ -49,59 +47,58 @@ class KotlinMethodParameterTests { @Test fun `Method parameter nullability`() { - assertTrue(MethodParameter(nullableMethod, 0).isOptional) - assertFalse(MethodParameter(nonNullableMethod, 0).isOptional) + assertThat(MethodParameter(nullableMethod, 0).isOptional).isTrue() + assertThat(MethodParameter(nonNullableMethod, 0).isOptional).isFalse() } @Test fun `Method return type nullability`() { - assertTrue(MethodParameter(nullableMethod, -1).isOptional) - assertFalse(MethodParameter(nonNullableMethod, -1).isOptional) + assertThat(MethodParameter(nullableMethod, -1).isOptional).isTrue() + assertThat(MethodParameter(nonNullableMethod, -1).isOptional).isFalse() } @Test // SPR-17222 fun `Inner class constructor`() { - assertFalse(MethodParameter(innerClassConstructor, 0).isOptional) - - assertFalse(MethodParameter(innerClassWithParametersConstructor, 0).isOptional) - assertFalse(MethodParameter(innerClassWithParametersConstructor, 1).isOptional) - assertTrue(MethodParameter(innerClassWithParametersConstructor, 2).isOptional) + assertThat(MethodParameter(innerClassConstructor, 0).isOptional).isFalse() + assertThat(MethodParameter(innerClassWithParametersConstructor, 0).isOptional).isFalse() + assertThat(MethodParameter(innerClassWithParametersConstructor, 1).isOptional).isFalse() + assertThat(MethodParameter(innerClassWithParametersConstructor, 2).isOptional).isTrue() } @Test fun `Regular class constructor`() { - assertFalse(MethodParameter(regularClassConstructor, 0).isOptional) - assertTrue(MethodParameter(regularClassConstructor, 1).isOptional) + assertThat(MethodParameter(regularClassConstructor, 0).isOptional).isFalse() + assertThat(MethodParameter(regularClassConstructor, 1).isOptional).isTrue() } @Test fun `Suspending function return type`() { - assertEquals(Number::class.java, returnParameterType("suspendFun")) - assertEquals(Number::class.java, returnGenericParameterType("suspendFun")) + assertThat(returnParameterType("suspendFun")).isEqualTo(Number::class.java) + assertThat(returnGenericParameterType("suspendFun")).isEqualTo(Number::class.java) - assertEquals(Producer::class.java, returnParameterType("suspendFun2")) - assertEquals("org.springframework.core.Producer", returnGenericParameterTypeName("suspendFun2")) + assertThat(returnParameterType("suspendFun2")).isEqualTo(Producer::class.java) + assertThat(returnGenericParameterTypeName("suspendFun2")).isEqualTo("org.springframework.core.Producer") - assertEquals(Wrapper::class.java, returnParameterType("suspendFun3")) - assertEquals("org.springframework.core.Wrapper", returnGenericParameterTypeName("suspendFun3")) + assertThat(returnParameterType("suspendFun3")).isEqualTo(Wrapper::class.java) + assertThat(returnGenericParameterTypeName("suspendFun3")).isEqualTo("org.springframework.core.Wrapper") - assertEquals(Consumer::class.java, returnParameterType("suspendFun4")) - assertEquals("org.springframework.core.Consumer", returnGenericParameterTypeName("suspendFun4")) + assertThat(returnParameterType("suspendFun4")).isEqualTo(Consumer::class.java) + assertThat(returnGenericParameterTypeName("suspendFun4")).isEqualTo("org.springframework.core.Consumer") - assertEquals(Producer::class.java, returnParameterType("suspendFun5")) - assertTrue(returnGenericParameterType("suspendFun5") is TypeVariable<*>) - assertEquals("org.springframework.core.Producer", returnGenericParameterTypeBoundName("suspendFun5")) + assertThat(returnParameterType("suspendFun5")).isEqualTo(Producer::class.java) + assertThat(returnGenericParameterType("suspendFun5")).isInstanceOf(TypeVariable::class.java) + assertThat(returnGenericParameterTypeBoundName("suspendFun5")).isEqualTo("org.springframework.core.Producer") - assertEquals(Wrapper::class.java, returnParameterType("suspendFun6")) - assertTrue(returnGenericParameterType("suspendFun6") is TypeVariable<*>) - assertEquals("org.springframework.core.Wrapper", returnGenericParameterTypeBoundName("suspendFun6")) + assertThat(returnParameterType("suspendFun6")).isEqualTo(Wrapper::class.java) + assertThat(returnGenericParameterType("suspendFun6")).isInstanceOf(TypeVariable::class.java) + assertThat(returnGenericParameterTypeBoundName("suspendFun6")).isEqualTo("org.springframework.core.Wrapper") - assertEquals(Consumer::class.java, returnParameterType("suspendFun7")) - assertTrue(returnGenericParameterType("suspendFun7") is TypeVariable<*>) - assertEquals("org.springframework.core.Consumer", returnGenericParameterTypeBoundName("suspendFun7")) + assertThat(returnParameterType("suspendFun7")).isEqualTo(Consumer::class.java) + assertThat(returnGenericParameterType("suspendFun7")).isInstanceOf(TypeVariable::class.java) + assertThat(returnGenericParameterTypeBoundName("suspendFun7")).isEqualTo("org.springframework.core.Consumer") - assertEquals(Object::class.java, returnParameterType("suspendFun8")) - assertEquals(Object::class.java, returnGenericParameterType("suspendFun8")) + assertThat(returnParameterType("suspendFun8")).isEqualTo(Object::class.java) + assertThat(returnGenericParameterType("suspendFun8")).isEqualTo(Object::class.java) } private fun returnParameterType(funName: String) = returnMethodParameter(funName).parameterType diff --git a/spring-core/src/test/kotlin/org/springframework/core/KotlinReactiveAdapterRegistryTests.kt b/spring-core/src/test/kotlin/org/springframework/core/KotlinReactiveAdapterRegistryTests.kt index fb589a025f..b58a236bf5 100644 --- a/spring-core/src/test/kotlin/org/springframework/core/KotlinReactiveAdapterRegistryTests.kt +++ b/spring-core/src/test/kotlin/org/springframework/core/KotlinReactiveAdapterRegistryTests.kt @@ -17,16 +17,13 @@ package org.springframework.core import kotlinx.coroutines.Deferred -import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.async import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.flow import kotlinx.coroutines.flow.toList import kotlinx.coroutines.runBlocking -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.Assertions.fail +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.reactivestreams.Publisher import reactor.core.publisher.Flux @@ -35,7 +32,6 @@ import reactor.test.StepVerifier import java.time.Duration import kotlin.reflect.KClass -@ExperimentalCoroutinesApi class KotlinReactiveAdapterRegistryTests { private val registry = ReactiveAdapterRegistry.getSharedInstance() @@ -44,16 +40,16 @@ class KotlinReactiveAdapterRegistryTests { fun deferredToPublisher() { val source = GlobalScope.async { 1 } val target: Publisher = getAdapter(Deferred::class).toPublisher(source) - assertTrue(target is Mono<*>, "Expected Mono Publisher: " + target.javaClass.name) - assertEquals(1, (target as Mono).block(Duration.ofMillis(1000))) + assertThat(target).isInstanceOf(Mono::class.java) + assertThat((target as Mono).block(Duration.ofMillis(1000))).isEqualTo(1) } @Test fun publisherToDeferred() { val source = Mono.just(1) val target = getAdapter(Deferred::class).fromPublisher(source) - assertTrue(target is Deferred<*>) - assertEquals(1, runBlocking { (target as Deferred<*>).await() }) + assertThat(target).isInstanceOf(Deferred::class.java) + assertThat(runBlocking { (target as Deferred<*>).await() }).isEqualTo(1) } @Test @@ -64,7 +60,7 @@ class KotlinReactiveAdapterRegistryTests { emit(3) } val target: Publisher = getAdapter(Flow::class).toPublisher(source) - assertTrue(target is Flux<*>, "Expected Flux Publisher: " + target.javaClass.name) + assertThat(target).isInstanceOf(Flux::class.java) StepVerifier.create(target) .expectNext(1) .expectNext(2) @@ -76,12 +72,8 @@ class KotlinReactiveAdapterRegistryTests { fun publisherToFlow() { val source = Flux.just(1, 2, 3) val target = getAdapter(Flow::class).fromPublisher(source) - if (target is Flow<*>) { - assertEquals(listOf(1, 2, 3), runBlocking { target.toList() }) - } - else { - fail() - } + assertThat(target).isInstanceOf(Flow::class.java) + assertThat(runBlocking { (target as Flow<*>).toList() }).contains(1, 2, 3) } private fun getAdapter(reactiveType: KClass<*>): ReactiveAdapter { diff --git a/spring-core/src/test/kotlin/org/springframework/core/KotlinReflectionParameterNameDiscovererTests.kt b/spring-core/src/test/kotlin/org/springframework/core/KotlinReflectionParameterNameDiscovererTests.kt index a3423775d3..55b5ed4772 100644 --- a/spring-core/src/test/kotlin/org/springframework/core/KotlinReflectionParameterNameDiscovererTests.kt +++ b/spring-core/src/test/kotlin/org/springframework/core/KotlinReflectionParameterNameDiscovererTests.kt @@ -16,10 +16,9 @@ package org.springframework.core +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test -import org.hamcrest.CoreMatchers.`is` -import org.hamcrest.MatcherAssert.assertThat import org.springframework.util.ReflectionUtils /** @@ -33,21 +32,21 @@ class KotlinReflectionParameterNameDiscovererTests { fun getParameterNamesOnInterface() { val method = ReflectionUtils.findMethod(MessageService::class.java,"sendMessage", String::class.java)!! val actualParams = parameterNameDiscoverer.getParameterNames(method) - assertThat(actualParams, `is`(arrayOf("message"))) + assertThat(actualParams).contains("message") } @Test fun getParameterNamesOnClass() { val method = ReflectionUtils.findMethod(MessageServiceImpl::class.java,"sendMessage", String::class.java)!! val actualParams = parameterNameDiscoverer.getParameterNames(method) - assertThat(actualParams, `is`(arrayOf("message"))) + assertThat(actualParams).contains("message") } @Test fun getParameterNamesOnExtensionMethod() { val method = ReflectionUtils.findMethod(UtilityClass::class.java, "identity", String::class.java)!! val actualParams = parameterNameDiscoverer.getParameterNames(method)!! - assertThat(actualParams, `is`(arrayOf("\$receiver"))) + assertThat(actualParams).contains("\$receiver") } interface MessageService { diff --git a/spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/JdbcOperationsExtensionsTests.kt b/spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/JdbcOperationsExtensionsTests.kt index 9c8df3696d..eb2dfe3671 100644 --- a/spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/JdbcOperationsExtensionsTests.kt +++ b/spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/JdbcOperationsExtensionsTests.kt @@ -21,8 +21,7 @@ import java.sql.* import io.mockk.every import io.mockk.mockk import io.mockk.verify -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertNull +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test /** @@ -40,21 +39,21 @@ class JdbcOperationsExtensionsTests { @Test fun `queryForObject with reified type parameters`() { every { template.queryForObject(sql, any>()) } returns 2 - assertEquals(2, template.queryForObject(sql)) + assertThat(template.queryForObject(sql)).isEqualTo(2) verify { template.queryForObject(sql, any>()) } } @Test fun `queryForObject with RowMapper-like function`() { every { template.queryForObject(sql, any>(), any()) } returns 2 - assertEquals(2, template.queryForObject(sql, 3) { rs: ResultSet, _: Int -> rs.getInt(1) }) + assertThat(template.queryForObject(sql, 3) { rs: ResultSet, _: Int -> rs.getInt(1) }).isEqualTo(2) verify { template.queryForObject(eq(sql), any>(), eq(3)) } } @Test // gh-22682 fun `queryForObject with nullable RowMapper-like function`() { every { template.queryForObject(sql, any>(), 3) } returns null - assertNull(template.queryForObject(sql, 3) { _, _ -> null as Int? }) + assertThat(template.queryForObject(sql, 3) { _, _ -> null as Int? }).isNull() verify { template.queryForObject(eq(sql), any>(), eq(3)) } } @@ -63,7 +62,7 @@ class JdbcOperationsExtensionsTests { val args = arrayOf(3) val argTypes = intArrayOf(JDBCType.INTEGER.vendorTypeNumber) every { template.queryForObject(sql, args, argTypes, any>()) } returns 2 - assertEquals(2, template.queryForObject(sql, args, argTypes)) + assertThat(template.queryForObject(sql, args, argTypes)).isEqualTo(2) verify { template.queryForObject(sql, args, argTypes, any>()) } } @@ -71,7 +70,7 @@ class JdbcOperationsExtensionsTests { fun `queryForObject with reified type parameters and args`() { val args = arrayOf(3) every { template.queryForObject(sql, args, any>()) } returns 2 - assertEquals(2, template.queryForObject(sql, args)) + assertThat(template.queryForObject(sql, args)).isEqualTo(2) verify { template.queryForObject(sql, args, any>()) } } @@ -79,7 +78,7 @@ class JdbcOperationsExtensionsTests { fun `queryForList with reified type parameters`() { val list = listOf(1, 2, 3) every { template.queryForList(sql, any>()) } returns list - assertEquals(list, template.queryForList(sql)) + assertThat(template.queryForList(sql)).isEqualTo(list) verify { template.queryForList(sql, any>()) } } @@ -89,7 +88,7 @@ class JdbcOperationsExtensionsTests { val args = arrayOf(3) val argTypes = intArrayOf(JDBCType.INTEGER.vendorTypeNumber) every { template.queryForList(sql, args, argTypes, any>()) } returns list - assertEquals(list, template.queryForList(sql, args, argTypes)) + assertThat(template.queryForList(sql, args, argTypes)).isEqualTo(list) verify { template.queryForList(sql, args, argTypes, any>()) } } @@ -105,17 +104,17 @@ class JdbcOperationsExtensionsTests { @Test fun `query with ResultSetExtractor-like function`() { every { template.query(eq(sql), any>(), eq(3)) } returns 2 - assertEquals(2, template.query(sql, 3) { rs -> + assertThat(template.query(sql, 3) { rs -> rs.next() rs.getInt(1) - }) + }).isEqualTo(2) verify { template.query(eq(sql), any>(), eq(3)) } } @Test // gh-22682 fun `query with nullable ResultSetExtractor-like function`() { every { template.query(eq(sql), any>(), eq(3)) } returns null - assertNull(template.query(sql, 3) { _ -> null }) + assertThat(template.query(sql, 3) { _ -> null }).isNull() verify { template.query(eq(sql), any>(), eq(3)) } } @@ -124,7 +123,7 @@ class JdbcOperationsExtensionsTests { fun `query with RowCallbackHandler-like function`() { every { template.query(sql, ofType(), 3) } returns Unit template.query(sql, 3) { rs -> - assertEquals(22, rs.getInt(1)) + assertThat(rs.getInt(1)).isEqualTo(22) } verify { template.query(sql, ofType(), 3) } } @@ -133,9 +132,9 @@ class JdbcOperationsExtensionsTests { fun `query with RowMapper-like function`() { val list = listOf(1, 2, 3) every { template.query(sql, ofType>(), 3) } returns list - assertEquals(list, template.query(sql, 3) { rs, _ -> + assertThat(template.query(sql, 3) { rs, _ -> rs.getInt(1) - }) + }).isEqualTo(list) verify { template.query(sql, ofType>(), 3) } } diff --git a/spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/namedparam/MapSqlParameterSourceExtensionsTests.kt b/spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/namedparam/MapSqlParameterSourceExtensionsTests.kt index c72b73f035..add5017fdd 100644 --- a/spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/namedparam/MapSqlParameterSourceExtensionsTests.kt +++ b/spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/namedparam/MapSqlParameterSourceExtensionsTests.kt @@ -16,9 +16,9 @@ package org.springframework.jdbc.core.namedparam +import org.assertj.core.api.Assertions.assertThat import java.sql.JDBCType -import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test /** @@ -32,24 +32,24 @@ class MapSqlParameterSourceExtensionsTests { fun `setter with value`() { val source = MapSqlParameterSource() source["foo"] = 2 - assertEquals(2, source.getValue("foo")) + assertThat(source.getValue("foo")).isEqualTo(2) } @Test fun `setter with value and type`() { val source = MapSqlParameterSource() source["foo", JDBCType.INTEGER.vendorTypeNumber] = 2 - assertEquals(2, source.getValue("foo")) - assertEquals(JDBCType.INTEGER.vendorTypeNumber, source.getSqlType("foo")) + assertThat(source.getValue("foo")).isEqualTo(2) + assertThat(source.getSqlType("foo")).isEqualTo(JDBCType.INTEGER.vendorTypeNumber) } @Test fun `setter with value, type and type name`() { val source = MapSqlParameterSource() source["foo", JDBCType.INTEGER.vendorTypeNumber, "INT"] = 2 - assertEquals(2, source.getValue("foo")) - assertEquals(JDBCType.INTEGER.vendorTypeNumber, source.getSqlType("foo")) - assertEquals("INT", source.getTypeName("foo")) + assertThat(source.getValue("foo")).isEqualTo(2) + assertThat(source.getSqlType("foo")).isEqualTo(JDBCType.INTEGER.vendorTypeNumber) + assertThat(source.getTypeName("foo")).isEqualTo("INT") } } diff --git a/spring-messaging/src/main/kotlin/org/springframework/messaging/rsocket/RSocketRequesterExtensions.kt b/spring-messaging/src/main/kotlin/org/springframework/messaging/rsocket/RSocketRequesterExtensions.kt index 069f227da6..680eb08dee 100644 --- a/spring-messaging/src/main/kotlin/org/springframework/messaging/rsocket/RSocketRequesterExtensions.kt +++ b/spring-messaging/src/main/kotlin/org/springframework/messaging/rsocket/RSocketRequesterExtensions.kt @@ -17,7 +17,6 @@ package org.springframework.messaging.rsocket import io.rsocket.transport.ClientTransport -import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.reactive.awaitFirstOrNull import kotlinx.coroutines.reactive.awaitSingle @@ -90,7 +89,6 @@ inline fun RSocketRequester.RequestSpec.dataWithType(publisher * @author Sebastien Deleuze * @since 5.2 */ -@ExperimentalCoroutinesApi inline fun RSocketRequester.RequestSpec.dataWithType(flow: Flow): RSocketRequester.ResponseSpec = data(flow, object : ParameterizedTypeReference() {}) @@ -120,7 +118,6 @@ suspend inline fun RSocketRequester.ResponseSpec.retrieveAndAw * @author Sebastien Deleuze * @since 5.2 */ -@ExperimentalCoroutinesApi inline fun RSocketRequester.ResponseSpec.retrieveFlow(): Flow = retrieveFlux(object : ParameterizedTypeReference() {}).asFlow() diff --git a/spring-messaging/src/test/kotlin/org/springframework/messaging/rsocket/RSocketRequesterExtensionsTests.kt b/spring-messaging/src/test/kotlin/org/springframework/messaging/rsocket/RSocketRequesterExtensionsTests.kt index 383bf8ad04..8e9e17b377 100644 --- a/spring-messaging/src/test/kotlin/org/springframework/messaging/rsocket/RSocketRequesterExtensionsTests.kt +++ b/spring-messaging/src/test/kotlin/org/springframework/messaging/rsocket/RSocketRequesterExtensionsTests.kt @@ -1,12 +1,27 @@ +/* + * Copyright 2002-2019 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * 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.messaging.rsocket import io.mockk.every import io.mockk.mockk -import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.toList import kotlinx.coroutines.runBlocking -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.mockito.ArgumentMatchers.anyInt import org.reactivestreams.Publisher @@ -20,7 +35,6 @@ import java.util.concurrent.CompletableFuture * * @author Sebastien Deleuze */ -@ExperimentalCoroutinesApi class RSocketRequesterExtensionsTests { private val stringTypeRefMatcher: (ParameterizedTypeReference<*>) -> Boolean = { it.type == String::class.java } @@ -31,7 +45,7 @@ class RSocketRequesterExtensionsTests { val builder = mockk() every { builder.connect(any()) } returns Mono.just(requester) runBlocking { - assertEquals(requester, builder.connectAndAwait(mockk())) + assertThat(builder.connectAndAwait(mockk())).isEqualTo(requester) } } @@ -42,7 +56,7 @@ class RSocketRequesterExtensionsTests { val builder = mockk() every { builder.connectTcp(host, anyInt()) } returns Mono.just(requester) runBlocking { - assertEquals(requester, builder.connectTcpAndAwait(host, 0)) + assertThat(builder.connectTcpAndAwait(host, 0)).isEqualTo(requester) } } @@ -52,7 +66,7 @@ class RSocketRequesterExtensionsTests { val builder = mockk() every { builder.connectWebSocket(any()) } returns Mono.just(requester) runBlocking { - assertEquals(requester, builder.connectWebSocketAndAwait(mockk())) + assertThat(builder.connectWebSocketAndAwait(mockk())).isEqualTo(requester) } } @@ -62,7 +76,7 @@ class RSocketRequesterExtensionsTests { val responseSpec = mockk() val data = mockk>() every { requestSpec.data(any>(), match>(stringTypeRefMatcher)) } returns responseSpec - assertEquals(responseSpec, requestSpec.dataWithType(data)) + assertThat(requestSpec.dataWithType(data)).isEqualTo(responseSpec) } @Test @@ -71,7 +85,7 @@ class RSocketRequesterExtensionsTests { val responseSpec = mockk() val data = mockk>() every { requestSpec.data(any>(), match>(stringTypeRefMatcher)) } returns responseSpec - assertEquals(responseSpec, requestSpec.dataWithType(data)) + assertThat(requestSpec.dataWithType(data)).isEqualTo(responseSpec) } @Test @@ -80,7 +94,7 @@ class RSocketRequesterExtensionsTests { val responseSpec = mockk() val data = mockk>() every { requestSpec.data(any>(), match>(stringTypeRefMatcher)) } returns responseSpec - assertEquals(responseSpec, requestSpec.dataWithType(data)) + assertThat(requestSpec.dataWithType(data)).isEqualTo(responseSpec) } @Test @@ -88,7 +102,7 @@ class RSocketRequesterExtensionsTests { val requestSpec = mockk() val responseSpec = mockk() every { requestSpec.data(any()) } returns responseSpec - assertEquals(responseSpec, requestSpec.data(mockk())) + assertThat(requestSpec.data(mockk())).isEqualTo(responseSpec) } @Test @@ -106,7 +120,7 @@ class RSocketRequesterExtensionsTests { val responseSpec = mockk() every { responseSpec.retrieveMono(match>(stringTypeRefMatcher)) } returns Mono.just("foo") runBlocking { - assertEquals(response, responseSpec.retrieveAndAwait()) + assertThat(responseSpec.retrieveAndAwait()).isEqualTo(response) } } @@ -115,7 +129,7 @@ class RSocketRequesterExtensionsTests { val responseSpec = mockk() every { responseSpec.retrieveFlux(match>(stringTypeRefMatcher)) } returns Flux.just("foo", "bar") runBlocking { - assertEquals(listOf("foo", "bar"), responseSpec.retrieveFlow().toList()) + assertThat(responseSpec.retrieveFlow().toList()).contains("foo", "bar") } } @@ -124,7 +138,7 @@ class RSocketRequesterExtensionsTests { val responseSpec = mockk() every { responseSpec.retrieveMono(match>(stringTypeRefMatcher)) } returns Mono.just("foo") runBlocking { - assertEquals("foo", responseSpec.retrieveMono().block()) + assertThat(responseSpec.retrieveMono().block()).isEqualTo("foo") } } @@ -133,7 +147,7 @@ class RSocketRequesterExtensionsTests { val responseSpec = mockk() every { responseSpec.retrieveFlux(match>(stringTypeRefMatcher)) } returns Flux.just("foo", "bar") runBlocking { - assertEquals(listOf("foo", "bar"), responseSpec.retrieveFlux().collectList().block()) + assertThat(responseSpec.retrieveFlux().collectList().block()).contains("foo", "bar") } } diff --git a/spring-messaging/src/test/kotlin/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandlerKotlinTests.kt b/spring-messaging/src/test/kotlin/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandlerKotlinTests.kt index 28aebe097e..9e49d6dc6a 100644 --- a/spring-messaging/src/test/kotlin/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandlerKotlinTests.kt +++ b/spring-messaging/src/test/kotlin/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandlerKotlinTests.kt @@ -17,6 +17,7 @@ package org.springframework.messaging.simp.annotation.support import io.mockk.mockk +import org.assertj.core.api.Assertions.assertThat import java.util.Collections import java.util.HashMap @@ -36,7 +37,6 @@ import org.springframework.messaging.simp.SimpMessagingTemplate import org.springframework.messaging.support.MessageBuilder import org.springframework.stereotype.Controller -import org.junit.jupiter.api.Assertions.* import org.springframework.messaging.MessageHandlingException import org.springframework.messaging.handler.annotation.MessageExceptionHandler @@ -70,8 +70,8 @@ class SimpAnnotationMethodMessageHandlerKotlinTests { val message = createMessage("/nullableHeader", Collections.singletonMap("foo", "bar")) messageHandler.registerHandler(testController) messageHandler.handleMessage(message) - assertNull(testController.exception) - assertEquals("bar", testController.header) + assertThat(testController.exception).isNull() + assertThat(testController.header).isEqualTo("bar") } @Test @@ -79,8 +79,8 @@ class SimpAnnotationMethodMessageHandlerKotlinTests { val message = createMessage("/nullableHeader", Collections.emptyMap()) messageHandler.registerHandler(testController) messageHandler.handleMessage(message) - assertNull(testController.exception) - assertNull(testController.header) + assertThat(testController.exception).isNull() + assertThat(testController.header).isNull() } @Test @@ -88,7 +88,7 @@ class SimpAnnotationMethodMessageHandlerKotlinTests { val message = createMessage("/nonNullableHeader", Collections.singletonMap("foo", "bar")) messageHandler.registerHandler(testController) messageHandler.handleMessage(message) - assertEquals("bar", testController.header) + assertThat(testController.header).isEqualTo("bar") } @Test @@ -96,8 +96,8 @@ class SimpAnnotationMethodMessageHandlerKotlinTests { val message = createMessage("/nonNullableHeader", Collections.emptyMap()) messageHandler.registerHandler(testController) messageHandler.handleMessage(message) - assertNotNull(testController.exception) - assertTrue(testController.exception is MessageHandlingException) + assertThat(testController.exception).isNotNull() + assertThat(testController.exception).isInstanceOf(MessageHandlingException::class.java) } @Test @@ -105,8 +105,8 @@ class SimpAnnotationMethodMessageHandlerKotlinTests { val message = createMessage("/nullableHeaderNotRequired", Collections.singletonMap("foo", "bar")) messageHandler.registerHandler(testController) messageHandler.handleMessage(message) - assertNull(testController.exception) - assertEquals("bar", testController.header) + assertThat(testController.exception).isNull() + assertThat(testController.header).isEqualTo("bar") } @Test @@ -114,8 +114,8 @@ class SimpAnnotationMethodMessageHandlerKotlinTests { val message = createMessage("/nullableHeaderNotRequired", Collections.emptyMap()) messageHandler.registerHandler(testController) messageHandler.handleMessage(message) - assertNull(testController.exception) - assertNull(testController.header) + assertThat(testController.exception).isNull() + assertThat(testController.header).isNull() } @Test @@ -123,7 +123,7 @@ class SimpAnnotationMethodMessageHandlerKotlinTests { val message = createMessage("/nonNullableHeaderNotRequired", Collections.singletonMap("foo", "bar")) messageHandler.registerHandler(testController) messageHandler.handleMessage(message) - assertEquals("bar", testController.header) + assertThat(testController.header).isEqualTo("bar") } @Test @@ -131,8 +131,8 @@ class SimpAnnotationMethodMessageHandlerKotlinTests { val message = createMessage("/nonNullableHeaderNotRequired", Collections.emptyMap()) messageHandler.registerHandler(testController) messageHandler.handleMessage(message) - assertNotNull(testController.exception) - assertTrue(testController.exception is IllegalArgumentException) + assertThat(testController.exception).isNotNull() + assertThat(testController.exception).isInstanceOf(IllegalArgumentException::class.java) } private fun createMessage(destination: String, headers: Map): Message { diff --git a/spring-test/src/test/kotlin/org/springframework/test/web/reactive/server/WebTestClientExtensionsTests.kt b/spring-test/src/test/kotlin/org/springframework/test/web/reactive/server/WebTestClientExtensionsTests.kt index af25ab8278..78cf0dac17 100644 --- a/spring-test/src/test/kotlin/org/springframework/test/web/reactive/server/WebTestClientExtensionsTests.kt +++ b/spring-test/src/test/kotlin/org/springframework/test/web/reactive/server/WebTestClientExtensionsTests.kt @@ -20,7 +20,7 @@ import io.mockk.mockk import io.mockk.verify import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.Flow -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.reactivestreams.Publisher import org.springframework.core.ParameterizedTypeReference @@ -80,7 +80,7 @@ class WebTestClientExtensionsTests { WebTestClient .bindToRouterFunction( router { GET("/") { ok().bodyValue("foo") } } ) .build() - .get().uri("/").exchange().expectBody().consumeWith { assertEquals("foo", it.responseBody) } + .get().uri("/").exchange().expectBody().consumeWith { assertThat(it.responseBody).isEqualTo("foo") } } @Test @@ -88,7 +88,7 @@ class WebTestClientExtensionsTests { WebTestClient .bindToRouterFunction( router { GET("/") { ok().bodyValue("foo") } } ) .build() - .get().uri("/").exchange().expectBody().returnResult().apply { assertEquals("foo", responseBody) } + .get().uri("/").exchange().expectBody().returnResult().apply { assertThat(responseBody).isEqualTo("foo") } } @Test diff --git a/spring-test/src/test/kotlin/org/springframework/test/web/servlet/MockMvcExtensionsTests.kt b/spring-test/src/test/kotlin/org/springframework/test/web/servlet/MockMvcExtensionsTests.kt index 86cb527d3d..98dfa3effb 100644 --- a/spring-test/src/test/kotlin/org/springframework/test/web/servlet/MockMvcExtensionsTests.kt +++ b/spring-test/src/test/kotlin/org/springframework/test/web/servlet/MockMvcExtensionsTests.kt @@ -16,10 +16,9 @@ package org.springframework.test.web.servlet +import org.assertj.core.api.Assertions.* import org.hamcrest.CoreMatchers -import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.Test -import org.junit.jupiter.api.assertThrows import org.springframework.http.HttpMethod import org.springframework.http.HttpStatus import org.springframework.http.MediaType.* @@ -81,8 +80,8 @@ class MockMvcExtensionsTests { }.andDo { handle(handler) } - assertTrue(matcherInvoked) - assertTrue(handlerInvoked) + assertThat(matcherInvoked).isTrue() + assertThat(handlerInvoked).isTrue() } @Test @@ -125,21 +124,20 @@ class MockMvcExtensionsTests { mockMvc.get("/person/$name") { accept = APPLICATION_JSON }.andExpect { - assertThrows { content { contentType(APPLICATION_ATOM_XML) } } - assertThrows { content { string("Wrong") } } - assertThrows { jsonPath("name", CoreMatchers.`is`("Wrong")) } - assertThrows { content { json("""{"name":"wrong"}""") } } - assertThrows { jsonPath("name") { value("wrong") } } - assertThrows { cookie { value("name", "wrong") } } - assertThrows { flash { attribute("name", "wrong") } } - assertThrows { header { stringValues("name", "wrong") } } - assertThrows { model { attributeExists("name", "wrong") } } - assertThrows { redirectedUrl("wrong/Url") } - assertThrows { redirectedUrlPattern("wrong/Url") } - assertThrows { redirectedUrlPattern("wrong/Url") } - assertThrows { status { isAccepted } } - assertThrows { view { name("wrongName") } } - assertThrows { jsonPath("name") { value("wrong") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { content { contentType(APPLICATION_ATOM_XML) } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { content { string("Wrong") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { jsonPath("name", CoreMatchers.`is`("Wrong")) } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { content { json("""{"name":"wrong"}""") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { jsonPath("name") { value("wrong") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { cookie { value("name", "wrong") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { flash { attribute("name", "wrong") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { header { stringValues("name", "wrong") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { model { attributeExists("name", "wrong") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { redirectedUrl("wrong/Url") } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { redirectedUrlPattern("wrong/Url") } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { status { isAccepted } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { view { name("wrongName") } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { jsonPath("name") { value("wrong") } } } } @@ -149,7 +147,7 @@ class MockMvcExtensionsTests { accept = APPLICATION_XML }.andExpect { status { isOk } - assertThrows { xpath("//wrong") { nodeCount(1) } } + assertThatExceptionOfType(AssertionError::class.java).isThrownBy { xpath("//wrong") { nodeCount(1) } } }.andDo { print() } diff --git a/spring-web/src/test/kotlin/org/springframework/web/client/RestOperationsExtensionsTests.kt b/spring-web/src/test/kotlin/org/springframework/web/client/RestOperationsExtensionsTests.kt index 42a5e1f202..6bcd605b3c 100644 --- a/spring-web/src/test/kotlin/org/springframework/web/client/RestOperationsExtensionsTests.kt +++ b/spring-web/src/test/kotlin/org/springframework/web/client/RestOperationsExtensionsTests.kt @@ -19,7 +19,7 @@ package org.springframework.web.client import io.mockk.every import io.mockk.mockk import io.mockk.verify -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.core.ParameterizedTypeReference import org.springframework.http.* @@ -47,7 +47,7 @@ class RestOperationsExtensionsTests { val var1 = "var1" val var2 = "var2" every { template.getForObject(url, Foo::class.java, var1, var2) } returns foo - assertEquals(foo, template.getForObject(url, var1, var2)) + assertThat(template.getForObject(url, var1, var2)).isEqualTo(foo) verify { template.getForObject(url, Foo::class.java, var1, var2) } } @@ -56,7 +56,7 @@ class RestOperationsExtensionsTests { val url = "https://spring.io" val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) every { template.getForObject(url, Foo::class.java, vars) } returns foo - assertEquals(foo, template.getForObject(url, vars)) + assertThat(template.getForObject(url, vars)).isEqualTo(foo) verify { template.getForObject(url, Foo::class.java, vars) } } @@ -64,7 +64,7 @@ class RestOperationsExtensionsTests { fun `getForObject with reified type parameters and URI`() { val url = URI("https://spring.io") every { template.getForObject(url, Foo::class.java) } returns foo - assertEquals(foo, template.getForObject(url)) + assertThat(template.getForObject(url)).isEqualTo(foo) verify { template.getForObject(url, Foo::class.java) } } @@ -72,7 +72,7 @@ class RestOperationsExtensionsTests { fun `getForEntity with reified type parameters, String and URI`() { val url = URI("https://spring.io") every { template.getForEntity(url, Foo::class.java) } returns entity - assertEquals(entity, template.getForEntity(url)) + assertThat(template.getForEntity(url)).isEqualTo(entity) verify { template.getForEntity(url, Foo::class.java) } } @@ -82,7 +82,7 @@ class RestOperationsExtensionsTests { val var1 = "var1" val var2 = "var2" every { template.getForEntity(url, Foo::class.java, var1, var2) } returns entity - assertEquals(entity, template.getForEntity(url, var1, var2)) + assertThat(template.getForEntity(url, var1, var2)).isEqualTo(entity) verify { template.getForEntity(url, Foo::class.java, var1, var2) } } @@ -91,7 +91,7 @@ class RestOperationsExtensionsTests { val url = "https://spring.io" val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) every { template.getForEntity(url, Foo::class.java, vars) } returns entity - assertEquals(entity, template.getForEntity(url, vars)) + assertThat(template.getForEntity(url, vars)).isEqualTo(entity) verify { template.getForEntity(url, Foo::class.java, vars) } } @@ -102,7 +102,7 @@ class RestOperationsExtensionsTests { val var1 = "var1" val var2 = "var2" every { template.patchForObject(url, body, Foo::class.java, var1, var2) } returns foo - assertEquals(foo, template.patchForObject(url, body, var1, var2)) + assertThat(template.patchForObject(url, body, var1, var2)).isEqualTo(foo) verify { template.patchForObject(url, body, Foo::class.java, var1, var2) } } @@ -112,7 +112,7 @@ class RestOperationsExtensionsTests { val body: Any = "body" val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) every { template.patchForObject(url, body, Foo::class.java, vars) } returns foo - assertEquals(foo, template.patchForObject(url, body, vars)) + assertThat(template.patchForObject(url, body, vars)).isEqualTo(foo) verify { template.patchForObject(url, body, Foo::class.java, vars) } } @@ -121,7 +121,7 @@ class RestOperationsExtensionsTests { val url = "https://spring.io" val body: Any = "body" every { template.patchForObject(url, body, Foo::class.java) } returns foo - assertEquals(foo, template.patchForObject(url, body)) + assertThat(template.patchForObject(url, body)).isEqualTo(foo) verify { template.patchForObject(url, body, Foo::class.java) } } @@ -129,7 +129,7 @@ class RestOperationsExtensionsTests { fun `patchForObject with reified type parameters`() { val url = "https://spring.io" every { template.patchForObject(url, null, Foo::class.java) } returns foo - assertEquals(foo, template.patchForObject(url)) + assertThat(template.patchForObject(url)).isEqualTo(foo) verify { template.patchForObject(url, null, Foo::class.java) } } @@ -140,7 +140,7 @@ class RestOperationsExtensionsTests { val var1 = "var1" val var2 = "var2" every { template.postForObject(url, body, Foo::class.java, var1, var2) } returns foo - assertEquals(foo, template.postForObject(url, body, var1, var2)) + assertThat(template.postForObject(url, body, var1, var2)).isEqualTo(foo) verify { template.postForObject(url, body, Foo::class.java, var1, var2) } } @@ -150,7 +150,7 @@ class RestOperationsExtensionsTests { val body: Any = "body" val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) every { template.postForObject(url, body, Foo::class.java, vars) } returns foo - assertEquals(foo, template.postForObject(url, body, vars)) + assertThat(template.postForObject(url, body, vars)).isEqualTo(foo) verify { template.postForObject(url, body, Foo::class.java, vars) } } @@ -159,7 +159,7 @@ class RestOperationsExtensionsTests { val url = "https://spring.io" val body: Any = "body" every { template.postForObject(url, body, Foo::class.java) } returns foo - assertEquals(foo, template.postForObject(url, body)) + assertThat(template.postForObject(url, body)).isEqualTo(foo) verify { template.postForObject(url, body, Foo::class.java) } } @@ -167,7 +167,7 @@ class RestOperationsExtensionsTests { fun `postForObject with reified type parameters`() { val url = "https://spring.io" every { template.postForObject(url, null, Foo::class.java) } returns foo - assertEquals(foo, template.postForObject(url)) + assertThat(template.postForObject(url)).isEqualTo(foo) verify { template.postForObject(url, null, Foo::class.java) } } @@ -178,7 +178,7 @@ class RestOperationsExtensionsTests { val var1 = "var1" val var2 = "var2" every { template.postForEntity(url, body, Foo::class.java, var1, var2) } returns entity - assertEquals(entity, template.postForEntity(url, body, var1, var2)) + assertThat(template.postForEntity(url, body, var1, var2)).isEqualTo(entity) verify { template.postForEntity(url, body, Foo::class.java, var1, var2) } } @@ -188,7 +188,7 @@ class RestOperationsExtensionsTests { val body: Any = "body" val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) every { template.postForEntity(url, body, Foo::class.java, vars) } returns entity - assertEquals(entity, template.postForEntity(url, body, vars)) + assertThat(template.postForEntity(url, body, vars)).isEqualTo(entity) verify { template.postForEntity(url, body, Foo::class.java, vars) } } @@ -197,7 +197,7 @@ class RestOperationsExtensionsTests { val url = "https://spring.io" val body: Any = "body" every { template.postForEntity(url, body, Foo::class.java) } returns entity - assertEquals(entity, template.postForEntity(url, body)) + assertThat(template.postForEntity(url, body)).isEqualTo(entity) verify { template.postForEntity(url, body, Foo::class.java) } } @@ -205,7 +205,7 @@ class RestOperationsExtensionsTests { fun `postForEntity with reified type parameters`() { val url = "https://spring.io" every { template.postForEntity(url, null, Foo::class.java) } returns entity - assertEquals(entity, template.postForEntity(url)) + assertThat(template.postForEntity(url)).isEqualTo(entity) verify { template.postForEntity(url, null, Foo::class.java) } } @@ -218,7 +218,7 @@ class RestOperationsExtensionsTests { val entityList = mockk>>() val responseType = object : ParameterizedTypeReference>() {} every { template.exchange(url, method, entity, responseType, var1, var2) } returns entityList - assertEquals(entityList, template.exchange>(url, method, entity, var1, var2)) + assertThat(template.exchange>(url, method, entity, var1, var2)).isEqualTo(entityList) verify { template.exchange(url, method, entity, responseType, var1, var2) } } @@ -231,7 +231,7 @@ class RestOperationsExtensionsTests { val entityList = mockk>>() val responseType = object : ParameterizedTypeReference>() {} every { template.exchange(url, method, entity, responseType, vars) } returns entityList - assertEquals(entityList, template.exchange>(url, method, entity, vars)) + assertThat(template.exchange>(url, method, entity, vars)).isEqualTo(entityList) verify { template.exchange(url, method, entity, responseType, vars) } } @@ -243,7 +243,7 @@ class RestOperationsExtensionsTests { val entityList = mockk>>() val responseType = object : ParameterizedTypeReference>() {} every { template.exchange(url, method, entity, responseType) } returns entityList - assertEquals(entityList, template.exchange>(url, method, entity)) + assertThat(template.exchange>(url, method, entity)).isEqualTo(entityList) verify { template.exchange(url, method, entity, responseType) } } @@ -254,7 +254,7 @@ class RestOperationsExtensionsTests { val entityList = mockk>>() val responseType = object : ParameterizedTypeReference>() {} every { template.exchange(url, method, null, responseType) } returns entityList - assertEquals(entityList, template.exchange>(url, method)) + assertThat(template.exchange>(url, method)).isEqualTo(entityList) verify { template.exchange(url, method, null, responseType) } } @@ -264,7 +264,7 @@ class RestOperationsExtensionsTests { val entityList = mockk>>() val responseType = object : ParameterizedTypeReference>() {} every { template.exchange(entity, responseType) } returns entityList - assertEquals(entityList, template.exchange>(entity)) + assertThat(template.exchange>(entity)).isEqualTo(entityList) verify { template.exchange(entity, responseType) } } @@ -276,9 +276,8 @@ class RestOperationsExtensionsTests { if (method.parameterTypes.contains(kClass.java)) { val parameters = mutableListOf>(RestOperations::class.java).apply { addAll(method.parameterTypes.filter { it != kClass.java }) } val f = extensions.getDeclaredMethod(method.name, *parameters.toTypedArray()).kotlinFunction!! - assertEquals(1, f.typeParameters.size) - System.out.println(method.name + f.typeParameters) - assertEquals(listOf(Any::class.createType(nullable = true)), f.typeParameters[0].upperBounds, "Failed: " + method.name) + assertThat(f.typeParameters.size).isEqualTo(1) + assertThat(f.typeParameters[0].upperBounds).isEqualTo(listOf(Any::class.createType(nullable = true))) } } } diff --git a/spring-web/src/test/kotlin/org/springframework/web/method/annotation/RequestParamMethodArgumentResolverKotlinTests.kt b/spring-web/src/test/kotlin/org/springframework/web/method/annotation/RequestParamMethodArgumentResolverKotlinTests.kt index 945ba5aaf8..8321d7f811 100644 --- a/spring-web/src/test/kotlin/org/springframework/web/method/annotation/RequestParamMethodArgumentResolverKotlinTests.kt +++ b/spring-web/src/test/kotlin/org/springframework/web/method/annotation/RequestParamMethodArgumentResolverKotlinTests.kt @@ -16,9 +16,9 @@ package org.springframework.web.method.annotation -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertNull -import org.junit.jupiter.api.fail +import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.springframework.core.MethodParameter @@ -94,43 +94,39 @@ class RequestParamMethodArgumentResolverKotlinTests { fun resolveNullableRequiredWithParameter() { request.addParameter("name", "123") var result = resolver.resolveArgument(nullableParamRequired, null, webRequest, binderFactory) - assertEquals("123", result) + assertThat(result).isEqualTo("123") } @Test fun resolveNullableRequiredWithoutParameter() { var result = resolver.resolveArgument(nullableParamRequired, null, webRequest, binderFactory) - assertNull(result) + assertThat(result).isNull() } @Test fun resolveNullableNotRequiredWithParameter() { request.addParameter("name", "123") var result = resolver.resolveArgument(nullableParamNotRequired, null, webRequest, binderFactory) - assertEquals("123", result) + assertThat(result).isEqualTo("123") } @Test fun resolveNullableNotRequiredWithoutParameter() { var result = resolver.resolveArgument(nullableParamNotRequired, null, webRequest, binderFactory) - assertNull(result) + assertThat(result).isNull() } @Test fun resolveNonNullableRequiredWithParameter() { request.addParameter("name", "123") var result = resolver.resolveArgument(nonNullableParamRequired, null, webRequest, binderFactory) - assertEquals("123", result) + assertThat(result).isEqualTo("123") } @Test fun resolveNonNullableRequiredWithoutParameter() { - try { + assertThatExceptionOfType(MissingServletRequestParameterException::class.java).isThrownBy { resolver.resolveArgument(nonNullableParamRequired, null, webRequest, binderFactory) - fail("should have thrown a MissingServletRequestParameterException") - } - catch (e: MissingServletRequestParameterException) { - // expected } } @@ -138,17 +134,13 @@ class RequestParamMethodArgumentResolverKotlinTests { fun resolveNonNullableNotRequiredWithParameter() { request.addParameter("name", "123") var result = resolver.resolveArgument(nonNullableParamNotRequired, null, webRequest, binderFactory) - assertEquals("123", result) + assertThat(result).isEqualTo("123") } @Test fun resolveNonNullableNotRequiredWithoutParameter() { - try { + assertThatExceptionOfType(TypeCastException::class.java).isThrownBy { resolver.resolveArgument(nonNullableParamNotRequired, null, webRequest, binderFactory) as String - fail("should have thrown a TypeCastException") - } - catch (e: TypeCastException) { - // expected } } @@ -160,7 +152,7 @@ class RequestParamMethodArgumentResolverKotlinTests { webRequest = ServletWebRequest(request) var result = resolver.resolveArgument(nullableMultipartParamRequired, null, webRequest, binderFactory) - assertEquals(expected, result) + assertThat(result).isEqualTo(expected) } @Test @@ -169,7 +161,7 @@ class RequestParamMethodArgumentResolverKotlinTests { request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE var result = resolver.resolveArgument(nullableMultipartParamRequired, null, webRequest, binderFactory) - assertNull(result) + assertThat(result).isNull() } @Test @@ -180,7 +172,7 @@ class RequestParamMethodArgumentResolverKotlinTests { webRequest = ServletWebRequest(request) var result = resolver.resolveArgument(nullableMultipartParamNotRequired, null, webRequest, binderFactory) - assertEquals(expected, result) + assertThat(result).isEqualTo(expected) } @Test @@ -189,7 +181,7 @@ class RequestParamMethodArgumentResolverKotlinTests { request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE var result = resolver.resolveArgument(nullableMultipartParamNotRequired, null, webRequest, binderFactory) - assertNull(result) + assertThat(result).isNull() } @Test @@ -200,7 +192,7 @@ class RequestParamMethodArgumentResolverKotlinTests { webRequest = ServletWebRequest(request) var result = resolver.resolveArgument(nonNullableMultipartParamRequired, null, webRequest, binderFactory) - assertEquals(expected, result) + assertThat(result).isEqualTo(expected) } @Test @@ -208,12 +200,8 @@ class RequestParamMethodArgumentResolverKotlinTests { request.method = HttpMethod.POST.name request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE - try { + assertThatExceptionOfType(MissingServletRequestPartException::class.java).isThrownBy { resolver.resolveArgument(nonNullableMultipartParamRequired, null, webRequest, binderFactory) - fail("should have thrown a MissingServletRequestPartException") - } - catch (e: MissingServletRequestPartException) { - // expected } } @@ -225,7 +213,7 @@ class RequestParamMethodArgumentResolverKotlinTests { webRequest = ServletWebRequest(request) var result = resolver.resolveArgument(nonNullableMultipartParamNotRequired, null, webRequest, binderFactory) - assertEquals(expected, result) + assertThat(result).isEqualTo(expected) } @Test @@ -233,12 +221,8 @@ class RequestParamMethodArgumentResolverKotlinTests { request.method = HttpMethod.POST.name request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE - try { + assertThatExceptionOfType(TypeCastException::class.java).isThrownBy { resolver.resolveArgument(nonNullableMultipartParamNotRequired, null, webRequest, binderFactory) as MultipartFile - fail("should have thrown a TypeCastException") - } - catch (e: TypeCastException) { - // expected } } diff --git a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/ClientResponseExtensionsTests.kt b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/ClientResponseExtensionsTests.kt index 49e642af05..f728f930d1 100644 --- a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/ClientResponseExtensionsTests.kt +++ b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/ClientResponseExtensionsTests.kt @@ -21,8 +21,7 @@ import io.mockk.mockk import io.mockk.verify import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.runBlocking -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertNull +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.core.ParameterizedTypeReference import org.springframework.http.HttpStatus @@ -74,7 +73,7 @@ class ClientResponseExtensionsTests { val response = mockk() every { response.bodyToMono() } returns Mono.just("foo") runBlocking { - assertEquals("foo", response.awaitBody()) + assertThat(response.awaitBody()).isEqualTo("foo") } } @@ -83,7 +82,7 @@ class ClientResponseExtensionsTests { val response = mockk() every { response.bodyToMono() } returns Mono.empty() runBlocking { - assertNull(response.awaitBodyOrNull()) + assertThat(response.awaitBodyOrNull()).isNull() } } @@ -93,7 +92,7 @@ class ClientResponseExtensionsTests { val entity = ResponseEntity("foo", HttpStatus.OK) every { response.toEntity() } returns Mono.just(entity) runBlocking { - assertEquals(entity, response.awaitEntity()) + assertThat(response.awaitEntity()).isEqualTo(entity) } } @@ -103,7 +102,7 @@ class ClientResponseExtensionsTests { val entity = ResponseEntity(listOf("foo"), HttpStatus.OK) every { response.toEntityList() } returns Mono.just(entity) runBlocking { - assertEquals(entity, response.awaitEntityList()) + assertThat(response.awaitEntityList()).isEqualTo(entity) } } diff --git a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/WebClientExtensionsTests.kt b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/WebClientExtensionsTests.kt index bfe808c0e8..9f29db1c20 100644 --- a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/WebClientExtensionsTests.kt +++ b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/WebClientExtensionsTests.kt @@ -22,7 +22,7 @@ import io.mockk.verify import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.runBlocking -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.reactivestreams.Publisher import org.springframework.core.ParameterizedTypeReference @@ -86,7 +86,7 @@ class WebClientExtensionsTests { val response = mockk() every { requestBodySpec.exchange() } returns Mono.just(response) runBlocking { - assertEquals(response, requestBodySpec.awaitExchange()) + assertThat(requestBodySpec.awaitExchange()).isEqualTo(response) } } @@ -95,7 +95,7 @@ class WebClientExtensionsTests { val spec = mockk() every { spec.bodyToMono() } returns Mono.just("foo") runBlocking { - assertEquals("foo", spec.awaitBody()) + assertThat(spec.awaitBody()).isEqualTo("foo") } } diff --git a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/CoRouterFunctionDslTests.kt b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/CoRouterFunctionDslTests.kt index 49d93c3e1f..25e76fe045 100644 --- a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/CoRouterFunctionDslTests.kt +++ b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/CoRouterFunctionDslTests.kt @@ -16,8 +16,10 @@ package org.springframework.web.reactive.function.server -import org.junit.jupiter.api.fail +import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.jupiter.api.Test +import org.junit.jupiter.api.fail import org.springframework.core.io.ClassPathResource import org.springframework.http.HttpHeaders.* import org.springframework.http.HttpMethod.* @@ -122,12 +124,8 @@ class CoRouterFunctionDslTests { @Test fun emptyRouter() { - try { + assertThatExceptionOfType(IllegalStateException::class.java).isThrownBy { router { } - fail("should have thrown an IllegalStateException") - } - catch (e: IllegalStateException) { - // expected } } diff --git a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/RouterFunctionDslTests.kt b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/RouterFunctionDslTests.kt index fa61624c06..d3d18e2fd2 100644 --- a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/RouterFunctionDslTests.kt +++ b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/RouterFunctionDslTests.kt @@ -16,8 +16,10 @@ package org.springframework.web.reactive.function.server -import org.junit.jupiter.api.fail +import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.jupiter.api.Test +import org.junit.jupiter.api.fail import org.springframework.core.io.ClassPathResource import org.springframework.http.HttpHeaders.* import org.springframework.http.HttpMethod.* @@ -123,12 +125,8 @@ class RouterFunctionDslTests { @Test fun emptyRouter() { - try { + assertThatExceptionOfType(IllegalStateException::class.java).isThrownBy { router { } - fail("should have thrown an IllegalStateException") - } - catch (e: IllegalStateException) { - // expected } } diff --git a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerRequestExtensionsTests.kt b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerRequestExtensionsTests.kt index ce62c29219..5f69c29fd8 100644 --- a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerRequestExtensionsTests.kt +++ b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerRequestExtensionsTests.kt @@ -21,8 +21,7 @@ import io.mockk.mockk import io.mockk.verify import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.runBlocking -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertNull +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.core.ParameterizedTypeReference import org.springframework.http.codec.multipart.Part @@ -63,7 +62,7 @@ class ServerRequestExtensionsTests { fun awaitBody() { every { request.bodyToMono() } returns Mono.just("foo") runBlocking { - assertEquals("foo", request.awaitBody()) + assertThat(request.awaitBody()).isEqualTo("foo") } } @@ -71,7 +70,7 @@ class ServerRequestExtensionsTests { fun awaitBodyOrNull() { every { request.bodyToMono() } returns Mono.empty() runBlocking { - assertNull(request.awaitBodyOrNull()) + assertThat(request.awaitBodyOrNull()).isNull() } } @@ -80,7 +79,7 @@ class ServerRequestExtensionsTests { val map = mockk>() every { request.formData() } returns Mono.just(map) runBlocking { - assertEquals(map, request.awaitFormData()) + assertThat(request.awaitFormData()).isEqualTo(map) } } @@ -89,7 +88,7 @@ class ServerRequestExtensionsTests { val map = mockk>() every { request.multipartData() } returns Mono.just(map) runBlocking { - assertEquals(map, request.awaitMultipartData()) + assertThat(request.awaitMultipartData()).isEqualTo(map) } } @@ -98,7 +97,7 @@ class ServerRequestExtensionsTests { val principal = mockk() every { request.principal() } returns Mono.just(principal) runBlocking { - assertEquals(principal, request.awaitPrincipal()) + assertThat(request.awaitPrincipal()).isEqualTo(principal) } } @@ -107,7 +106,7 @@ class ServerRequestExtensionsTests { val session = mockk() every { request.session() } returns Mono.just(session) runBlocking { - assertEquals(session, request.awaitSession()) + assertThat(request.awaitSession()).isEqualTo(session) } } diff --git a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerResponseExtensionsTests.kt b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerResponseExtensionsTests.kt index 8fc3a99ce4..10c6971703 100644 --- a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerResponseExtensionsTests.kt +++ b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerResponseExtensionsTests.kt @@ -23,7 +23,7 @@ import io.reactivex.Flowable import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.runBlocking -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.reactivestreams.Publisher import org.springframework.core.ParameterizedTypeReference @@ -145,7 +145,7 @@ class ServerResponseExtensionsTests { val builder = mockk>() every { builder.build() } returns Mono.just(response) runBlocking { - assertEquals(response, builder.buildAndAwait()) + assertThat(builder.buildAndAwait()).isEqualTo(response) } } diff --git a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/KotlinInvocableHandlerMethodTests.kt b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/KotlinInvocableHandlerMethodTests.kt index 02714a72ad..4ab2dc3932 100644 --- a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/KotlinInvocableHandlerMethodTests.kt +++ b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/KotlinInvocableHandlerMethodTests.kt @@ -19,9 +19,7 @@ package org.springframework.web.reactive.result import io.mockk.every import io.mockk.mockk import kotlinx.coroutines.delay -import org.hamcrest.CoreMatchers.`is` -import org.hamcrest.MatcherAssert.assertThat -import org.junit.jupiter.api.Assertions.assertEquals +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.http.HttpStatus import org.springframework.http.server.reactive.ServerHttpResponse @@ -83,7 +81,7 @@ class KotlinInvocableHandlerMethodTests { val result = invoke(CoroutinesController(), method) assertHandlerResultValue(result, "created") - assertThat(this.exchange.response.statusCode, `is`(HttpStatus.CREATED)) + assertThat(this.exchange.response.statusCode).isSameAs(HttpStatus.CREATED) } @Test @@ -96,7 +94,7 @@ class KotlinInvocableHandlerMethodTests { StepVerifier.create(result) .consumeNextWith { StepVerifier.create(it.returnValue as Mono<*>).verifyComplete() } .verifyComplete() - assertEquals("bar", this.exchange.response.headers.getFirst("foo")) + assertThat(this.exchange.response.headers.getFirst("foo")).isEqualTo("bar") } private fun invoke(handler: Any, method: Method, vararg providedArgs: Any?): Mono { diff --git a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/method/annotation/CoroutinesIntegrationTests.kt b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/method/annotation/CoroutinesIntegrationTests.kt index eb4af83f14..369aa06fd8 100644 --- a/spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/method/annotation/CoroutinesIntegrationTests.kt +++ b/spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/method/annotation/CoroutinesIntegrationTests.kt @@ -17,14 +17,12 @@ package org.springframework.web.reactive.result.method.annotation import kotlinx.coroutines.Deferred -import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.async import kotlinx.coroutines.delay import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.flow -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.fail +import org.assertj.core.api.Assertions.* import org.springframework.context.ApplicationContext import org.springframework.context.annotation.AnnotationConfigApplicationContext import org.springframework.context.annotation.ComponentScan @@ -37,7 +35,6 @@ import org.springframework.web.bind.annotation.RestController import org.springframework.web.client.HttpServerErrorException import org.springframework.web.reactive.config.EnableWebFlux -@ExperimentalCoroutinesApi class CoroutinesIntegrationTests : AbstractRequestMappingIntegrationTests() { override fun initApplicationContext(): ApplicationContext { @@ -53,8 +50,8 @@ class CoroutinesIntegrationTests : AbstractRequestMappingIntegrationTests() { startServer(httpServer) val entity = performGet("/suspend", HttpHeaders.EMPTY, String::class.java) - assertEquals(HttpStatus.OK, entity.statusCode) - assertEquals("foo", entity.body) + assertThat(entity.statusCode).isEqualTo(HttpStatus.OK) + assertThat(entity.body).isEqualTo("foo") } @ParameterizedHttpServerTest @@ -62,8 +59,8 @@ class CoroutinesIntegrationTests : AbstractRequestMappingIntegrationTests() { startServer(httpServer) val entity = performGet("/deferred", HttpHeaders.EMPTY, String::class.java) - assertEquals(HttpStatus.OK, entity.statusCode) - assertEquals("foo", entity.body) + assertThat(entity.statusCode).isEqualTo(HttpStatus.OK) + assertThat(entity.body).isEqualTo("foo") } @ParameterizedHttpServerTest @@ -71,8 +68,8 @@ class CoroutinesIntegrationTests : AbstractRequestMappingIntegrationTests() { startServer(httpServer) val entity = performGet("/flow", HttpHeaders.EMPTY, String::class.java) - assertEquals(HttpStatus.OK, entity.statusCode) - assertEquals("foobar", entity.body) + assertThat(entity.statusCode).isEqualTo(HttpStatus.OK) + assertThat(entity.body).isEqualTo("foobar") } @ParameterizedHttpServerTest @@ -80,19 +77,16 @@ class CoroutinesIntegrationTests : AbstractRequestMappingIntegrationTests() { startServer(httpServer) val entity = performGet("/suspending-flow", HttpHeaders.EMPTY, String::class.java) - assertEquals(HttpStatus.OK, entity.statusCode) - assertEquals("foobar", entity.body) + assertThat(entity.statusCode).isEqualTo(HttpStatus.OK) + assertThat(entity.body).isEqualTo("foobar") } @ParameterizedHttpServerTest fun `Suspending handler method throwing exception`(httpServer: HttpServer) { startServer(httpServer) - try { + assertThatExceptionOfType(HttpServerErrorException.InternalServerError::class.java).isThrownBy { performGet("/error", HttpHeaders.EMPTY, String::class.java) - fail("should have thrown an HttpServerErrorException.InternalServerError") - } catch (e: HttpServerErrorException.InternalServerError) { - // expected } } @@ -100,11 +94,8 @@ class CoroutinesIntegrationTests : AbstractRequestMappingIntegrationTests() { fun `Handler method returning Flow throwing exception`(httpServer: HttpServer) { startServer(httpServer) - try { + assertThatExceptionOfType(HttpServerErrorException.InternalServerError::class.java).isThrownBy { performGet("/flow-error", HttpHeaders.EMPTY, String::class.java) - fail("should have thrown an HttpServerErrorException.InternalServerError") - } catch (e: HttpServerErrorException.InternalServerError) { - // expected } } diff --git a/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/RouterFunctionDslTests.kt b/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/RouterFunctionDslTests.kt index 468666a33a..a5a432c6e9 100644 --- a/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/RouterFunctionDslTests.kt +++ b/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/RouterFunctionDslTests.kt @@ -16,9 +16,7 @@ package org.springframework.web.servlet.function -import org.junit.jupiter.api.Assertions.assertFalse -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.fail +import org.assertj.core.api.Assertions.* import org.junit.jupiter.api.Test import org.springframework.core.io.ClassPathResource import org.springframework.http.HttpHeaders.* @@ -38,7 +36,7 @@ class RouterFunctionDslTests { val servletRequest = MockHttpServletRequest() servletRequest.addHeader("bar", "bar") val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isTrue() } @Test @@ -46,7 +44,7 @@ class RouterFunctionDslTests { val servletRequest = MockHttpServletRequest("GET", "/content") servletRequest.addHeader(ACCEPT, APPLICATION_ATOM_XML_VALUE) val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isTrue() } @Test @@ -54,7 +52,7 @@ class RouterFunctionDslTests { val servletRequest = MockHttpServletRequest("POST", "/api/foo/") servletRequest.addHeader(ACCEPT, APPLICATION_JSON_VALUE) val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isTrue() } @Test @@ -62,35 +60,35 @@ class RouterFunctionDslTests { val servletRequest = MockHttpServletRequest("GET", "/content") servletRequest.addHeader(CONTENT_TYPE, APPLICATION_OCTET_STREAM_VALUE) val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isTrue() } @Test fun resourceByPath() { val servletRequest = MockHttpServletRequest("GET", "/org/springframework/web/servlet/function/response.txt") val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isTrue() } @Test fun method() { val servletRequest = MockHttpServletRequest("PATCH", "/") val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isTrue() } @Test fun path() { val servletRequest = MockHttpServletRequest("GET", "/baz") val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isTrue() } @Test fun resource() { val servletRequest = MockHttpServletRequest("GET", "/response.txt") val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isTrue() } @Test @@ -100,24 +98,20 @@ class RouterFunctionDslTests { servletRequest.addHeader(ACCEPT, APPLICATION_PDF_VALUE) servletRequest.addHeader(CONTENT_TYPE, APPLICATION_PDF_VALUE) val request = DefaultServerRequest(servletRequest, emptyList()) - assertFalse(sampleRouter().route(request).isPresent) + assertThat(sampleRouter().route(request).isPresent).isFalse() } @Test fun rendering() { val servletRequest = MockHttpServletRequest("GET", "/rendering") val request = DefaultServerRequest(servletRequest, emptyList()) - assertTrue(sampleRouter().route(request).get().handle(request) is RenderingResponse) + assertThat(sampleRouter().route(request).get().handle(request) is RenderingResponse).isTrue() } @Test fun emptyRouter() { - try { + assertThatExceptionOfType(IllegalStateException::class.java).isThrownBy { router { } - fail("should have thrown an IllegalStateException") - } - catch (e: IllegalStateException) { - // expected } } diff --git a/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/ServerRequestExtensionsTests.kt b/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/ServerRequestExtensionsTests.kt index 1fbf8eebaf..952eac0a62 100644 --- a/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/ServerRequestExtensionsTests.kt +++ b/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/ServerRequestExtensionsTests.kt @@ -19,8 +19,7 @@ package org.springframework.web.servlet.function import io.mockk.every import io.mockk.mockk import io.mockk.verify -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertNull +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.core.ParameterizedTypeReference import org.springframework.http.MediaType @@ -43,23 +42,23 @@ class ServerRequestExtensionsTests { fun `remoteAddressOrNull with value`() { val remoteAddress = mockk() every { request.remoteAddress() } returns Optional.of(remoteAddress) - assertEquals(remoteAddress, request.remoteAddressOrNull()) + assertThat(remoteAddress).isEqualTo(request.remoteAddressOrNull()) verify { request.remoteAddress() } } @Test fun `remoteAddressOrNull with null`() { every { request.remoteAddress() } returns Optional.empty() - assertNull(request.remoteAddressOrNull()) + assertThat(request.remoteAddressOrNull()).isNull() verify { request.remoteAddress() } } @Test fun body() { - val body = Arrays.asList("foo", "bar") + val body = listOf("foo", "bar") val typeReference = object: ParameterizedTypeReference>() {} every { request.body(typeReference) } returns body - assertEquals(body, request.body>()) + assertThat(request.body>()).isEqualTo(body) verify { request.body(typeReference) } } @@ -67,14 +66,14 @@ class ServerRequestExtensionsTests { fun `attributeOrNull with value`() { val attribute = mockk() every { request.attribute("foo") } returns Optional.of(attribute) - assertEquals(attribute, request.attributeOrNull("foo")) + assertThat(request.attributeOrNull("foo")).isEqualTo(attribute) verify { request.attribute("foo") } } @Test fun `attributeOrNull with null`() { every { request.attribute("foo") } returns Optional.empty() - assertNull(request.attributeOrNull("foo")) + assertThat(request.attributeOrNull("foo")).isNull() verify { request.attribute("foo") } } @@ -82,14 +81,14 @@ class ServerRequestExtensionsTests { fun `paramOrNull with value`() { val param = "bar" every { request.param("foo") } returns Optional.of(param) - assertEquals(param, request.paramOrNull("foo")) + assertThat(request.paramOrNull("foo")).isEqualTo(param) verify { request.param("foo") } } @Test fun `paramOrNull with null`() { every { request.param("foo") } returns Optional.empty() - assertNull(request.paramOrNull("foo")) + assertThat(request.paramOrNull("foo")).isNull() verify { request.param("foo") } } @@ -97,14 +96,14 @@ class ServerRequestExtensionsTests { fun `principalOrNull with value`() { val principal = mockk() every { request.principal() } returns Optional.of(principal) - assertEquals(principal, request.principalOrNull()) + assertThat(request.principalOrNull()).isEqualTo(principal) verify { request.principal() } } @Test fun `principalOrNull with null`() { every { request.principal() } returns Optional.empty() - assertNull(request.principalOrNull()) + assertThat(request.principalOrNull()).isNull() verify { request.principal() } } @@ -112,14 +111,14 @@ class ServerRequestExtensionsTests { fun `contentLengthOrNull with value`() { val contentLength: Long = 123 every { headers.contentLength() } returns OptionalLong.of(contentLength) - assertEquals(contentLength, headers.contentLengthOrNull()) + assertThat(headers.contentLengthOrNull()).isEqualTo(contentLength) verify { headers.contentLength() } } @Test fun `contentLengthOrNull with null`() { every { headers.contentLength() } returns OptionalLong.empty() - assertNull(headers.contentLengthOrNull()) + assertThat(headers.contentLengthOrNull()).isNull() verify { headers.contentLength() } } @@ -127,14 +126,14 @@ class ServerRequestExtensionsTests { fun `contentTypeOrNull with value`() { val contentType = mockk() every { headers.contentType() } returns Optional.of(contentType) - assertEquals(contentType, headers.contentTypeOrNull()) + assertThat(headers.contentTypeOrNull()).isEqualTo(contentType) verify { headers.contentType() } } @Test fun `contentTypeOrNull with null`() { every { headers.contentType() } returns Optional.empty() - assertNull(headers.contentTypeOrNull()) + assertThat(headers.contentTypeOrNull()).isNull() verify { headers.contentType() } } } diff --git a/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/ServerResponseExtensionsTests.kt b/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/ServerResponseExtensionsTests.kt index e55377e58d..b3748279f7 100644 --- a/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/ServerResponseExtensionsTests.kt +++ b/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/function/ServerResponseExtensionsTests.kt @@ -19,10 +19,9 @@ package org.springframework.web.servlet.function import io.mockk.every import io.mockk.mockk import io.mockk.verify +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.core.ParameterizedTypeReference -import java.util.* -import org.junit.jupiter.api.Assertions.assertEquals /** * Tests for WebMvc.fn [ServerResponse] extensions. @@ -35,10 +34,10 @@ class ServerResponseExtensionsTests { fun bodyWithType() { val builder = mockk() val response = mockk() - val body = Arrays.asList("foo", "bar") + val body = listOf("foo", "bar") val typeReference = object: ParameterizedTypeReference>() {} every { builder.body(body, typeReference) } returns response - assertEquals(response, builder.bodyWithType>(body)) + assertThat(builder.bodyWithType>(body)).isEqualTo(response) verify { builder.body(body, typeReference) } } } diff --git a/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodKotlinTests.kt b/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodKotlinTests.kt index 27fd0365ac..f457dab5e4 100644 --- a/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodKotlinTests.kt +++ b/spring-webmvc/src/test/kotlin/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodKotlinTests.kt @@ -1,5 +1,5 @@ /* - * Copyright 2002-2017 the original author or authors. + * Copyright 2002-2019 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +16,7 @@ package org.springframework.web.servlet.mvc.method.annotation -import org.junit.jupiter.api.Assertions.* +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.springframework.mock.web.test.MockHttpServletRequest import org.springframework.mock.web.test.MockHttpServletResponse @@ -37,7 +37,7 @@ class ServletAnnotationControllerHandlerMethodKotlinTests : AbstractServletHandl request.addParameter("param2", "2") val response = MockHttpServletResponse() servlet.service(request, response) - assertEquals("value1-2", response.contentAsString) + assertThat(response.contentAsString).isEqualTo("value1-2") } @Test @@ -49,7 +49,7 @@ class ServletAnnotationControllerHandlerMethodKotlinTests : AbstractServletHandl request.addParameter("param2", "2") val response = MockHttpServletResponse() servlet.service(request, response) - assertEquals("value1-2", response.contentAsString) + assertThat(response.contentAsString).isEqualTo("value1-2") } @Test @@ -60,7 +60,7 @@ class ServletAnnotationControllerHandlerMethodKotlinTests : AbstractServletHandl request.addParameter("param1", "value1") val response = MockHttpServletResponse() servlet.service(request, response) - assertEquals("value1-12", response.contentAsString) + assertThat(response.contentAsString).isEqualTo("value1-12") }