Merge pull request #8 from hangga/rxjava-to-coroutines-rev0

Rxjava to coroutines rev0

Author: hangga

core-kotlin-modules/core-kotlin-concurrency-3/src/test/java/com/baeldung/singlerxjavatocoroutinedeferred/SingleRxJavaToCoroutineDeferredUnitTest.kt

@@ -6,8 +6,6 @@ import kotlinx.coroutines.*
 import kotlinx.coroutines.rx3.await
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
-import org.slf4j.LoggerFactory
-import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 import kotlin.coroutines.suspendCoroutine
@@ -16,8 +14,6 @@ import kotlin.test.assertTrue
 
 class SingleRxJavaToCoroutineDeferredUnitTest {
 
-    private val logger = LoggerFactory.getLogger("")
-
     data class Product(val id: Int, val name: String, val price: Double)
 
     private val allProducts = listOf(
@@ -47,35 +43,14 @@ class SingleRxJavaToCoroutineDeferredUnitTest {
     }
 
     @Test
-    fun `using async direcly and blockingGet`() = runBlocking {
-        val deferred = async { getFilteredProducts().blockingGet() } // simple, but must be careful because blocking main thread
+    fun `using async and blockingGet`() = runBlocking {
+        val deferred =
+            async { getFilteredProducts().blockingGet() } // potentially blocking main thread while not careful
         deferred.assertOver500AndSorted() // assertion test
     }
 
-    // using async with extension
-    private suspend fun <T : Any> Single<T>.toDeferredAsync(): Deferred<T> =
-        coroutineScope { async { this@toDeferredAsync.blockingGet() } }
-
-
-    @Test
-    fun `test using async with extension`() = runBlocking {
-        val deferredExt = getFilteredProducts().toDeferredAsync()
-        deferredExt.assertOver500AndSorted()
-    }
-
-    // using CoroutineScope(context).async
-    private fun <T : Any> Single<T>.toDeferredWithContext(context: CoroutineContext): Deferred<T> =
-        CoroutineScope(context).async { this@toDeferredWithContext.blockingGet() }
-
-    @Test
-    fun `test using CoroutineScope with context and async`(): Unit = runBlocking {
-        val deferred = getFilteredProducts().toDeferredWithContext(Dispatchers.IO)
-        deferred.assertOver500AndSorted()
-    }
-
-    // using CompletableDeferred & subscribe
     @Test
-    fun `using CompletableDeferred and subscribe`() = runBlocking {
+    fun `using subscribe and CompletableDeferred`() = runBlocking {
         val deferred = CompletableDeferred<List<Product>>()
         getFilteredProducts().subscribe({ products ->
             deferred.complete(products)
@@ -85,129 +60,35 @@ class SingleRxJavaToCoroutineDeferredUnitTest {
         deferred.assertOver500AndSorted()
     }
 
-    // using CompletableDeferred extension
-    private fun <T : Any> Single<T>.toCompletableDeferred(): CompletableDeferred<T> {
-        val completableDeferred = CompletableDeferred<T>()
-        this.subscribe({ completableDeferred.complete(it) }, { completableDeferred.completeExceptionally(it) })
-        return completableDeferred
-    }
-
-    // using CompletableDeferred with custom callback
-    private fun <T : Any> Single<T>.toCompletableDeferred(
-        onSuccess: (CompletableDeferred<T>, T) -> Unit, onError: (CompletableDeferred<T>, Throwable) -> Unit
-    ): CompletableDeferred<T> {
-        val completableDeferred = CompletableDeferred<T>()
-        this.subscribe({ result ->
-            completableDeferred.complete(result)
-            onSuccess(completableDeferred, result)
-        }, { error ->
-            completableDeferred.completeExceptionally(error)
-            onError(completableDeferred, error)
-        })
-        return completableDeferred
-    }
-
-    @Test
-    fun `test using CompletableDeferred extension`() = runBlocking {
-        val deferred = getFilteredProducts().toCompletableDeferred()
-        deferred.assertOver500AndSorted()
-    }
-
-    @Test
-    fun `test using CompletableDeferred with callback`(): Unit = runBlocking {
-        getFilteredProducts().toCompletableDeferred(onSuccess = { deferredResult, _ ->
-            launch { deferredResult.assertOver500AndSorted() }
-        }, onError = { _, error ->
-            logger.debug("Error: ${error.message}")
-        }).await()
-    }
-
-    // using suspendCoroutines directly
     @Test
-    fun `using suspendCoroutines directly`(): Unit = runBlocking {
-        val defered = async {
+    fun `using suspendCoroutines`(): Unit = runBlocking {
+        val deferred = async {
             suspendCoroutine { continuation ->
                 getFilteredProducts().subscribe { result ->
                     continuation.resume(result)
                 }
             }
         }
-        defered.assertOver500AndSorted()
-    }
-
-    // using suspendCoroutines with extension
-    private suspend fun <T : Any> Single<T>.toDeferredWithSuspend(): Deferred<T> {
-        return coroutineScope {
-            async {
-                suspendCoroutine { continuation ->
-                    this@toDeferredWithSuspend.subscribe { result ->
-                        continuation.resume(result)
-                    }
-                }
-            }
-        }
-    }
-
-    @Test
-    fun `test using suspendCoroutine extension`() = runBlocking {
-        val deferred = getFilteredProducts().toDeferredWithSuspend()
         deferred.assertOver500AndSorted()
     }
 
-    // using suspendCancellableCoroutine
-    private suspend fun <T : Any> Single<T>.toDeferredWithSuspendCancellableCoroutine(
-        onSuccess: (Deferred<T>) -> Unit, onError: (Throwable) -> Unit
-    ): Deferred<T> {
-        return coroutineScope {
-            async {
-                suspendCancellableCoroutine { continuation ->
-                    this@toDeferredWithSuspendCancellableCoroutine.subscribe({ result ->
-                        val deferredResult = CompletableDeferred<T>().apply {
-                            complete(result)
-                            continuation.resume(result)
-                        }
-                        onSuccess(deferredResult)
-                    }, { error ->
-                        continuation.resumeWithException(error)
-                        onError(error)
-                    })
-                }
+    @Test
+    fun `using suspendCancellableCoroutine`(): Unit = runBlocking {
+        val deferred = async {
+            suspendCancellableCoroutine { continuation ->
+                getFilteredProducts().subscribe({ result ->
+                    continuation.resume(result)
+                }, { error ->
+                    continuation.resumeWithException(error)
+                })
             }
         }
-    }
-    @Test
-    fun `test using suspendCancellableCoroutine with custom callback`(): Unit = runBlocking {
-        getFilteredProducts().toDeferredWithSuspendCancellableCoroutine(onSuccess = { deferredResult ->
-            launch { deferredResult.assertOver500AndSorted() }
-        }, onError = { error ->
-            logger.debug("Error: ${error.message}")
-        }).await()
-    }
-
-    // using rx3 directly
-    @Test
-    fun `using rx3 directly`() = runBlocking {
-        val deferred = async { getFilteredProducts().await() }
-        deferred.assertOver500AndSorted()
-    }
-
-    // using rx3 ext
-    private suspend fun <T : Any> Single<T>.toDeferredRx3(): Deferred<T> =
-        coroutineScope { async { this@toDeferredRx3.await() } }
-
-    @Test
-    fun `test using rx3 ext`() = runBlocking {
-        val deferred = getFilteredProducts().toDeferredRx3()
         deferred.assertOver500AndSorted()
     }
 
-    // using rx3 with context
-    private fun <T : Any> Single<T>.toDeferredRx3WithContext(context: CoroutineContext): Deferred<T> =
-        CoroutineScope(context).async { this@toDeferredRx3WithContext.await() }
-
     @Test
-    fun `test using rx3 with context`(): Unit = runBlocking {
-        val deferred = getFilteredProducts().toDeferredRx3WithContext(Dispatchers.IO)
+    fun `using Kotlin Coroutines Rx3`() = runBlocking {
+        val deferred = async { getFilteredProducts().await() }
         deferred.assertOver500AndSorted()
     }