Merge branch 'main' into coroutines-convert-BTClient.getConfiguration

# Conflicts:
#	BraintreeCore/src/main/java/com/braintreepayments/api/core/BraintreeClient.kt
#	BraintreeCore/src/test/java/com/braintreepayments/api/core/BraintreeClientUnitTest.kt
#	TestUtils/src/main/java/com/braintreepayments/api/testutils/MockkBraintreeClientBuilder.kt

Author: noguier

BraintreeCore/src/androidTest/java/com/braintreepayments/api/core/BraintreeGraphQLClientTest.kt

@@ -4,6 +4,10 @@ import android.content.Context
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.internal.runner.junit4.AndroidJUnit4ClassRunner
 import com.braintreepayments.api.testutils.Fixtures
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import org.json.JSONException
 import org.json.JSONObject
 import org.junit.Assert.assertFalse
@@ -17,6 +21,8 @@ import javax.net.ssl.SSLException
 class BraintreeGraphQLClientTest {
 
     private lateinit var countDownLatch: CountDownLatch
+    private val mainDispatcher: CoroutineDispatcher = Dispatchers.Main
+    private val coroutineScope: CoroutineScope = CoroutineScope(mainDispatcher)
 
     @Before
     fun setup() {
@@ -29,10 +35,14 @@ class BraintreeGraphQLClientTest {
         val context = ApplicationProvider.getApplicationContext<Context>()
         val braintreeClient = BraintreeClient(context, Fixtures.TOKENIZATION_KEY)
 
-        braintreeClient.sendGraphQLPOST(JSONObject("{}")) { _, httpError ->
-            // Make sure SSL handshake is successful
-            assertFalse(httpError is SSLException)
-            countDownLatch.countDown()
+        coroutineScope.launch {
+            try {
+                braintreeClient.sendGraphQLPOST(JSONObject("{}"))
+            } catch (e: Exception) {
+                assertFalse(e is SSLException)
+            } finally {
+                countDownLatch.countDown()
+            }
         }
 
         countDownLatch.await()
@@ -44,10 +54,14 @@ class BraintreeGraphQLClientTest {
         val context = ApplicationProvider.getApplicationContext<Context>()
         val braintreeClient = BraintreeClient(context, Fixtures.PROD_TOKENIZATION_KEY)
 
-        braintreeClient.sendGraphQLPOST(JSONObject("{}")) { _, httpError ->
-            // Make sure SSL handshake is successful
-            assertFalse(httpError is SSLException)
-            countDownLatch.countDown()
+        coroutineScope.launch {
+            try {
+                braintreeClient.sendGraphQLPOST(JSONObject("{}"))
+            } catch (e: Exception) {
+                assertFalse(e is SSLException)
+            } finally {
+                countDownLatch.countDown()
+            }
         }
 
         countDownLatch.await()

BraintreeCore/src/main/java/com/braintreepayments/api/core/ApiClient.kt

@@ -22,11 +22,17 @@ class ApiClient(
 
     fun tokenizeGraphQL(tokenizePayload: JSONObject, callback: TokenizeCallback) =
         braintreeClient.run {
-            sendGraphQLPOST(tokenizePayload) { responseBody, httpError ->
-                parseResponseToJSON(responseBody)?.let { json ->
-                    callback.onResult(json, null)
-                } ?: httpError?.let { error ->
-                    callback.onResult(null, error)
+            coroutineScope.launch {
+                try {
+                    val responseBody = sendGraphQLPOST(tokenizePayload)
+                    parseResponseToJSON(responseBody)?.let { json ->
+                        callback.onResult(json, null)
+                    } ?: callback.onResult(
+                        null,
+                        BraintreeException("Unable to parse GraphQL response.")
+                    )
+                } catch (e: IOException) {
+                    callback.onResult(null, e)
                 }
             }
         }

BraintreeCore/src/main/java/com/braintreepayments/api/core/BraintreeClient.kt

@@ -14,6 +14,9 @@ import kotlinx.coroutines.launch
 import org.json.JSONException
 import org.json.JSONObject
 import java.io.IOException
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
 
 /**
  * Core Braintree class that handles network requests.
@@ -169,37 +172,39 @@ class BraintreeClient internal constructor(
     /**
      * @suppress
      */
-    fun sendGraphQLPOST(json: JSONObject, responseCallback: HttpResponseCallback) {
-        coroutineScope.launch {
-            try {
-                val configuration = getConfiguration()
-                val response = graphQLClient.post(
-                    data = json.toString(),
-                    configuration = configuration,
-                    authorization = merchantRepository.authorization
-                )
-                try {
-                    val query = json.optString(GraphQLConstants.Keys.QUERY)
-                    val queryDiscardHolder = query.replace(Regex("^[^\\(]*"), "")
-                    val finalQuery = query.replace(queryDiscardHolder, "")
-                    val params = AnalyticsEventParams(
-                        startTime = response.timing.startTime,
-                        endTime = response.timing.endTime,
-                        endpoint = finalQuery
-                    )
-                    sendAnalyticsEvent(
-                        eventName = CoreAnalytics.API_REQUEST_LATENCY,
-                        params = params,
-                        sendImmediately = false
-                    )
-                    responseCallback.onResult(response.body, null)
-                } catch (jsonException: JSONException) {
-                    responseCallback.onResult(null, jsonException)
+    suspend fun sendGraphQLPOST(json: JSONObject): String {
+        val configuration = suspendCoroutine { continuation ->
+            getConfiguration { config, error ->
+                if (config != null) {
+                    continuation.resume(config)
+                } else {
+                    continuation.resumeWithException(error ?: Exception("Unknown configuration error"))
                 }
-            } catch (e: IOException) {
-                responseCallback.onResult(null, e)
             }
         }
+
+        val response = graphQLClient.post(
+            data = json.toString(),
+            configuration = configuration,
+            authorization = merchantRepository.authorization
+        )
+
+        val query = json.optString(GraphQLConstants.Keys.QUERY)
+        val queryDiscardHolder = query.replace(Regex("^[^\\(]*"), "")
+        val finalQuery = query.replace(queryDiscardHolder, "")
+        val params = AnalyticsEventParams(
+            startTime = response.timing.startTime,
+            endTime = response.timing.endTime,
+            endpoint = finalQuery
+        )
+
+        sendAnalyticsEvent(
+            eventName = CoreAnalytics.API_REQUEST_LATENCY,
+            params = params,
+            sendImmediately = false
+        )
+
+        return response.body ?: throw IOException("Response body is null")
     }
 
     /**

BraintreeCore/src/test/java/com/braintreepayments/api/core/ApiClientUnitTest.kt

@@ -3,14 +3,7 @@ package com.braintreepayments.api.core
 import com.braintreepayments.api.card.Card
 import com.braintreepayments.api.testutils.Fixtures
 import com.braintreepayments.api.testutils.MockkBraintreeClientBuilder
-import io.mockk.coEvery
-import io.mockk.coVerify
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.slot
-import io.mockk.spyk
-import io.mockk.verify
-import io.mockk.verifyOrder
+import io.mockk.*
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.TestScope
@@ -34,6 +27,7 @@ class ApiClientUnitTest {
 
     private lateinit var graphQLEnabledConfig: Configuration
     private lateinit var graphQLDisabledConfig: Configuration
+    private lateinit var testScope: TestScope
     private val testDispatcher = StandardTestDispatcher()
 
     @Before
@@ -44,6 +38,8 @@ class ApiClientUnitTest {
 
         graphQLEnabledConfig = Configuration.fromJson(Fixtures.CONFIGURATION_WITH_GRAPHQL)
         graphQLDisabledConfig = Configuration.fromJson(Fixtures.CONFIGURATION_WITHOUT_ACCESS_TOKEN)
+
+        testScope = TestScope(testDispatcher)
     }
 
     @Test
@@ -62,7 +58,7 @@ class ApiClientUnitTest {
                 data = capture(bodySlot),
             )
         } returns "{}"
-        val testScope = TestScope(testDispatcher)
+
         val sut = ApiClient(
             braintreeClient = braintreeClient,
             analyticsParamRepository = analyticsParamRepository,
@@ -89,19 +85,21 @@ class ApiClientUnitTest {
         assertEquals("session-id", data.getString("sessionId"))
     }
 
+    @OptIn(ExperimentalCoroutinesApi::class)
     @Test
     @Throws(BraintreeException::class, InvalidArgumentException::class, JSONException::class)
-    fun tokenizeGraphQL_tokenizesCardsWithGraphQL() {
+    fun tokenizeGraphQL_tokenizesCardsWithGraphQL() = runTest(testDispatcher) {
         val braintreeClient = MockkBraintreeClientBuilder()
             .configurationSuccess(graphQLEnabledConfig)
             .build()
 
         val graphQLBodySlot = slot<JSONObject>()
-        every { braintreeClient.sendGraphQLPOST(capture(graphQLBodySlot), any()) } returns Unit
+        coEvery { braintreeClient.sendGraphQLPOST(capture(graphQLBodySlot)) } returns ""
 
-        val sut = ApiClient(braintreeClient)
+        val sut = ApiClient(braintreeClient, analyticsParamRepository, testDispatcher, testScope)
         val card = Card()
         sut.tokenizeGraphQL(card.buildJSONForGraphQL(), tokenizeCallback)
+        advanceUntilIdle()
 
         coVerify(inverse = true) {
             braintreeClient.sendPOST(
@@ -118,7 +116,7 @@ class ApiClientUnitTest {
             .configurationSuccess(graphQLEnabledConfig)
             .sendPostSuccessfulResponse("{}")
             .build()
-        val testScope = TestScope(testDispatcher)
+
         val sut = ApiClient(
             braintreeClient = braintreeClient,
             dispatcher = testDispatcher,
@@ -129,7 +127,7 @@ class ApiClientUnitTest {
 
         advanceUntilIdle()
 
-        verify(inverse = true) { braintreeClient.sendGraphQLPOST(any(), any()) }
+        coVerify(inverse = true) { braintreeClient.sendGraphQLPOST(any()) }
     }
 
     @Test
@@ -138,7 +136,7 @@ class ApiClientUnitTest {
         val braintreeClient = MockkBraintreeClientBuilder()
             .sendPostSuccessfulResponse("{}")
             .build()
-        val testScope = TestScope(testDispatcher)
+
         val sut = ApiClient(
             braintreeClient = braintreeClient,
             dispatcher = testDispatcher,