feat: Add tests for suspending functions support

Author: haroldadmin

src/test/kotlin/com/haroldadmin/cnradapter/CancelTest.kt

@@ -11,7 +11,7 @@ import java.io.IOException
 internal class CancelTest : DescribeSpec({
 
     val mockWebServer = MockWebServer()
-    val factory = CoroutinesNetworkResponseAdapterFactory()
+    val factory = NetworkResponseAdapterFactory()
     val retrofit = Retrofit.Builder()
             .baseUrl(mockWebServer.url("/"))
             .addConverterFactory(StringConverterFactory())

src/test/kotlin/com/haroldadmin/cnradapter/DeferredTest.kt

@@ -25,7 +25,7 @@ internal class DeferredTest : DescribeSpec() {
         retrofit = Retrofit.Builder()
                 .baseUrl(server.url("/"))
                 .addConverterFactory(StringConverterFactory())
-                .addCallAdapterFactory(CoroutinesNetworkResponseAdapterFactory())
+                .addCallAdapterFactory(NetworkResponseAdapterFactory())
                 .callbackExecutor(executor)
                 .build()
         service = retrofit.create(Service::class.java)
@@ -94,7 +94,7 @@ internal class DeferredTest : DescribeSpec() {
             }
 
             context("IO error") {
-                server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST))
+                server.enqueue(MockResponse().apply { socketPolicy = SocketPolicy.DISCONNECT_AFTER_REQUEST })
 
                 it("Should be treated as NetworkResponse.NetworkError") {
                     val response = service.getText().await()

src/test/kotlin/com/haroldadmin/cnradapter/ErrorExtractionTest.kt

@@ -0,0 +1,56 @@
+package com.haroldadmin.cnradapter
+
+import io.kotlintest.matchers.types.shouldBeSameInstanceAs
+import io.kotlintest.matchers.types.shouldBeTypeOf
+import io.kotlintest.shouldBe
+import okhttp3.Headers
+import okhttp3.ResponseBody
+import retrofit2.HttpException
+import retrofit2.Response
+import okhttp3.ResponseBody.Companion.toResponseBody
+import org.junit.Test
+import retrofit2.Converter
+import retrofit2.http.Header
+import java.io.IOException
+import java.lang.Exception
+
+internal class ErrorExtractionTest {
+
+    private val errorConverter = Converter<ResponseBody, String> { responseBody -> responseBody.toString() }
+
+    @Test
+    fun `extract error from HttpException test`() {
+        val serverResponse = "Server Error".toResponseBody()
+        val response = Response.error<String>(404, serverResponse)
+        val exception = HttpException(response)
+        with(exception.extractFromHttpException<String, String>(errorConverter)) {
+
+            shouldBeTypeOf<NetworkResponse.ServerError<String>>()
+            this as NetworkResponse.ServerError
+
+            body shouldBe errorConverter.convert(serverResponse)
+            code shouldBe 404
+            headers shouldBe Headers.headersOf()
+        }
+    }
+
+    @Test
+    fun `extract error from IOException test`() {
+        val ioException = IOException()
+        with(ioException.extractNetworkResponse<String, String>(errorConverter)) {
+
+            shouldBeTypeOf<NetworkResponse.NetworkError>()
+            this as NetworkResponse.NetworkError
+
+            error shouldBeSameInstanceAs ioException
+        }
+    }
+
+    private class CustomException: Exception()
+
+    @Test(expected = CustomException::class)
+    fun `extract error from an unknown exception test`() {
+        val exception = CustomException()
+        exception.extractNetworkResponse<String, String>(errorConverter)
+    }
+}

src/test/kotlin/com/haroldadmin/cnradapter/FactoryTest.kt

@@ -5,21 +5,22 @@ import io.kotlintest.shouldBe
 import io.kotlintest.specs.DescribeSpec
 import kotlinx.coroutines.Deferred
 import okhttp3.mockwebserver.MockWebServer
+import retrofit2.Call
 import retrofit2.Retrofit
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 
 internal class FactoryTest : DescribeSpec() {
 
     private lateinit var mockWebServer: MockWebServer
-    private lateinit var callAdapterFactory: CoroutinesNetworkResponseAdapterFactory
+    private lateinit var callAdapterFactory: NetworkResponseAdapterFactory
     private lateinit var retrofit: Retrofit
     private lateinit var executor: ExecutorService
 
     override fun beforeSpec(spec: Spec) {
         super.beforeSpec(spec)
         mockWebServer = MockWebServer()
-        callAdapterFactory = CoroutinesNetworkResponseAdapterFactory()
+        callAdapterFactory = NetworkResponseAdapterFactory()
         executor = Executors.newSingleThreadExecutor()
         retrofit = Retrofit.Builder()
                 .baseUrl(mockWebServer.url("/"))
@@ -45,12 +46,18 @@ internal class FactoryTest : DescribeSpec() {
                     callAdapterFactory.get(bodyClass, emptyArray(), retrofit) shouldBe null
                 }
             }
-            context("Request type if Deferred<NetworkResponse>") {
+            context("Request type is Deferred<NetworkResponse>") {
                 val bodyClass = typeOf<Deferred<NetworkResponse<String, String>>>()
                 it("Should return correct type") {
                     callAdapterFactory.get(bodyClass, emptyArray(), retrofit)!!.responseType() shouldBe String::class.java
                 }
             }
+            context("Request type is NetworkResponse") {
+                val bodyClass = typeOf<Call<NetworkResponse<String, String>>>()
+                it("should return the correct type") {
+                    callAdapterFactory.get(bodyClass, emptyArray(), retrofit)!!.responseType() shouldBe String::class.java
+                }
+            }
         }
     }
 }

src/test/kotlin/com/haroldadmin/cnradapter/NetworkResponseCallTest.kt

@@ -0,0 +1,107 @@
+package com.haroldadmin.cnradapter
+
+import com.haroldadmin.cnradapter.CompletableCall
+import com.haroldadmin.cnradapter.NetworkResponse
+import com.haroldadmin.cnradapter.NetworkResponseCall
+import io.kotlintest.matchers.types.shouldBeTypeOf
+import io.kotlintest.matchers.types.shouldNotBeSameInstanceAs
+import io.kotlintest.shouldBe
+import okhttp3.ResponseBody
+import okhttp3.ResponseBody.Companion.toResponseBody
+import org.junit.Test
+import retrofit2.*
+import java.io.IOException
+
+internal class NetworkResponseCallTest {
+    private val errorConverter = Converter<ResponseBody, String> { it.toString() }
+    private val backingCall = CompletableCall<String>()
+    private val networkResponseCall = NetworkResponseCall<String, String>(backingCall, errorConverter)
+
+    @Test(expected = UnsupportedOperationException::class)
+    fun `should throw an error when invoking 'execute'`() {
+        networkResponseCall.execute()
+    }
+
+    @Test
+    fun `should delegate properties to backing call`() {
+        with (networkResponseCall) {
+            isExecuted shouldBe backingCall.isExecuted
+            isCanceled shouldBe backingCall.isCanceled
+            request() shouldBe backingCall.request()
+        }
+    }
+
+    @Test
+    fun `should return new instance when cloned`() {
+        val clonedCall = networkResponseCall.clone()
+        clonedCall shouldNotBeSameInstanceAs networkResponseCall
+    }
+
+    @Test
+    fun `should cancel backing call as well when canceled`() {
+        networkResponseCall.cancel()
+        assert(backingCall.isCanceled)
+    }
+
+    @Test
+    fun `should parse successful call as NetworkResponse Success`() {
+        val body = "Test body"
+        networkResponseCall.enqueue(object : Callback<NetworkResponse<String, String>> {
+            override fun onResponse(call: Call<NetworkResponse<String, String>>, response: Response<NetworkResponse<String, String>>) {
+                assert(response.isSuccessful)
+                response.body().shouldBeTypeOf<NetworkResponse.Success<String>>()
+                (response.body()!! as NetworkResponse.Success).body shouldBe body
+            }
+
+            override fun onFailure(call: Call<NetworkResponse<String, String>>, t: Throwable) {
+                throw IllegalStateException()
+            }
+        })
+        backingCall.complete(body)
+    }
+
+    @Test
+    fun `should parse unsuccessful call with HttpException as NetworkResponse ServerError`() {
+        networkResponseCall.enqueue(object : Callback<NetworkResponse<String, String>> {
+            override fun onResponse(call: Call<NetworkResponse<String, String>>, response: Response<NetworkResponse<String, String>>) {
+                response.body().shouldBeTypeOf<NetworkResponse.ServerError<String>>()
+            }
+
+            override fun onFailure(call: Call<NetworkResponse<String, String>>, t: Throwable) {
+                throw IllegalStateException()
+            }
+        })
+
+        backingCall.completeWithException(HttpException(Response.error<String>(404, "Server Error".toResponseBody())))
+    }
+
+    @Test
+    fun `should parse unsuccessful call with IOException as NetworkResponse NetworkError`() {
+        networkResponseCall.enqueue(object: Callback<NetworkResponse<String, String>> {
+            override fun onFailure(call: Call<NetworkResponse<String, String>>, t: Throwable) {
+                throw IllegalStateException()
+            }
+
+            override fun onResponse(call: Call<NetworkResponse<String, String>>, response: Response<NetworkResponse<String, String>>) {
+                response.body().shouldBeTypeOf<NetworkResponse.NetworkError>()
+            }
+        })
+
+        backingCall.completeWithException(IOException())
+    }
+
+    @Test
+    fun `should parse successful call with empty body as NetworkResponse ServerError`() {
+        networkResponseCall.enqueue(object : Callback<NetworkResponse<String, String>> {
+            override fun onFailure(call: Call<NetworkResponse<String, String>>, t: Throwable) {
+                throw IllegalStateException()
+            }
+
+            override fun onResponse(call: Call<NetworkResponse<String, String>>, response: Response<NetworkResponse<String, String>>) {
+                response.body().shouldBeTypeOf<NetworkResponse.ServerError<String>>()
+            }
+        })
+
+        backingCall.complete(Response.error(404, "".toResponseBody()))
+    }
+}

src/test/kotlin/com/haroldadmin/cnradapter/RetryTest.kt

@@ -25,7 +25,7 @@ class ExtensionsTest : DescribeSpec() {
         retrofit = Retrofit.Builder()
             .baseUrl(server.url("/"))
             .callbackExecutor(executor)
-            .addCallAdapterFactory(CoroutinesNetworkResponseAdapterFactory())
+            .addCallAdapterFactory(NetworkResponseAdapterFactory())
             .addConverterFactory(StringConverterFactory())
             .build()
         service = retrofit.create(Service::class.java)
@@ -41,7 +41,8 @@ class ExtensionsTest : DescribeSpec() {
         describe("Execute with retry") {
 
             repeat(9) {
-                server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST))
+                val mockResponse = MockResponse()
+                server.enqueue(mockResponse.apply { mockResponse.socketPolicy = SocketPolicy.DISCONNECT_AFTER_REQUEST })
             }
 
             server.enqueue(MockResponse().setBody("Hi!"))

src/test/kotlin/com/haroldadmin/cnradapter/Service.kt

@@ -6,4 +6,7 @@ import retrofit2.http.GET
 interface Service {
     @GET("/")
     fun getText(): Deferred<NetworkResponse<String, String>>
+
+    @GET("/suspend")
+    suspend fun getTextSuspend(): NetworkResponse<String, String>
 }

src/test/kotlin/com/haroldadmin/cnradapter/SuspendTest.kt

@@ -1,2 +1,91 @@
 package com.haroldadmin.cnradapter
 
+import io.kotlintest.matchers.types.shouldBeTypeOf
+import io.kotlintest.shouldBe
+import io.kotlintest.shouldNotBe
+import kotlinx.coroutines.runBlocking
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.SocketPolicy
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import retrofit2.Retrofit
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+class SuspendTest {
+
+    private lateinit var server: MockWebServer
+    private lateinit var executor: ExecutorService
+    private lateinit var retrofit: Retrofit
+    private lateinit var service: Service
+
+    @Before
+    fun setup() {
+        server = MockWebServer()
+        executor = Executors.newSingleThreadExecutor()
+        retrofit = Retrofit.Builder()
+                .baseUrl(server.url("/suspend/"))
+                .addConverterFactory(StringConverterFactory())
+                .addCallAdapterFactory(NetworkResponseAdapterFactory())
+                .callbackExecutor(executor)
+                .build()
+        service = retrofit.create(Service::class.java)
+    }
+
+    @Test
+    fun `successful response test`() {
+        val responseBody = "Hi!"
+        server.enqueue(
+                MockResponse()
+                        .setBody(responseBody)
+                        .setResponseCode(200)
+                        .setHeader("TEST","test")
+        )
+
+        val response = runBlocking {
+            service.getTextSuspend()
+        }
+
+        with(response) {
+            shouldBeTypeOf<NetworkResponse.Success<String>>()
+            this as NetworkResponse.Success
+            body shouldBe responseBody
+            headers shouldNotBe null
+            headers!!["TEST"] shouldBe "test"
+        }
+    }
+
+    @Test
+    fun `empty response test`() {
+        val responseCode = 404
+        server.enqueue(
+                MockResponse()
+                        .setResponseCode(responseCode)
+                        .setHeader("TEST", "test")
+        )
+        val response = runBlocking { service.getTextSuspend() }
+
+        with (response) {
+            shouldBeTypeOf<NetworkResponse.ServerError<String>>()
+            this as NetworkResponse.ServerError
+            code shouldBe responseCode
+            body shouldBe null
+            headers!!["TEST"] shouldBe "test"
+        }
+    }
+
+    @Test
+    fun `network error test`() {
+        server.enqueue(MockResponse().apply { socketPolicy = SocketPolicy.DISCONNECT_AFTER_REQUEST })
+        val response = runBlocking { service.getTextSuspend() }
+        response.shouldBeTypeOf<NetworkResponse.NetworkError>()
+    }
+
+    @After
+    fun cleanup() {
+        server.close()
+        executor.shutdown()
+    }
+}