be able to run public endpoint tests on jvm

Author: adamint

README.md

@@ -388,33 +388,8 @@ APIs available only in `SpotifyClientApi` and `SpotifyImplicitGrantApi` instance
 
 ### Java
 This library has first-class support for Java! You have two choices when using this library: async-only with Kotlin
-suspend functions (using SpotifyContinuation), or by using the `SpotifyRestAction` class. Using `SpotifyRestAction`s are 
-recommended.
-
-#### What is the SpotifyRestAction class and how do I use it?
-Abstracting requests into a `SpotifyRestAction` class allows for a lot of flexibility in sending and receiving requests.
-This class includes options for asynchronous and blocking execution in all endpoints. However,
-due to this, you **must** call one of the provided methods in order for the call
-to execute! The `SpotifyRestAction` provides many methods and fields for use, including blocking and asynchronous ones. For example,
-- `hasRun()` tells you whether the rest action has been *started*
-- `hasCompleted()` tells you whether this rest action has been fully executed and *completed*
-- `complete()` blocks the current thread and returns the result
-- `suspendComplete(context: CoroutineContext = Dispatchers.Default)` switches to given context, invokes the supplier, and synchronously retrieves the result.
-- `suspendQueue()` suspends the coroutine, invokes the supplier asynchronously, and resumes with the result
-- `queue()` executes and immediately returns
-- `queue(consumer: (T) -> Unit)` executes the provided callback as soon as the request
-  is asynchronously evaluated
-- `queueAfter(quantity: Int, timeUnit: TimeUnit, consumer: (T) -> Unit)` executes the
-  provided callback after the provided time. As long as supplier execution is less than the provided
-  time, this will likely be accurate within a few milliseconds.
-- `asFuture()` transforms the supplier into a `CompletableFuture` (only JVM)
-
-Here's an example of how easy it is to use `spotify-web-api-kotlin` with a `SpotifyRestAction`:
-```java
-var api = SpotifyApiBuilderKt.spotifyAppApi(Const.clientId, Const.clientSecret).buildRestAction(true).complete();
-var album = api.getAlbums().getAlbumRestAction("spotify:album:0b23AHutIA1BOW0u1dZ6wM", null).complete();
-System.out.println("Album name is: " + album.getName());
-```
+suspend functions (using SpotifyContinuation).
+
 
 #### Integrating with Kotlin suspend functions via Java `Continuation`s
 Unfortunately, coroutines don't play very nicely with Java code. Fortunately, however, we provide a wrapper around Kotlin's 

build.gradle.kts

@@ -156,10 +156,6 @@ kotlin {
         binaries.executable()
     }
 
-    // val hostOs = System.getProperty("os.name")
-    // val isMainHost = hostOs.contains("mac", true)
-    // val isMingwX64 = hostOs.startsWith("Windows")
-
     macosX64 {
         mavenPublication {
             setupPom(artifactId)
@@ -216,8 +212,6 @@ kotlin {
     }
 
     targets {
-        val kotlinxDatetimeVersion = "0.3.1"
-
         sourceSets {
             val kotlinxDatetimeVersion = "0.4.0"
             val serializationVersion = "1.3.3"
@@ -227,7 +221,7 @@ kotlin {
             val korlibsVersion = "2.2.0"
             val androidSpotifyAuthVersion = "1.2.5"
             val androidCryptoVersion = "1.0.0"
-            val coroutineMTVersion = "1.6.0-native-mt"
+            val coroutineMTVersion = "1.6.4"
 
             val commonMain by getting {
                 dependencies {
@@ -240,6 +234,7 @@ kotlin {
 
             val commonTest by getting {
                 dependencies {
+                    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4")
                     implementation(kotlin("test-common"))
                     implementation(kotlin("test-annotations-common"))
                 }

gradle.properties

@@ -20,4 +20,5 @@ android.useAndroidX=true
 android.enableJetifier=true
 kotlin.mpp.enableGranularSourceSetsMetadata=true
 kotlinVersion=1.7.10
-androidBuildToolsVersion=7.0.0
+androidBuildToolsVersion=7.0.0
+versions.kotlinxdatetime=0.4.0

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

@@ -75,28 +75,28 @@ public abstract class SpotifyEndpoint(public val api: GenericSpotifyApi) {
         }
     }
 
-    internal suspend fun get(url: String): String {
+    internal open suspend fun get(url: String): String {
         return execute<String>(url)
     }
 
     internal suspend fun getNullable(url: String): String? {
-        return execute<String?>(url, retryOnNull = false)
+        return execute(url, retryOnNull = false)
     }
 
-    internal suspend fun post(url: String, body: String? = null, contentType: String? = null): String {
-        return execute<String>(url, body, HttpRequestMethod.POST, contentType = contentType)
+    internal open suspend fun post(url: String, body: String? = null, contentType: String? = null): String {
+        return execute(url, body, HttpRequestMethod.POST, contentType = contentType)
     }
 
-    internal suspend fun put(url: String, body: String? = null, contentType: String? = null): String {
-        return execute<String>(url, body, HttpRequestMethod.PUT, contentType = contentType)
+    internal open suspend fun put(url: String, body: String? = null, contentType: String? = null): String {
+        return execute(url, body, HttpRequestMethod.PUT, contentType = contentType)
     }
 
     internal suspend fun delete(
         url: String,
         body: String? = null,
         contentType: String? = null
     ): String {
-        return execute<String>(url, body, HttpRequestMethod.DELETE, contentType = contentType)
+        return execute(url, body, HttpRequestMethod.DELETE, contentType = contentType)
     }
 
     @Suppress("UNCHECKED_CAST")

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

@@ -8,4 +8,4 @@ public enum class TimeUnit(public val multiplier: Long) {
     MILLISECONDS(1), SECONDS(1000), MINUTES(60000);
 
     public fun toMillis(duration: Long): Long = duration * multiplier
-}
+}

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

@@ -1,80 +1,19 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
 package com.adamratzman.spotify
 
-import kotlin.native.concurrent.ThreadLocal
 import kotlin.test.assertTrue
 import kotlinx.coroutines.CoroutineScope
-
-val clientId = getEnvironmentVariable("SPOTIFY_CLIENT_ID")
-val clientSecret = getEnvironmentVariable("SPOTIFY_CLIENT_SECRET")
-val redirectUri = getEnvironmentVariable("SPOTIFY_REDIRECT_URI")
-val tokenString = getEnvironmentVariable("SPOTIFY_TOKEN_STRING")
-
-// https://github.com/Kotlin/kotlinx.coroutines/issues/1996#issuecomment-728562784
-expect fun runBlockingTest(block: suspend CoroutineScope.() -> Unit)
-
-@ThreadLocal
-var instantiationCompleted: Boolean = false
-
-@ThreadLocal
-private lateinit var apiBacking: GenericSpotifyApi
-
-// https://github.com/Kotlin/kotlinx.coroutines/issues/706#issuecomment-429922811
-suspend fun buildSpotifyApi() = when {
-    tokenString?.isNotBlank() == true -> {
-        spotifyClientApi {
-            credentials {
-                clientId = com.adamratzman.spotify.clientId
-                clientSecret = com.adamratzman.spotify.clientSecret
-                redirectUri = com.adamratzman.spotify.redirectUri
-            }
-            authorization {
-                tokenString = com.adamratzman.spotify.tokenString
-            }
-        }.build().also { instantiationCompleted = true; apiBacking = it }
-    }
-    clientId?.isNotBlank() == true -> {
-        spotifyAppApi {
-            credentials {
-                clientId = com.adamratzman.spotify.clientId
-                clientSecret = com.adamratzman.spotify.clientSecret
-            }
-        }.build().also {
-            instantiationCompleted = true; apiBacking = it
-        }
-    }
-    else -> null.also { instantiationCompleted = true }
-}?.also { if (getEnvironmentVariable("SPOTIFY_LOG_HTTP") == "true") it.spotifyApiOptions.enableDebugMode = true }
-
-fun buildSpotifyApiSync() = when {
-    tokenString?.isNotBlank() == true -> {
-        spotifyClientApi {
-            credentials {
-                clientId = com.adamratzman.spotify.clientId
-                clientSecret = com.adamratzman.spotify.clientSecret
-                redirectUri = com.adamratzman.spotify.redirectUri
-            }
-            authorization {
-                tokenString = com.adamratzman.spotify.tokenString
-            }
-        }.buildRestAction().complete().also { instantiationCompleted = true; apiBacking = it }
-    }
-    clientId?.isNotBlank() == true -> {
-        spotifyAppApi {
-            credentials {
-                clientId = com.adamratzman.spotify.clientId
-                clientSecret = com.adamratzman.spotify.clientSecret
-            }
-        }.buildRestAction().complete().also {
-            instantiationCompleted = true; apiBacking = it
-        }
-    }
-    else -> null.also { instantiationCompleted = true }
-}?.also { if (getEnvironmentVariable("SPOTIFY_LOG_HTTP") == "true") it.spotifyApiOptions.enableDebugMode = true }
-
-expect fun getEnvironmentVariable(name: String): String?
-
-expect fun Exception.stackTrace()
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.TestResult
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.withContext
+
+expect fun areLivePkceTestsEnabled(): Boolean
+expect fun arePlayerTestsEnabled(): Boolean
+expect fun getTestClientId(): String?
+expect fun getTestClientSecret(): String?
+expect suspend fun buildSpotifyApi(): GenericSpotifyApi?
 
 suspend inline fun <reified T : Throwable> assertFailsWithSuspend(crossinline block: suspend () -> Unit) {
     val noExceptionMessage = "Expected ${T::class.simpleName} exception to be thrown, but no exception was thrown."
@@ -89,3 +28,10 @@ suspend inline fun <reified T : Throwable> assertFailsWithSuspend(crossinline bl
         )
     }
 }
+
+@OptIn(ExperimentalCoroutinesApi::class)
+fun <T> runTestOnDefaultDispatcher(block: suspend CoroutineScope.() -> T): TestResult = runTest {
+    withContext(Dispatchers.Default) {
+        block()
+    }
+}

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

@@ -1,37 +1,29 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
 package com.adamratzman.spotify
 
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+
 abstract class AbstractTest<T : GenericSpotifyApi> {
-    var api: T? = null
+    lateinit var api: T
+    var apiInitialized: Boolean = false
 
-    open fun testPrereq(): Boolean {
-        val result = api != null
-        if (!result) println("Prereq failed in ${this::class.simpleName}.")
-        return result
-    }
+    suspend inline fun <reified Z : T> buildApi() {
+        if (apiInitialized) return
 
-    suspend inline fun <reified Z : T> build(): Boolean {
-        return try {
-            val f = buildSpotifyApi()
-            @Suppress("UNCHECKED_CAST")
-            (f as? T)?.let { if (f is Z) api = it }
-            api != null
-        } catch (cce: Exception) {
-            cce.printStackTrace()
-            false
+        val api = buildSpotifyApi()
+        if (api != null && api is Z) {
+            this.api = api
+            apiInitialized = true
         }
     }
 
-    fun buildSync(): Boolean {
-        return try {
-            @Suppress("UNCHECKED_CAST")
-            (buildSpotifyApiSync() as? T)?.let { api = it }
-            api != null
-        } catch (cce: ClassCastException) {
+    suspend fun isApiInitialized(): Boolean {
+        return if (apiInitialized) true
+        else {
+            println("Api is not initialized. buildSpotifyApi returns ${buildSpotifyApi()}")
             false
         }
     }
-}
-
-typealias GenericSpotifyApiTest = AbstractTest<GenericSpotifyApi>
-typealias SpotifyClientApiTest = AbstractTest<SpotifyClientApi>
+}

src/commonTest/kotlin/com.adamratzman/spotify/priv/ClientEpisodeApiTest.kt

@@ -1,42 +1,41 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
 package com.adamratzman.spotify.priv
 
 import com.adamratzman.spotify.AbstractTest
 import com.adamratzman.spotify.SpotifyClientApi
 import com.adamratzman.spotify.SpotifyException.BadRequestException
-import com.adamratzman.spotify.runBlockingTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import com.adamratzman.spotify.runTestOnDefaultDispatcher
 
 class ClientEpisodeApiTest : AbstractTest<SpotifyClientApi>() {
     @Test
-    fun testGetEpisode() {
-        return runBlockingTest {
-            super.build<SpotifyClientApi>()
-            if (!testPrereq()) return@runBlockingTest else api
+    fun testGetEpisode() = runTestOnDefaultDispatcher {
+        buildApi<SpotifyClientApi>()
+        if (!isApiInitialized()) return@runTestOnDefaultDispatcher
 
-            assertNull(api!!.episodes.getEpisode("nonexistant episode"))
-            assertNotNull(api!!.episodes.getEpisode("3lMZTE81Pbrp0U12WZe27l"))
-        }
+        assertNull(api.episodes.getEpisode("nonexistant episode"))
+        assertNotNull(api.episodes.getEpisode("3lMZTE81Pbrp0U12WZe27l"))
     }
 
     @Test
-    fun testGetEpisodes() {
-        return runBlockingTest {
-            super.build<SpotifyClientApi>()
-            if (!testPrereq()) return@runBlockingTest else api!!
+    fun testGetEpisodes() = runTestOnDefaultDispatcher {
+        buildApi<SpotifyClientApi>()
+        if (!isApiInitialized()) return@runTestOnDefaultDispatcher
 
-            assertFailsWith<BadRequestException> { api!!.episodes.getEpisodes("hi", "dad") }
-            assertFailsWith<BadRequestException> {
-                api!!.episodes.getEpisodes("1cfOhXP4GQCd5ZFHoSF8gg", "j").map { it?.name }
-            }
-            assertEquals(
-                listOf("The Great Inflation (Classic)"),
-                api!!.episodes.getEpisodes("3lMZTE81Pbrp0U12WZe27l").map { it?.name }
-            )
+        assertFailsWith<BadRequestException> { api.episodes.getEpisodes("hi", "dad") }
+        assertFailsWith<BadRequestException> {
+            api.episodes.getEpisodes("1cfOhXP4GQCd5ZFHoSF8gg", "j").map { it?.name }
         }
+        assertEquals(
+            listOf("The Great Inflation (Classic)"),
+            api.episodes.getEpisodes("3lMZTE81Pbrp0U12WZe27l").map { it?.name }
+        )
     }
 }