Migrate to AssertJ in Kotlin tests

Closes gh-23475

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<Foo>(url, var1, var2))
+		assertThat(template.getForObject<Foo>(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<Foo>(url, vars))
+		assertThat(template.getForObject<Foo>(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<Foo>(url))
+		assertThat(template.getForObject<Foo>(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<Foo>(url))
+		assertThat(template.getForEntity<Foo>(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<Foo>(url, var1, var2))
+		assertThat(template.getForEntity<Foo>(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<Foo>(url, vars))
+		assertThat(template.getForEntity<Foo>(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<Foo>(url, body, var1, var2))
+		assertThat(template.patchForObject<Foo>(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<Foo>(url, body, vars))
+		assertThat(template.patchForObject<Foo>(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<Foo>(url, body))
+		assertThat(template.patchForObject<Foo>(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<Foo>(url))
+		assertThat(template.patchForObject<Foo>(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<Foo>(url, body, var1, var2))
+		assertThat(template.postForObject<Foo>(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<Foo>(url, body, vars))
+		assertThat(template.postForObject<Foo>(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<Foo>(url, body))
+		assertThat(template.postForObject<Foo>(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<Foo>(url))
+		assertThat(template.postForObject<Foo>(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<Foo>(url, body, var1, var2))
+		assertThat(template.postForEntity<Foo>(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<Foo>(url, body, vars))
+		assertThat(template.postForEntity<Foo>(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<Foo>(url, body))
+		assertThat(template.postForEntity<Foo>(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<Foo>(url))
+		assertThat(template.postForEntity<Foo>(url)).isEqualTo(entity)
 		verify { template.postForEntity(url, null, Foo::class.java) }
 	}
 
@@ -218,7 +218,7 @@ class RestOperationsExtensionsTests {
 		val entityList = mockk<ResponseEntity<List<Foo>>>()
 		val responseType = object : ParameterizedTypeReference<List<Foo>>() {}
 		every { template.exchange(url, method, entity, responseType, var1, var2) } returns entityList
-		assertEquals(entityList, template.exchange<List<Foo>>(url, method, entity, var1, var2))
+		assertThat(template.exchange<List<Foo>>(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<ResponseEntity<List<Foo>>>()
 		val responseType = object : ParameterizedTypeReference<List<Foo>>() {}
 		every { template.exchange(url, method, entity, responseType, vars) } returns entityList
-		assertEquals(entityList, template.exchange<List<Foo>>(url, method, entity, vars))
+		assertThat(template.exchange<List<Foo>>(url, method, entity, vars)).isEqualTo(entityList)
 		verify { template.exchange(url, method, entity, responseType, vars) }
 	}
 
@@ -243,7 +243,7 @@ class RestOperationsExtensionsTests {
 		val entityList = mockk<ResponseEntity<List<Foo>>>()
 		val responseType = object : ParameterizedTypeReference<List<Foo>>() {}
 		every { template.exchange(url, method, entity, responseType) } returns entityList
-		assertEquals(entityList, template.exchange<List<Foo>>(url, method, entity))
+		assertThat(template.exchange<List<Foo>>(url, method, entity)).isEqualTo(entityList)
 		verify { template.exchange(url, method, entity, responseType) }
 	}
 
@@ -254,7 +254,7 @@ class RestOperationsExtensionsTests {
 		val entityList = mockk<ResponseEntity<List<Foo>>>()
 		val responseType = object : ParameterizedTypeReference<List<Foo>>() {}
 		every { template.exchange(url, method, null, responseType) } returns entityList
-		assertEquals(entityList, template.exchange<List<Foo>>(url, method))
+		assertThat(template.exchange<List<Foo>>(url, method)).isEqualTo(entityList)
 		verify { template.exchange(url, method, null, responseType) }
 	}
 
@@ -264,7 +264,7 @@ class RestOperationsExtensionsTests {
 		val entityList = mockk<ResponseEntity<List<Foo>>>()
 		val responseType = object : ParameterizedTypeReference<List<Foo>>() {}
 		every { template.exchange(entity, responseType) } returns entityList
-		assertEquals(entityList, template.exchange<List<Foo>>(entity))
+		assertThat(template.exchange<List<Foo>>(entity)).isEqualTo(entityList)
 		verify { template.exchange(entity, responseType) }
 	}
 
@@ -276,9 +276,8 @@ class RestOperationsExtensionsTests {
 				if (method.parameterTypes.contains(kClass.java)) {
 					val parameters = mutableListOf<Class<*>>(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)))
 				}
 			}
 		}

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
 		}
 	}