Add Error when Tokenization Key is Used for ShopperInsights (#1057)

* Add error when tokenization key is used for ShopperInsights
braintree · Jul 11, 2024 · 26f69af · 26f69af
1 parent 681435c
commit 26f69af
Show file tree

Hide file tree

Showing 5 changed files with 75 additions and 17 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,8 @@
 
 * PayPal
   * Fix issue that causes a JSON parsing error when Pay Later is selected during checkout.
+* ShopperInsights (BETA)
+  * Add error when using an invalid authorization type
 
 ## 4.49.0 (2024-07-08)
 

diff --git a/ShopperInsights/build.gradle b/ShopperInsights/build.gradle
@@ -41,6 +41,9 @@ dependencies {
     testImplementation deps.jsonAssert
     testImplementation deps.kotlinTest
     testImplementation deps.mockk
+    testImplementation deps.robolectric
+    testImplementation deps.junitTest
+    testImplementation project(':TestUtils')
 }
 
 // region signing and publishing

diff --git a/ShopperInsights/src/main/java/com/braintreepayments/api/ShopperInsightsClient.kt b/ShopperInsights/src/main/java/com/braintreepayments/api/ShopperInsightsClient.kt
@@ -30,7 +30,6 @@ class ShopperInsightsClient @VisibleForTesting internal constructor(
     /**
      * Retrieves recommended payment methods based on the provided shopper insights request.
      *
-     * @param context Android context
      * @param request The [ShopperInsightsRequest] containing information about the shopper.
      * @return A [ShopperInsightsResult] object indicating the recommended payment methods.
      * Note: This feature is in beta. Its public API may change or be removed in future releases
@@ -54,23 +53,43 @@ class ShopperInsightsClient @VisibleForTesting internal constructor(
             return
         }
 
-        api.findEligiblePayments(
-            EligiblePaymentsApiRequest(
-                request,
-                currencyCode = currencyCode,
-                countryCode = countryCode,
-                accountDetails = includeAccountDetails,
-                constraintType = constraintType,
-                paymentSources = paymentSources
-            ),
-            callback = { result, error ->
-                handleFindEligiblePaymentsResult(
-                    result,
-                    error,
-                    callback
-                )
+        braintreeClient.getAuthorization { authorization, authorizationError ->
+            if (authorization != null) {
+                when (authorization) {
+                    is TokenizationKey -> {
+                        callbackFailure(
+                            callback = callback,
+                            error = BraintreeException(
+                                "Invalid authorization. This feature can only be used with a client token."
+                            )
+                        )
+                        return@getAuthorization
+                    }
+
+                    is ClientToken -> {
+                        api.findEligiblePayments(
+                            EligiblePaymentsApiRequest(
+                                request,
+                                currencyCode = currencyCode,
+                                countryCode = countryCode,
+                                accountDetails = includeAccountDetails,
+                                constraintType = constraintType,
+                                paymentSources = paymentSources
+                            ),
+                            callback = { result, error ->
+                                handleFindEligiblePaymentsResult(
+                                    result,
+                                    error,
+                                    callback
+                                )
+                            }
+                        )
+                    }
+                }
+            } else if (authorizationError != null) {
+                callbackFailure(callback = callback, error = BraintreeException(authorizationError?.message))
             }
-        )
+        }
     }
 
     private fun handleFindEligiblePaymentsResult(

diff --git a/ShopperInsights/src/test/java/com/braintreepayments/api/ShopperInsightsClientUnitTest.kt b/ShopperInsights/src/test/java/com/braintreepayments/api/ShopperInsightsClientUnitTest.kt
@@ -1,5 +1,7 @@
 package com.braintreepayments.api
 
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
 import io.mockk.every
 import io.mockk.just
 import io.mockk.mockk
@@ -8,6 +10,8 @@ import io.mockk.slot
 import io.mockk.verify
 import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
@@ -19,18 +23,25 @@ import kotlin.test.assertTrue
  * It focuses on testing how the client handles different scenarios when fetching recommended
  * payment methods.
  */
+@RunWith(RobolectricTestRunner::class)
 @OptIn(ExperimentalBetaApi::class)
 class ShopperInsightsClientUnitTest {
 
     private lateinit var sut: ShopperInsightsClient
     private lateinit var api: ShopperInsightsApi
     private lateinit var braintreeClient: BraintreeClient
+    private lateinit var context: Context
+
+    private val authorizationCallbackSlot = slot<AuthorizationCallback>()
 
     @Before
     fun beforeEach() {
         api = mockk(relaxed = true)
         braintreeClient = mockk(relaxed = true)
         sut = ShopperInsightsClient(api, braintreeClient)
+        context = ApplicationProvider.getApplicationContext()
+
+        every { braintreeClient.getAuthorization(capture(authorizationCallbackSlot)) } just runs
     }
 
     @Test
@@ -365,6 +376,27 @@ class ShopperInsightsClientUnitTest {
         verifySuccessAnalyticsEvent()
     }
 
+    @Test
+    fun `test getRecommendPaymentMethods is called with a tokenization key, error is sent`() {
+        val braintreeClient = MockkBraintreeClientBuilder()
+            .authorizationSuccess(Authorization.fromString(Fixtures.TOKENIZATION_KEY))
+            .build()
+
+        sut = ShopperInsightsClient(api, braintreeClient)
+
+        val request = ShopperInsightsRequest("some-email", null)
+        sut.getRecommendedPaymentMethods(request) { result ->
+            assertTrue { result is ShopperInsightsResult.Failure }
+            assertTrue {
+                (result as ShopperInsightsResult.Failure).error is BraintreeException
+            }
+            assertEquals(
+                "Invalid authorization. This feature can only be used with a client token.",
+                (result as ShopperInsightsResult.Failure).error.message
+            )
+        }
+    }
+
     @Test
     fun `test paypal presented analytics event`() {
         sut.sendPayPalPresentedEvent()
@@ -399,6 +431,7 @@ class ShopperInsightsClientUnitTest {
         every { api.findEligiblePayments(any(), capture(apiCallbackSlot)) } just runs
 
         sut.getRecommendedPaymentMethods(request, callback)
+        authorizationCallbackSlot.captured.onAuthorizationResult(ClientToken(Fixtures.BASE64_CLIENT_TOKEN), null)
 
         apiCallbackSlot.captured.onResult(result = result, error = error)
     }

diff --git a/ShopperInsights/src/test/resources/robolectric.properties b/ShopperInsights/src/test/resources/robolectric.properties
@@ -0,0 +1 @@
+sdk=28