From 952ce1acc011a100f4cbcdad6f3da3034389da04 Mon Sep 17 00:00:00 2001 From: Sebastien Deleuze Date: Wed, 3 Apr 2019 12:26:30 +0200 Subject: [PATCH] Add non-nullable variants to Coroutines extensions --- .../core/ReactiveFindOperationExtensions.kt | 26 ++++- .../core/ReactiveUpdateOperationExtensions.kt | 25 ++++- .../ReactiveFindOperationExtensionsTests.kt | 96 ++++++++++++++++++- .../ReactiveUpdateOperationExtensionsTests.kt | 95 +++++++++++++++++- 4 files changed, 229 insertions(+), 13 deletions(-) diff --git a/spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensions.kt b/spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensions.kt index d133956925..0a70ae675e 100644 --- a/spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensions.kt +++ b/spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensions.kt @@ -77,21 +77,39 @@ inline fun ReactiveFindOperation.DistinctWithProjection.asType `as`(T::class.java) /** - * Coroutines variant of [ReactiveFindOperation.TerminatingFind.one]. + * Non-nullable Coroutines variant of [ReactiveFindOperation.TerminatingFind.one]. * * @author Sebastien Deleuze * @since 2.2 */ -suspend inline fun ReactiveFindOperation.TerminatingFind.awaitOne(): T? = +suspend inline fun ReactiveFindOperation.TerminatingFind.awaitOne(): T = + one().awaitSingle() + +/** + * Nullable Coroutines variant of [ReactiveFindOperation.TerminatingFind.one]. + * + * @author Sebastien Deleuze + * @since 2.2 + */ +suspend inline fun ReactiveFindOperation.TerminatingFind.awaitOneOrNull(): T? = one().awaitFirstOrNull() /** - * Coroutines variant of [ReactiveFindOperation.TerminatingFind.first]. + * Non-nullable Coroutines variant of [ReactiveFindOperation.TerminatingFind.first]. + * + * @author Sebastien Deleuze + * @since 2.2 + */ +suspend inline fun ReactiveFindOperation.TerminatingFind.awaitFirst(): T = + first().awaitSingle() + +/** + * Nullable Coroutines variant of [ReactiveFindOperation.TerminatingFind.first]. * * @author Sebastien Deleuze * @since 2.2 */ -suspend inline fun ReactiveFindOperation.TerminatingFind.awaitFirst(): T? = +suspend inline fun ReactiveFindOperation.TerminatingFind.awaitFirstOrNull(): T? = first().awaitFirstOrNull() /** diff --git a/spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensions.kt b/spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensions.kt index 5922619c5e..1bbba22e55 100644 --- a/spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensions.kt +++ b/spring-data-mongodb/src/main/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensions.kt @@ -40,22 +40,39 @@ inline fun ReactiveUpdateOperation.update(): ReactiveUpdateOpe update(T::class.java) /** - * Coroutines variant of [ReactiveUpdateOperation.TerminatingFindAndModify.findModifyAndAwait]. + * Non-nullable Coroutines variant of [ReactiveUpdateOperation.TerminatingFindAndModify.findModifyAndAwait]. * * @author Sebastien Deleuze * @since 2.2 */ -suspend fun ReactiveUpdateOperation.TerminatingFindAndModify.findModifyAndAwait(): T? = +suspend fun ReactiveUpdateOperation.TerminatingFindAndModify.findModifyAndAwait(): T = + findAndModify().awaitSingle() + +/** + * Nullable Coroutines variant of [ReactiveUpdateOperation.TerminatingFindAndModify.findModifyAndAwait]. + * + * @author Sebastien Deleuze + * @since 2.2 + */ +suspend fun ReactiveUpdateOperation.TerminatingFindAndModify.findModifyAndAwaitOrNull(): T? = findAndModify().awaitFirstOrNull() +/** + * Non-nullable Coroutines variant of [ReactiveUpdateOperation.TerminatingFindAndReplace.findAndReplace]. + * + * @author Sebastien Deleuze + * @since 2.2 + */ +suspend fun ReactiveUpdateOperation.TerminatingFindAndReplace.findReplaceAndAwait(): T = + findAndReplace().awaitSingle() /** - * Coroutines variant of [ReactiveUpdateOperation.TerminatingFindAndReplace.findAndReplace]. + * Nullable Coroutines variant of [ReactiveUpdateOperation.TerminatingFindAndReplace.findAndReplace]. * * @author Sebastien Deleuze * @since 2.2 */ -suspend fun ReactiveUpdateOperation.TerminatingFindAndReplace.findReplaceAndAwait(): T? = +suspend fun ReactiveUpdateOperation.TerminatingFindAndReplace.findReplaceAndAwaitOrNull(): T? = findAndReplace().awaitFirstOrNull() /** diff --git a/spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensionsTests.kt b/spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensionsTests.kt index e42211fbad..21f6a1d6a8 100644 --- a/spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensionsTests.kt +++ b/spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveFindOperationExtensionsTests.kt @@ -21,7 +21,7 @@ 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.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.Test import reactor.core.publisher.Mono @@ -80,7 +80,7 @@ class ReactiveFindOperationExtensionsTests { } @Test // DATAMONGO-2209 - fun terminatingFindAwaitOne() { + fun terminatingFindAwaitOneWithValue() { val find = mockk>() every { find.one() } returns Mono.just("foo") @@ -95,7 +95,52 @@ class ReactiveFindOperationExtensionsTests { } @Test // DATAMONGO-2209 - fun terminatingFindAwaitFirst() { + fun terminatingFindAwaitOneWithNull() { + + val find = mockk>() + every { find.one() } returns Mono.empty() + + assertThatExceptionOfType(NoSuchElementException::class.java).isThrownBy { + runBlocking { find.awaitOne() } + } + + verify { + find.one() + } + } + + @Test // DATAMONGO-2209 + fun terminatingFindAwaitOneOrNullWithValue() { + + val find = mockk>() + every { find.one() } returns Mono.just("foo") + + runBlocking { + assertThat(find.awaitOneOrNull()).isEqualTo("foo") + } + + verify { + find.one() + } + } + + @Test // DATAMONGO-2209 + fun terminatingFindAwaitOneOrNullWithNull() { + + val find = mockk>() + every { find.one() } returns Mono.empty() + + runBlocking { + assertThat(find.awaitOneOrNull()).isNull() + } + + verify { + find.one() + } + } + + @Test // DATAMONGO-2209 + fun terminatingFindAwaitFirstWithValue() { val find = mockk>() every { find.first() } returns Mono.just("foo") @@ -109,6 +154,51 @@ class ReactiveFindOperationExtensionsTests { } } + @Test // DATAMONGO-2209 + fun terminatingFindAwaitFirstWithNull() { + + val find = mockk>() + every { find.first() } returns Mono.empty() + + assertThatExceptionOfType(NoSuchElementException::class.java).isThrownBy { + runBlocking { find.awaitFirst() } + } + + verify { + find.first() + } + } + + @Test // DATAMONGO-2209 + fun terminatingFindAwaitFirstOrNullWithValue() { + + val find = mockk>() + every { find.first() } returns Mono.just("foo") + + runBlocking { + assertThat(find.awaitFirstOrNull()).isEqualTo("foo") + } + + verify { + find.first() + } + } + + @Test // DATAMONGO-2209 + fun terminatingFindAwaitFirstOrNullWithNull() { + + val find = mockk>() + every { find.first() } returns Mono.empty() + + runBlocking { + assertThat(find.awaitFirstOrNull()).isNull() + } + + verify { + find.first() + } + } + @Test // DATAMONGO-2209 fun terminatingFindAwaitCount() { diff --git a/spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensionsTests.kt b/spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensionsTests.kt index b1e30cde18..4dc46c1c29 100644 --- a/spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensionsTests.kt +++ b/spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ReactiveUpdateOperationExtensionsTests.kt @@ -22,6 +22,7 @@ import io.mockk.mockk import io.mockk.verify import kotlinx.coroutines.runBlocking import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.Test import reactor.core.publisher.Mono @@ -50,7 +51,7 @@ class ReactiveUpdateOperationExtensionsTests { } @Test // DATAMONGO-2209 - fun findModifyAndAwait() { + fun findModifyAndAwaitWithValue() { val find = mockk>() every { find.findAndModify() } returns Mono.just("foo") @@ -65,7 +66,52 @@ class ReactiveUpdateOperationExtensionsTests { } @Test // DATAMONGO-2209 - fun findReplaceAndAwait() { + fun findModifyAndAwaitWithNull() { + + val find = mockk>() + every { find.findAndModify() } returns Mono.empty() + + assertThatExceptionOfType(NoSuchElementException::class.java).isThrownBy { + runBlocking { find.findModifyAndAwait() } + } + + verify { + find.findAndModify() + } + } + + @Test // DATAMONGO-2209 + fun findModifyAndAwaitOrNullWithValue() { + + val find = mockk>() + every { find.findAndModify() } returns Mono.just("foo") + + runBlocking { + assertThat(find.findModifyAndAwaitOrNull()).isEqualTo("foo") + } + + verify { + find.findAndModify() + } + } + + @Test // DATAMONGO-2209 + fun findModifyAndAwaitOrNullWithNull() { + + val find = mockk>() + every { find.findAndModify() } returns Mono.empty() + + runBlocking { + assertThat(find.findModifyAndAwaitOrNull()).isNull() + } + + verify { + find.findAndModify() + } + } + + @Test // DATAMONGO-2209 + fun findReplaceAndAwaitWithValue() { val find = mockk>() every { find.findAndReplace() } returns Mono.just("foo") @@ -79,6 +125,51 @@ class ReactiveUpdateOperationExtensionsTests { } } + @Test // DATAMONGO-2209 + fun findReplaceAndAwaitWithNull() { + + val find = mockk>() + every { find.findAndReplace() } returns Mono.empty() + + assertThatExceptionOfType(NoSuchElementException::class.java).isThrownBy { + runBlocking { find.findReplaceAndAwait() } + } + + verify { + find.findAndReplace() + } + } + + @Test // DATAMONGO-2209 + fun findReplaceAndAwaitOrNullWithValue() { + + val find = mockk>() + every { find.findAndReplace() } returns Mono.just("foo") + + runBlocking { + assertThat(find.findReplaceAndAwaitOrNull()).isEqualTo("foo") + } + + verify { + find.findAndReplace() + } + } + + @Test // DATAMONGO-2209 + fun findReplaceAndAwaitOrNullWithNull() { + + val find = mockk>() + every { find.findAndReplace() } returns Mono.empty() + + runBlocking { + assertThat(find.findReplaceAndAwaitOrNull()).isNull() + } + + verify { + find.findAndReplace() + } + } + @Test // DATAMONGO-2209 fun allAndAwait() {