#290 - Add Kotlin extensions for fluent R2dbcEntityTemplate API.

src/main/kotlin/org/springframework/data/r2dbc/core/ReactiveDeleteOperationExtensions.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2018-2020 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.data.r2dbc.core
+
+import kotlinx.coroutines.reactive.awaitSingle
+
+/**
+ * Extensions for [ReactiveDeleteOperation].
+ *
+ * @author Mark Paluch
+ * @since 1.1
+ */
+
+/**
+ * Extension for [ReactiveDeleteOperation.delete] leveraging reified type parameters.
+ */
+inline fun <reified T : Any> ReactiveDeleteOperation.delete(): ReactiveDeleteOperation.ReactiveDelete =
+		delete(T::class.java)
+
+/**
+ * Coroutines variant of [ReactiveDeleteOperation.TerminatingDelete.all].
+ */
+suspend fun ReactiveDeleteOperation.TerminatingDelete.allAndAwait(): Int =
+		all().awaitSingle()

src/main/kotlin/org/springframework/data/r2dbc/core/ReactiveInsertOperationExtensions.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020 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.data.r2dbc.core
+
+import kotlinx.coroutines.reactive.awaitSingle
+
+/**
+ * Extensions for [ReactiveInsertOperation].
+ *
+ * @author Mark Paluch
+ * @since 1.1
+ */
+
+/**
+ * Extension for [ReactiveInsertOperation.insert] leveraging reified type parameters.
+ */
+inline fun <reified T : Any> ReactiveInsertOperation.insert(): ReactiveInsertOperation.ReactiveInsert<T> =
+		insert(T::class.java)
+
+/**
+ * Coroutines variant of [ReactiveInsertOperation.TerminatingInsert.using].
+ */
+suspend inline fun <reified T : Any> ReactiveInsertOperation.TerminatingInsert<T>.usingAndAwait(o: T): T =
+		using(o).awaitSingle()

src/main/kotlin/org/springframework/data/r2dbc/core/ReactiveSelectOperationExtensions.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2020 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.data.r2dbc.core
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.reactive.asFlow
+import kotlinx.coroutines.reactive.awaitFirstOrNull
+import kotlinx.coroutines.reactive.awaitSingle
+
+/**
+ * Extensions for [ReactiveSelectOperation].
+ *
+ * @author Mark Paluch
+ * @since 1.1
+ */
+
+/**
+ * Extension for [ReactiveSelectOperation.select] leveraging reified type parameters.
+ */
+inline fun <reified T : Any> ReactiveSelectOperation.select(): ReactiveSelectOperation.ReactiveSelect<T> =
+		select(T::class.java)
+
+/**
+ * Extension for [ReactiveSelectOperation.SelectWithProjection. as] leveraging reified type parameters.
+ */
+inline fun <reified T : Any> ReactiveSelectOperation.SelectWithProjection<*>.asType(): ReactiveSelectOperation.SelectWithQuery<T> =
+		`as`(T::class.java)
+
+/**
+ * Non-nullable Coroutines variant of [ReactiveSelectOperation.TerminatingSelect.one].
+ */
+suspend inline fun <reified T : Any> ReactiveSelectOperation.TerminatingSelect<T>.awaitOne(): T =
+		one().awaitSingle()
+
+/**
+ * Nullable Coroutines variant of [ReactiveSelectOperation.TerminatingSelect.one].
+ */
+suspend inline fun <reified T : Any> ReactiveSelectOperation.TerminatingSelect<T>.awaitOneOrNull(): T? =
+		one().awaitFirstOrNull()
+
+/**
+ * Non-nullable Coroutines variant of [ReactiveSelectOperation.TerminatingSelect.first].
+ */
+suspend inline fun <reified T : Any> ReactiveSelectOperation.TerminatingSelect<T>.awaitFirst(): T =
+		first().awaitSingle()
+
+/**
+ * Nullable Coroutines variant of [ReactiveSelectOperation.TerminatingSelect.first].
+ */
+suspend inline fun <reified T : Any> ReactiveSelectOperation.TerminatingSelect<T>.awaitFirstOrNull(): T? =
+		first().awaitFirstOrNull()
+
+/**
+ * Coroutines variant of [ReactiveSelectOperation.TerminatingSelect.count].
+ */
+suspend fun <T : Any> ReactiveSelectOperation.TerminatingSelect<T>.awaitCount(): Long =
+		count().awaitSingle()
+
+/**
+ * Coroutines variant of [ReactiveSelectOperation.TerminatingSelect.exists].
+ */
+suspend fun <T : Any> ReactiveSelectOperation.TerminatingSelect<T>.awaitExists(): Boolean =
+		exists().awaitSingle()
+
+/**
+ * Coroutines [Flow] variant of [ReactiveSelectOperation.TerminatingSelect.all].
+ */
+fun <T : Any> ReactiveSelectOperation.TerminatingSelect<T>.flow(): Flow<T> =
+		all().asFlow()

src/main/kotlin/org/springframework/data/r2dbc/core/ReactiveUpdateOperationExtensions.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020 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.data.r2dbc.core
+
+import kotlinx.coroutines.reactive.awaitSingle
+import org.springframework.data.r2dbc.query.Update
+
+/**
+ * Extensions for [ReactiveUpdateOperation].
+ *
+ * @author Mark Paluch
+ * @since 1.1
+ */
+
+/**
+ * Extension for [ReactiveUpdateOperation.update] leveraging reified type parameters.
+ */
+inline fun <reified T : Any> ReactiveUpdateOperation.update(): ReactiveUpdateOperation.ReactiveUpdate =
+		update(T::class.java)
+
+/**
+ * Coroutines variant of [ReactiveUpdateOperation.TerminatingUpdate.apply].
+ */
+suspend fun ReactiveUpdateOperation.TerminatingUpdate.applyAndAwait(update: Update): Int = apply(update).awaitSingle()

src/test/kotlin/org/springframework/data/r2dbc/core/Person.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2020 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.data.r2dbc.core
+
+data class Person(val id: String)

src/test/kotlin/org/springframework/data/r2dbc/core/ReactiveDeleteOperationExtensionsUnitTests.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020 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.data.r2dbc.core
+
+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.Test
+import reactor.core.publisher.Mono
+
+/**
+ * Unit tests for [ReactiveDeleteOperationExtensions].
+ *
+ * @author Mark Paluch
+ */
+class ReactiveDeleteOperationExtensionsUnitTests {
+
+	val operations = mockk<FluentR2dbcOperations>(relaxed = true)
+
+	@Test // gh-290
+	fun `delete() with reified type parameter extension should call its Java counterpart`() {
+
+		operations.delete<Person>()
+		verify { operations.delete(Person::class.java) }
+	}
+
+	@Test // gh-290
+	fun allAndAwait() {
+
+		val delete = mockk<ReactiveDeleteOperation.TerminatingDelete>()
+		every { delete.all() } returns Mono.just(42)
+
+		runBlocking {
+			assertThat(delete.allAndAwait()).isEqualTo(42)
+		}
+
+		verify {
+			delete.all()
+		}
+	}
+}

src/test/kotlin/org/springframework/data/r2dbc/core/ReactiveInsertOperationExtensionsUnitTests.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020 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.data.r2dbc.core
+
+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.Test
+import reactor.core.publisher.Mono
+
+/**
+ * Unit tests for [ReactiveInsertOperationExtensions].
+ *
+ * @author Mark Paluch
+ */
+class ReactiveInsertOperationExtensionsUnitTests {
+
+	val operations = mockk<FluentR2dbcOperations>(relaxed = true)
+
+	@Test // gh-290
+	fun `insert() with reified type parameter extension should call its Java counterpart`() {
+
+		operations.insert<Person>()
+		verify { operations.insert(Person::class.java) }
+	}
+
+	@Test // gh-290
+	fun oneAndAwait() {
+
+		val insert = mockk<ReactiveInsertOperation.TerminatingInsert<String>>()
+		every { insert.using("foo") } returns Mono.just("bar")
+
+		runBlocking {
+			assertThat(insert.usingAndAwait("foo")).isEqualTo("bar")
+		}
+
+		verify {
+			insert.using("foo")
+		}
+	}
+}

src/test/kotlin/org/springframework/data/r2dbc/core/ReactiveSelectOperationExtensionsUnitTests.kt

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2020 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.data.r2dbc.core
+
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import kotlinx.coroutines.flow.toList
+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.Flux
+import reactor.core.publisher.Mono
+
+/**
+ * Unit tests for [ReactiveSelectOperationExtensions].
+ *
+ * @author Mark Paluch
+ */
+class ReactiveSelectOperationExtensionsUnitTests {
+
+	val operations = mockk<FluentR2dbcOperations>(relaxed = true)
+
+	val operationWithProjection = mockk<ReactiveSelectOperation.SelectWithProjection<Person>>(relaxed = true)
+
+	@Test // gh-290
+	fun `query() with reified type parameter extension should call its Java counterpart`() {
+
+		operations.select<Person>()
+		verify { operations.select(Person::class.java) }
+	}
+
+	@Test // gh-290
+	fun `asType() with reified type parameter extension should call its Java counterpart`() {
+
+		operationWithProjection.asType<User>();
+		verify { operationWithProjection.`as`(User::class.java) }
+	}
+
+	@Test // gh-290
+	fun terminatingFindAwaitOneWithValue() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.one() } returns Mono.just("foo")
+
+		runBlocking {
+			assertThat(find.awaitOne()).isEqualTo("foo")
+		}
+
+		verify {
+			find.one()
+		}
+	}
+
+	@Test // gh-290
+	fun terminatingFindAwaitOneWithNull() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.one() } returns Mono.empty()
+
+		assertThatExceptionOfType(NoSuchElementException::class.java).isThrownBy {
+			runBlocking { find.awaitOne() }
+		}
+
+		verify {
+			find.one()
+		}
+	}
+
+	@Test // gh-290gh-290
+	fun terminatingFindAwaitOneOrNullWithValue() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.one() } returns Mono.just("foo")
+
+		runBlocking {
+			assertThat(find.awaitOneOrNull()).isEqualTo("foo")
+		}
+
+		verify {
+			find.one()
+		}
+	}
+
+	@Test // gh-290gh-290
+	fun terminatingFindAwaitOneOrNullWithNull() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.one() } returns Mono.empty()
+
+		runBlocking {
+			assertThat(find.awaitOneOrNull()).isNull()
+		}
+
+		verify {
+			find.one()
+		}
+	}
+
+	@Test // DATACASS-632
+	fun terminatingFindAwaitFirstWithValue() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.first() } returns Mono.just("foo")
+
+		runBlocking {
+			assertThat(find.awaitFirst()).isEqualTo("foo")
+		}
+
+		verify {
+			find.first()
+		}
+	}
+
+	@Test // gh-290gh-290
+	fun terminatingFindAwaitFirstWithNull() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.first() } returns Mono.empty()
+
+		assertThatExceptionOfType(NoSuchElementException::class.java).isThrownBy {
+			runBlocking { find.awaitFirst() }
+		}
+
+		verify {
+			find.first()
+		}
+	}
+
+	@Test // gh-290gh-290
+	fun terminatingFindAwaitFirstOrNullWithValue() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.first() } returns Mono.just("foo")
+
+		runBlocking {
+			assertThat(find.awaitFirstOrNull()).isEqualTo("foo")
+		}
+
+		verify {
+			find.first()
+		}
+	}
+
+	@Test // gh-290gh-290
+	fun terminatingFindAwaitFirstOrNullWithNull() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.first() } returns Mono.empty()
+
+		runBlocking {
+			assertThat(find.awaitFirstOrNull()).isNull()
+		}
+
+		verify {
+			find.first()
+		}
+	}
+
+	@Test // DATACASS-632
+	fun terminatingFindAwaitCount() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.count() } returns Mono.just(1)
+
+		runBlocking {
+			assertThat(find.awaitCount()).isEqualTo(1)
+		}
+
+		verify {
+			find.count()
+		}
+	}
+
+	@Test // DATACASS-632
+	fun terminatingFindAwaitExists() {
+
+		val find = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { find.exists() } returns Mono.just(true)
+
+		runBlocking {
+			assertThat(find.awaitExists()).isTrue()
+		}
+
+		verify {
+			find.exists()
+		}
+	}
+
+	@Test // DATACASS-648
+	fun terminatingFindAllAsFlow() {
+
+		val spec = mockk<ReactiveSelectOperation.TerminatingSelect<String>>()
+		every { spec.all() } returns Flux.just("foo", "bar", "baz")
+
+		runBlocking {
+			assertThat(spec.flow().toList()).contains("foo", "bar", "baz")
+		}
+
+		verify {
+			spec.all()
+		}
+	}
+
+	data class User(val id: String)
+}

src/test/kotlin/org/springframework/data/r2dbc/core/ReactiveUpdateOperationExtensionsUnitTests.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020 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.data.r2dbc.core
+
+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.Test
+import org.springframework.data.r2dbc.query.Update
+import reactor.core.publisher.Mono
+
+/**
+ * Unit tests for [ReactiveUpdateOperationExtensions].
+ *
+ * @author Mark Paluch
+ */
+class ReactiveUpdateOperationExtensionsUnitTests {
+
+	val operations = mockk<FluentR2dbcOperations>(relaxed = true)
+
+	@Test// gh-290
+	fun `update() with reified type parameter extension should call its Java counterpart`() {
+
+		operations.update<Person>()
+		verify { operations.update(Person::class.java) }
+	}
+
+	@Test // gh-290
+	fun applyAndAwait() {
+
+		val update = mockk<ReactiveUpdateOperation.TerminatingUpdate>()
+		val updateObj = mockk<Update>();
+		every { update.apply(updateObj) } returns Mono.just(42)
+
+		runBlocking {
+			assertThat(update.applyAndAwait(updateObj)).isEqualTo(42)
+		}
+
+		verify {
+			update.apply(updateObj)
+		}
+	}
+}