bump spek, ktor, coroutine, international dependency versions

Author: adamint

build.gradle.kts

@@ -1,7 +1,5 @@
-
 import org.jetbrains.dokka.gradle.DokkaTask
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsCompile
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     `maven-publish`
@@ -35,10 +33,10 @@ kotlin {
 
     targets {
         sourceSets {
-            val coroutineVersion = "1.3.2"
+            val coroutineVersion = "1.3.3"
             val serializationVersion = "0.14.0"
-            val spekVersion = "2.0.8"
-            val ktorVersion = "1.2.6"
+            val spekVersion = "2.0.9"
+            val ktorVersion = "1.3.0-rc2"
 
             val commonMain by getting {
                 dependencies {
@@ -63,7 +61,6 @@ kotlin {
                 }
 
                 dependencies {
-                    implementation("com.neovisionaries:nv-i18n:1.26")
                     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutineVersion")
                     implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime:$serializationVersion")
                     implementation("io.ktor:ktor-client-apache:$ktorVersion")
@@ -75,7 +72,7 @@ kotlin {
                 dependencies {
                     implementation(kotlin("test"))
                     implementation(kotlin("test-junit"))
-                    implementation("org.junit.jupiter:junit-jupiter:5.5.2")
+                    implementation("org.junit.jupiter:junit-jupiter:5.6.0-M1")
                     implementation("org.spekframework.spek2:spek-dsl-jvm:$spekVersion")
                     runtimeOnly("org.spekframework.spek2:spek-runner-junit5:$spekVersion")
                     runtimeOnly(kotlin("reflect"))
@@ -84,7 +81,7 @@ kotlin {
 
             val jsMain by getting {
                 dependencies {
-                    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-js:1.3.2")
+                    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$coroutineVersion")
                     implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime-js:$serializationVersion")
                     implementation("io.ktor:ktor-client-js:$ktorVersion")
                     compileOnly(kotlin("stdlib-js"))

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

@@ -9,17 +9,17 @@ import io.ktor.client.HttpClient
 import io.ktor.client.features.ResponseException
 import io.ktor.client.request.HttpRequestBuilder
 import io.ktor.client.request.header
+import io.ktor.client.request.request
 import io.ktor.client.request.url
-import io.ktor.client.response.readText
+import io.ktor.client.statement.readText
 import io.ktor.client.utils.EmptyContent
 import io.ktor.http.ContentType
 import io.ktor.http.HttpMethod
 import io.ktor.http.content.ByteArrayContent
 import io.ktor.http.content.TextContent
+import io.ktor.utils.io.core.toByteArray
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.delay
-import kotlinx.io.core.toByteArray
-import kotlinx.io.core.use
 
 enum class HttpRequestMethod(internal val externalMethod: HttpMethod) {
     GET(HttpMethod.Get),
@@ -33,13 +33,13 @@ internal data class HttpHeader(val key: String, val value: String)
 internal data class HttpResponse(val responseCode: Int, val body: String, val headers: List<HttpHeader>)
 
 internal class HttpConnection constructor(
-    private val url: String,
-    private val method: HttpRequestMethod,
-    private val bodyMap: Map<*, *>?,
-    private val bodyString: String?,
-    contentType: String?,
-    private val headers: List<HttpHeader> = listOf(),
-    val api: SpotifyApi<*, *>? = null
+        private val url: String,
+        private val method: HttpRequestMethod,
+        private val bodyMap: Map<*, *>?,
+        private val bodyString: String?,
+        contentType: String?,
+        private val headers: List<HttpHeader> = listOf(),
+        val api: SpotifyApi<*, *>? = null
 ) {
     private val contentType: ContentType = contentType?.let { ContentType.parse(it) } ?: ContentType.Application.Json
 
@@ -82,45 +82,44 @@ internal class HttpConnection constructor(
     }
 
     internal suspend fun execute(
-        additionalHeaders: List<HttpHeader>? = null,
-        retryIf502: Boolean = true
+            additionalHeaders: List<HttpHeader>? = null,
+            retryIf502: Boolean = true
     ): HttpResponse {
         val httpRequest = buildRequest(additionalHeaders)
 
         try {
-            return client.execute(httpRequest).use {
-                val resp = it.response
-                val respCode = resp.status.value
+            return client.request<io.ktor.client.statement.HttpResponse>(httpRequest).let { response ->
+                val respCode = response.status.value
 
                 if (respCode == 502 && retryIf502) {
                     api?.logger?.logError(
-                        false,
-                        "Received 502 (Invalid response) for URL $url and $this\nRetrying..",
-                        null
+                            false,
+                            "Received 502 (Invalid response) for URL $url and $this\nRetrying..",
+                            null
                     )
-                    return@use execute(additionalHeaders, retryIf502 = false)
+                    return@let execute(additionalHeaders, retryIf502 = false)
                 } else if (respCode == 502 && !retryIf502) {
                     api?.logger?.logWarning("Recieved 502 (Invalid response) for URL $url and $this\nNot retrying")
                 }
 
                 if (respCode == 429) {
-                    val ratelimit = resp.headers["Retry-After"]!!.toLong() + 1L
+                    val ratelimit = response.headers["Retry-After"]!!.toLong() + 1L
                     if (api?.retryWhenRateLimited == true) {
                         api.logger.logError(
-                            false,
-                            "The request ($url) was ratelimited for $ratelimit seconds at ${getCurrentTimeMs()}",
-                            null
+                                false,
+                                "The request ($url) was ratelimited for $ratelimit seconds at ${getCurrentTimeMs()}",
+                                null
                         )
 
                         delay(ratelimit * 1000)
-                        return@use execute(additionalHeaders, retryIf502 = retryIf502)
+                        return@let execute(additionalHeaders, retryIf502 = retryIf502)
                     } else throw SpotifyRatelimitedException(ratelimit)
                 }
 
-                val body = resp.readText()
+                val body = response.readText()
 
                 if (respCode == 401 && body.contains("access token") &&
-                    api != null && api.automaticRefresh
+                        api != null && api.automaticRefresh
                 ) {
                     api.suspendRefreshToken()
                     val newAdditionalHeaders = additionalHeaders?.toMutableList() ?: mutableListOf()
@@ -129,14 +128,14 @@ internal class HttpConnection constructor(
                 }
 
                 return HttpResponse(
-                    responseCode = respCode,
-                    body = body,
-                    headers = resp.headers.entries().map { (key, value) ->
-                        HttpHeader(
-                            key,
-                            value.getOrNull(0) ?: "null"
-                        )
-                    }
+                        responseCode = respCode,
+                        body = body,
+                        headers = response.headers.entries().map { (key, value) ->
+                            HttpHeader(
+                                    key,
+                                    value.getOrNull(0) ?: "null"
+                            )
+                        }
                 )
             }
         } catch (e: CancellationException) {

src/commonMain/kotlin/com.adamratzman.spotify/utils/Base64.kt

@@ -1,8 +1,8 @@
 /* Spotify Web API - Kotlin Wrapper; MIT License, 2019; Original author: Adam Ratzman */
 package com.adamratzman.spotify.utils
 
-import kotlinx.io.core.String
-import kotlinx.io.core.toByteArray
+import io.ktor.utils.io.core.String
+import io.ktor.utils.io.core.toByteArray
 
 private val BASE64_ALPHABET: String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 private val BASE64_MASK: Byte = 0x3f

src/commonTest/kotlin/com.adamratzman/spotify/Common.kt

@@ -40,3 +40,12 @@ val api = when {
 }
 
 expect fun getEnvironmentVariable(name: String): String?
+
+expect fun Exception.stackTrace()
+
+fun block(code: () -> Unit) = try {
+    code
+} catch (e: Exception) {
+    e.stackTrace()
+    throw e
+}

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

@@ -3,6 +3,7 @@ package com.adamratzman.spotify.utilities
 
 import com.adamratzman.spotify.SpotifyClientAPI
 import com.adamratzman.spotify.api
+import com.adamratzman.spotify.block
 import com.adamratzman.spotify.getEnvironmentVariable
 import com.adamratzman.spotify.spotifyAppApi
 import com.adamratzman.spotify.spotifyClientApi
@@ -49,8 +50,11 @@ class UtilityTests : Spek({
                         clientSecret = getEnvironmentVariable("SPOTIFY_CLIENT_SECRET")
                     }
                 }
-                api.build()
-                api.buildAsyncAt(GlobalScope) { }
+
+                block {
+                    api.build()
+                    api.buildAsyncAt(GlobalScope) { }
+                }
             }
 
             it("Refresh on invalid token") {

src/jsTest/kotlin/com/adamratzman/spotify/CommonImpl.kt

@@ -8,6 +8,8 @@ actual fun getEnvironmentVariable(name: String): String? {
     return null
 }
 
+actual fun Exception.stackTrace() = println(this)
+
 @Test
 fun test() {
     println("asdf")

src/jvmTest/kotlin/com/adamratzman/spotify/CommonImpl.kt

@@ -4,3 +4,8 @@ package com.adamratzman.spotify
 actual fun getEnvironmentVariable(name: String): String? {
     return System.getenv(name) ?: System.getProperty(name)
 }
+
+actual fun Exception.stackTrace() {
+    println(this.stackTrace.joinToString("\n") { it.toString() })
+    this.printStackTrace()
+}