Move httpResponseSubscriber invocation to after handling response

Author: adamint

src/commonMain/kotlin/com.adamratzman.spotify/http/Endpoints.kt

@@ -12,11 +12,7 @@ import com.adamratzman.spotify.models.serialization.toObject
 import com.adamratzman.spotify.utils.ConcurrentHashMap
 import com.adamratzman.spotify.utils.getCurrentTimeMs
 import io.ktor.http.HttpStatusCode
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.*
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
 import kotlin.math.ceil
@@ -129,20 +125,29 @@ public abstract class SpotifyEndpoint(public val api: GenericSpotifyApi) {
         try {
             return withTimeout(api.spotifyApiOptions.requestTimeoutMillis ?: (100 * 1000L)) {
                 try {
-                    val document = createConnection(url, body, method, contentType).execute(
+                    val httpRequest = createConnection(url, body, method, contentType)
+                    val document = httpRequest.execute(
                         additionalHeaders = cacheState?.eTag?.let {
                             listOf(HttpHeader("If-None-Match", it))
                         },
                         retryIfInternalServerErrorLeft = api.spotifyApiOptions.retryOnInternalServerErrorTimes
                     )
 
-                    handleResponse(document, cacheState, spotifyRequest, retry202) ?: run {
+                    val response = handleResponse(document, cacheState, spotifyRequest, retry202) ?: run {
                         if (retryOnNull) {
                             execute<ReturnType>(url, body, method, false, contentType, retryOnNull)
                         } else {
                             null
                         }
                     }
+
+                    api.spotifyApiOptions.httpResponseSubscriber?.let { subscriber ->
+                        launch(currentCoroutineContext()) {
+                            subscriber(httpRequest, document)
+                        }
+                    }
+
+                    response
                 } catch (e: BadRequestException) {
                     if (e.statusCode == 401 && !attemptedRefresh) {
                         api.refreshToken()

src/commonMain/kotlin/com.adamratzman.spotify/http/HttpRequest.kt

@@ -165,12 +165,6 @@ public class HttpRequest constructor(
                     }
                 )
 
-                api?.spotifyApiOptions?.httpResponseSubscriber?.let { subscriber ->
-                    launch(currentCoroutineContext()) {
-                        subscriber(this, httpResponseToReturn)
-                    }
-                }
-
                 return httpResponseToReturn
             }
         } catch (e: CancellationException) {

src/commonTest/kotlin/com.adamratzman/spotify/utilities/UtilityTests.kt

@@ -3,24 +3,11 @@
 
 package com.adamratzman.spotify.utilities
 
-import com.adamratzman.spotify.GenericSpotifyApi
-import com.adamratzman.spotify.SpotifyClientApi
-import com.adamratzman.spotify.SpotifyScope
-import com.adamratzman.spotify.SpotifyUserAuthorization
-import com.adamratzman.spotify.buildSpotifyApi
-import com.adamratzman.spotify.getSpotifyPkceCodeChallenge
-import com.adamratzman.spotify.getTestClientId
-import com.adamratzman.spotify.getTestClientSecret
-import com.adamratzman.spotify.runTestOnDefaultDispatcher
-import com.adamratzman.spotify.spotifyAppApi
-import com.adamratzman.spotify.spotifyClientApi
-import io.ktor.util.PlatformUtils
+import com.adamratzman.spotify.*
+import io.ktor.util.*
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.TestResult
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-import kotlin.test.assertTrue
+import kotlin.test.*
 
 class UtilityTests {
     var api: GenericSpotifyApi? = null
@@ -140,4 +127,20 @@ class UtilityTests {
             ) { requiredScopes = listOf(SpotifyScope.PlaylistReadPrivate) }.build()
         }
     }
+
+    @Test
+    fun testResponseSubscriber(): TestResult = runTestOnDefaultDispatcher {
+        buildSpotifyApi(this::class.simpleName!!, ::testPagingObjectGetAllItems.name)?.let { api = it }
+        val options = api!!.spotifyApiOptions
+        val oldSubscriber = options.httpResponseSubscriber
+        options.httpResponseSubscriber = { request, response ->
+            assertNotNull(
+                api!!.getCache().entries.singleOrNull { it.key.url == request.url }
+            )
+            oldSubscriber?.invoke(request, response)
+        }
+        
+        api!!.tracks.getTrack("6DrcMKnfMByc3RhhIvEw0F")
+        options.httpResponseSubscriber = oldSubscriber
+    }
 }