DATAMONGO-2209 - Polishing.

Convert spaces to tabs. Add ticket references to tests. Reformat code.

Original pull request: #649.

spring-data-mongodb/pom.xml

@@ -266,11 +266,13 @@
 			<artifactId>kotlin-stdlib</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 		<dependency>
 			<groupId>org.jetbrains.kotlin</groupId>
 			<artifactId>kotlin-reflect</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 		<dependency>
 			<groupId>org.jetbrains.kotlinx</groupId>
 			<artifactId>kotlinx-coroutines-core</artifactId>

spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensions.kt

@@ -89,5 +89,5 @@ suspend fun <T : Any> ReactiveUpdateOperation.TerminatingUpdate<T>.upsertAndAwai
  * @author Sebastien Deleuze
  * @since 2.2
  */
-inline fun <reified T : Any> ReactiveUpdateOperation.FindAndReplaceWithProjection<T>.asType(): ReactiveUpdateOperation.FindAndReplaceWithOptions<T> =
+inline fun <reified T : Any> ReactiveUpdateOperation.FindAndReplaceWithProjection<*>.asType(): ReactiveUpdateOperation.FindAndReplaceWithOptions<T> =
 		`as`(T::class.java)

spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensionsTests.kt

@@ -20,6 +20,7 @@ import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import kotlinx.coroutines.runBlocking
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Assert.assertEquals
 import org.junit.Test
 import reactor.core.publisher.Mono
@@ -78,49 +79,61 @@ class ReactiveFindOperationExtensionsTests {
 		verify { distinctWithProjection.`as`(User::class.java) }
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun terminatingFindAwaitOne() {
+
 		val find = mockk<ReactiveFindOperation.TerminatingFind<String>>()
 		every { find.one() } returns Mono.just("foo")
+
 		runBlocking {
-			assertEquals("foo", find.awaitOne())
+			assertThat(find.awaitOne()).isEqualTo("foo")
 		}
+
 		verify {
 			find.one()
 		}
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun terminatingFindAwaitFirst() {
+
 		val find = mockk<ReactiveFindOperation.TerminatingFind<String>>()
 		every { find.first() } returns Mono.just("foo")
+
 		runBlocking {
-			assertEquals("foo", find.awaitFirst())
+			assertThat(find.awaitFirst()).isEqualTo("foo")
 		}
+
 		verify {
 			find.first()
 		}
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun terminatingFindAwaitCount() {
+
 		val find = mockk<ReactiveFindOperation.TerminatingFind<String>>()
 		every { find.count() } returns Mono.just(1)
+
 		runBlocking {
-			assertEquals(1, find.awaitCount())
+			assertThat(find.awaitCount()).isEqualTo(1)
 		}
+
 		verify {
 			find.count()
 		}
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun terminatingFindAwaitExists() {
+
 		val find = mockk<ReactiveFindOperation.TerminatingFind<String>>()
 		every { find.exists() } returns Mono.just(true)
+
 		runBlocking {
-			assertEquals(true, find.awaitExists())
+			assertThat(find.awaitExists()).isTrue()
 		}
+
 		verify {
 			find.exists()
 		}

spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveInsertOperationExtensionsTests.kt

@@ -20,7 +20,7 @@ import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert.assertEquals
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
 import reactor.core.publisher.Mono
 
@@ -46,13 +46,16 @@ class ReactiveInsertOperationExtensionsTests {
 		verify { operation.insert(First::class.java) }
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun terminatingFindAwaitOne() {
+
 		val find = mockk<ReactiveInsertOperation.TerminatingInsert<String>>()
 		every { find.one("foo") } returns Mono.just("foo")
+
 		runBlocking {
-			assertEquals("foo", find.oneAndAwait("foo"))
+			assertThat(find.oneAndAwait("foo")).isEqualTo("foo")
 		}
+
 		verify {
 			find.one("foo")
 		}

spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveRemoveOperationExtensionsTests.kt

@@ -21,7 +21,7 @@ import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert.assertEquals
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
 import reactor.core.publisher.Mono
 
@@ -47,14 +47,17 @@ class ReactiveRemoveOperationExtensionsTests {
 		verify { operation.remove(First::class.java) }
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun allAndAwait() {
+
 		val remove = mockk<ReactiveRemoveOperation.TerminatingRemove<String>>()
 		val result = mockk<DeleteResult>()
 		every { remove.all() } returns Mono.just(result)
+
 		runBlocking {
-			assertEquals(result, remove.allAndAwait())
+			assertThat(remove.allAndAwait()).isEqualTo(result)
 		}
+
 		verify {
 			remove.all()
 		}

spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensionsTests.kt

@@ -21,7 +21,7 @@ import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert.assertEquals
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
 import reactor.core.publisher.Mono
 
@@ -49,75 +49,93 @@ class ReactiveUpdateOperationExtensionsTests {
 		verify { operation.update(First::class.java) }
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun findModifyAndAwait() {
+
 		val find = mockk<ReactiveUpdateOperation.TerminatingFindAndModify<String>>()
 		every { find.findAndModify() } returns Mono.just("foo")
+
 		runBlocking {
-			assertEquals("foo", find.findModifyAndAwait())
+			assertThat(find.findModifyAndAwait()).isEqualTo("foo")
 		}
+
 		verify {
 			find.findAndModify()
 		}
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun findReplaceAndAwait() {
+
 		val find = mockk<ReactiveUpdateOperation.TerminatingFindAndReplace<String>>()
 		every { find.findAndReplace() } returns Mono.just("foo")
+
 		runBlocking {
-			assertEquals("foo", find.findReplaceAndAwait())
+			assertThat(find.findReplaceAndAwait()).isEqualTo("foo")
 		}
+
 		verify {
 			find.findAndReplace()
 		}
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun allAndAwait() {
+
 		val update = mockk<ReactiveUpdateOperation.TerminatingUpdate<String>>()
 		val result = mockk<UpdateResult>()
 		every { update.all() } returns Mono.just(result)
+
 		runBlocking {
-			assertEquals(result, update.allAndAwait())
+			assertThat(update.allAndAwait()).isEqualTo(result)
 		}
+
 		verify {
 			update.all()
 		}
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun firstAndAwait() {
+
 		val update = mockk<ReactiveUpdateOperation.TerminatingUpdate<String>>()
 		val result = mockk<UpdateResult>()
 		every { update.first() } returns Mono.just(result)
+
 		runBlocking {
-			assertEquals(result, update.firstAndAwait())
+			assertThat(update.firstAndAwait()).isEqualTo(result)
 		}
+
 		verify {
 			update.first()
 		}
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun upsertAndAwait() {
+
 		val update = mockk<ReactiveUpdateOperation.TerminatingUpdate<String>>()
 		val result = mockk<UpdateResult>()
 		every { update.upsert() } returns Mono.just(result)
+
 		runBlocking {
-			assertEquals(result, update.upsertAndAwait())
+			assertThat(update.upsertAndAwait()).isEqualTo(result)
 		}
+
 		verify {
 			update.upsert()
 		}
 	}
 
-	@Test
+	@Test // DATAMONGO-2209
 	fun findAndReplaceWithProjectionAsType() {
+
 		val update = mockk<ReactiveUpdateOperation.FindAndReplaceWithProjection<String>>()
 		val result = mockk<ReactiveUpdateOperation.FindAndReplaceWithOptions<String>>()
 		every { update.`as`(String::class.java) } returns result
-		assertEquals(result, update.asType<String>())
+
+		assertThat(update.asType<String>()).isEqualTo(result)
+
 		verify {
 			update.`as`(String::class.java)
 		}