Migrate to AssertJ in Kotlin tests

Closes gh-23475

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 <reified T : Any> RSocketRequester.RequestSpec.dataWithType(publisher
  * @author Sebastien Deleuze
  * @since 5.2
  */
-@ExperimentalCoroutinesApi
 inline fun <reified T : Any> RSocketRequester.RequestSpec.dataWithType(flow: Flow<T>): RSocketRequester.ResponseSpec =
 		data(flow, object : ParameterizedTypeReference<T>() {})
 
@@ -120,7 +118,6 @@ suspend inline fun <reified T : Any> RSocketRequester.ResponseSpec.retrieveAndAw
  * @author Sebastien Deleuze
  * @since 5.2
  */
-@ExperimentalCoroutinesApi
 inline fun <reified T : Any> RSocketRequester.ResponseSpec.retrieveFlow(): Flow<T> =
 		retrieveFlux(object : ParameterizedTypeReference<T>() {}).asFlow()
 

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<RSocketRequester.Builder>()
 		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<RSocketRequester.Builder>()
 		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<RSocketRequester.Builder>()
 		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<RSocketRequester.ResponseSpec>()
 		val data = mockk<Publisher<String>>()
 		every { requestSpec.data(any<Publisher<String>>(), match<ParameterizedTypeReference<*>>(stringTypeRefMatcher)) } returns responseSpec
-		assertEquals(responseSpec, requestSpec.dataWithType(data))
+		assertThat(requestSpec.dataWithType(data)).isEqualTo(responseSpec)
 	}
 
 	@Test
@@ -71,7 +85,7 @@ class RSocketRequesterExtensionsTests {
 		val responseSpec = mockk<RSocketRequester.ResponseSpec>()
 		val data = mockk<Flow<String>>()
 		every { requestSpec.data(any<Publisher<String>>(), match<ParameterizedTypeReference<*>>(stringTypeRefMatcher)) } returns responseSpec
-		assertEquals(responseSpec, requestSpec.dataWithType(data))
+		assertThat(requestSpec.dataWithType(data)).isEqualTo(responseSpec)
 	}
 
 	@Test
@@ -80,7 +94,7 @@ class RSocketRequesterExtensionsTests {
 		val responseSpec = mockk<RSocketRequester.ResponseSpec>()
 		val data = mockk<CompletableFuture<String>>()
 		every { requestSpec.data(any<Publisher<String>>(), match<ParameterizedTypeReference<*>>(stringTypeRefMatcher)) } returns responseSpec
-		assertEquals(responseSpec, requestSpec.dataWithType<String>(data))
+		assertThat(requestSpec.dataWithType<String>(data)).isEqualTo(responseSpec)
 	}
 
 	@Test
@@ -88,7 +102,7 @@ class RSocketRequesterExtensionsTests {
 		val requestSpec = mockk<RSocketRequester.RequestSpec>()
 		val responseSpec = mockk<RSocketRequester.ResponseSpec>()
 		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<RSocketRequester.ResponseSpec>()
 		every { responseSpec.retrieveMono(match<ParameterizedTypeReference<*>>(stringTypeRefMatcher)) } returns Mono.just("foo")
 		runBlocking {
-			assertEquals(response, responseSpec.retrieveAndAwait<String>())
+			assertThat(responseSpec.retrieveAndAwait<String>()).isEqualTo(response)
 		}
 	}
 
@@ -115,7 +129,7 @@ class RSocketRequesterExtensionsTests {
 		val responseSpec = mockk<RSocketRequester.ResponseSpec>()
 		every { responseSpec.retrieveFlux(match<ParameterizedTypeReference<*>>(stringTypeRefMatcher)) } returns Flux.just("foo", "bar")
 		runBlocking {
-			assertEquals(listOf("foo", "bar"), responseSpec.retrieveFlow<String>().toList())
+			assertThat(responseSpec.retrieveFlow<String>().toList()).contains("foo", "bar")
 		}
 	}
 
@@ -124,7 +138,7 @@ class RSocketRequesterExtensionsTests {
 		val responseSpec = mockk<RSocketRequester.ResponseSpec>()
 		every { responseSpec.retrieveMono(match<ParameterizedTypeReference<*>>(stringTypeRefMatcher)) } returns Mono.just("foo")
 		runBlocking {
-			assertEquals("foo", responseSpec.retrieveMono<String>().block())
+			assertThat(responseSpec.retrieveMono<String>().block()).isEqualTo("foo")
 		}
 	}
 
@@ -133,7 +147,7 @@ class RSocketRequesterExtensionsTests {
 		val responseSpec = mockk<RSocketRequester.ResponseSpec>()
 		every { responseSpec.retrieveFlux(match<ParameterizedTypeReference<*>>(stringTypeRefMatcher)) } returns Flux.just("foo", "bar")
 		runBlocking {
-			assertEquals(listOf("foo", "bar"), responseSpec.retrieveFlux<String>().collectList().block())
+			assertThat(responseSpec.retrieveFlux<String>().collectList().block()).contains("foo", "bar")
 		}
 	}
 

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<String, String?>): Message<ByteArray> {