Some fixes and tests

purchases/src/main/kotlin/com/revenuecat/purchases/common/AppConfig.kt

@@ -57,6 +57,7 @@ internal class AppConfig(
         if (forceServerErrors != other.forceServerErrors) return false
         if (forceSigningErrors != other.forceSigningErrors) return false
         if (baseURL != other.baseURL) return false
+        if (showDeclinedPaymentMessagesAutomatically != other.showDeclinedPaymentMessagesAutomatically) return false
 
         return true
     }
@@ -72,6 +73,7 @@ internal class AppConfig(
         result = 31 * result + forceServerErrors.hashCode()
         result = 31 * result + forceSigningErrors.hashCode()
         result = 31 * result + baseURL.hashCode()
+        result = 31 * result + showDeclinedPaymentMessagesAutomatically.hashCode()
         return result
     }
 
@@ -84,6 +86,7 @@ internal class AppConfig(
             "versionName='$versionName', " +
             "packageName='$packageName', " +
             "finishTransactions=$finishTransactions, " +
+            "showDeclinedPaymentMessagesAutomatically=$showDeclinedPaymentMessagesAutomatically, " +
             "baseURL=$baseURL)"
     }
 }

purchases/src/main/kotlin/com/revenuecat/purchases/google/BillingWrapper.kt

@@ -763,18 +763,26 @@ internal class BillingWrapper(
             .build()
         val weakActivity = WeakReference(activity)
 
-        withConnectedClient {
-            val activity = weakActivity.get() ?: run {
-                debugLog("Activity is null, not showing Google Play in-app message.")
-                return@withConnectedClient
+        executeRequestOnUIThread { error ->
+            if (error != null) {
+                errorLog(BillingStrings.BILLING_CONNECTION_ERROR_INAPP_MESSAGES.format(error))
+                return@executeRequestOnUIThread
             }
-            showInAppMessages(activity, inAppMessageParams) { inAppMessageResult ->
-                if (inAppMessageResult.responseCode == InAppMessageResult.InAppMessageResponseCode.NO_ACTION_NEEDED) {
-                    verboseLog("No Google Play in-app message was available.")
-                } else if (inAppMessageResult.responseCode
-                    == InAppMessageResult.InAppMessageResponseCode.SUBSCRIPTION_STATUS_UPDATED
-                ) {
-                    debugLog("Subscription status was updated from In-App Message.")
+            withConnectedClient {
+                val activity = weakActivity.get() ?: run {
+                    debugLog("Activity is null, not showing Google Play in-app message.")
+                    return@withConnectedClient
+                }
+                showInAppMessages(activity, inAppMessageParams) { inAppMessageResult ->
+                    when (val responseCode = inAppMessageResult.responseCode) {
+                        InAppMessageResult.InAppMessageResponseCode.NO_ACTION_NEEDED -> {
+                            verboseLog(BillingStrings.BILLING_INAPP_MESSAGE_NONE)
+                        }
+                        InAppMessageResult.InAppMessageResponseCode.SUBSCRIPTION_STATUS_UPDATED -> {
+                            debugLog(BillingStrings.BILLING_INAPP_MESSAGE_UPDATE)
+                        }
+                        else -> errorLog(BillingStrings.BILLING_INAPP_MESSAGE_UNEXPECTED_CODE.format(responseCode))
+                    }
                 }
             }
         }

purchases/src/main/kotlin/com/revenuecat/purchases/strings/BillingStrings.kt

@@ -22,4 +22,9 @@ internal object BillingStrings {
     const val BILLING_CLIENT_RETRY = "Retrying BillingClient connection after backoff of %s milliseconds."
     const val ILLEGAL_STATE_EXCEPTION_WHEN_CONNECTING = "There was an IllegalStateException when connecting to " +
         "BillingClient. This has been reported to occur on Samsung devices on unknown circumstances.\nException: %s"
+    const val BILLING_CONNECTION_ERROR_INAPP_MESSAGES = "Error connecting to billing client to display " +
+        "inapp messages: %s"
+    const val BILLING_INAPP_MESSAGE_NONE = "No Google Play in-app message was available."
+    const val BILLING_INAPP_MESSAGE_UPDATE = "Subscription status was updated from In-App Message."
+    const val BILLING_INAPP_MESSAGE_UNEXPECTED_CODE = "Unexpected billing code: %s"
 }

purchases/src/test/java/com/revenuecat/purchases/BasePurchasesTest.kt

@@ -332,10 +332,12 @@ internal open class BasePurchasesTest {
         anonymous: Boolean,
         autoSync: Boolean = true,
         customEntitlementComputation: Boolean = false,
+        showDeclinedPaymentMessagesAutomatically: Boolean = false,
     ) {
         val appConfig = AppConfig(
             context = mockContext,
             observerMode = false,
+            showDeclinedPaymentMessagesAutomatically = showDeclinedPaymentMessagesAutomatically,
             platformInfo = PlatformInfo("native", "3.2.0"),
             proxyURL = null,
             store = Store.PLAY_STORE,

purchases/src/test/java/com/revenuecat/purchases/PurchasesCommonTest.kt

@@ -1497,6 +1497,7 @@ internal class PurchasesCommonTest: BasePurchasesTest() {
         purchases.purchasesOrchestrator.appConfig = AppConfig(
             mockContext,
             false,
+            false,
             PlatformInfo("", null),
             null,
             Store.AMAZON
@@ -1665,88 +1666,6 @@ internal class PurchasesCommonTest: BasePurchasesTest() {
 
     // endregion
 
-    // region app lifecycle
-
-    @Test
-    fun `state appInBackground is updated when app foregrounded`() {
-        mockOfferingsManagerAppForeground()
-        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = true)
-        Purchases.sharedInstance.purchasesOrchestrator.onAppForegrounded()
-        assertThat(purchases.purchasesOrchestrator.state.appInBackground).isFalse()
-    }
-
-    @Test
-    fun `state appInBackground is updated when app backgrounded`() {
-        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = false)
-        Purchases.sharedInstance.purchasesOrchestrator.onAppBackgrounded()
-        assertThat(purchases.purchasesOrchestrator.state.appInBackground).isTrue()
-    }
-
-    @Test
-    fun `force update of caches when app foregrounded for the first time`() {
-        mockOfferingsManagerAppForeground()
-        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = false, firstTimeInForeground = true)
-        Purchases.sharedInstance.purchasesOrchestrator.onAppForegrounded()
-        assertThat(purchases.purchasesOrchestrator.state.firstTimeInForeground).isFalse()
-        verify(exactly = 1) {
-            mockCustomerInfoHelper.retrieveCustomerInfo(
-                appUserId,
-                CacheFetchPolicy.FETCH_CURRENT,
-                false,
-                any()
-            )
-        }
-        verify(exactly = 0) {
-            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
-        }
-    }
-
-    @Test
-    fun `don't force update of caches when app foregrounded not for the first time`() {
-        every {
-            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
-        } returns false
-        mockOfferingsManagerAppForeground()
-        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = false, firstTimeInForeground = false)
-        Purchases.sharedInstance.purchasesOrchestrator.onAppForegrounded()
-        assertThat(purchases.purchasesOrchestrator.state.firstTimeInForeground).isFalse()
-        verify(exactly = 0) {
-            mockCustomerInfoHelper.retrieveCustomerInfo(
-                appUserId,
-                CacheFetchPolicy.FETCH_CURRENT,
-                false,
-                any()
-            )
-        }
-        verify(exactly = 1) {
-            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
-        }
-    }
-
-    @Test
-    fun `update of caches when app foregrounded not for the first time and caches stale`() {
-        every {
-            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
-        } returns true
-        mockOfferingsManagerAppForeground()
-        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = false, firstTimeInForeground = false)
-        Purchases.sharedInstance.purchasesOrchestrator.onAppForegrounded()
-        assertThat(purchases.purchasesOrchestrator.state.firstTimeInForeground).isFalse()
-        verify(exactly = 1) {
-            mockCustomerInfoHelper.retrieveCustomerInfo(
-                appUserId,
-                CacheFetchPolicy.FETCH_CURRENT,
-                false,
-                any()
-            )
-        }
-        verify(exactly = 1) {
-            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
-        }
-    }
-
-    // endregion
-
     // region Private Methods
     private fun mockSynchronizeSubscriberAttributesForAllUsers() {
         every {

purchases/src/test/java/com/revenuecat/purchases/PurchasesConfigurationTest.kt

@@ -37,6 +37,7 @@ class PurchasesConfigurationTest {
         assertThat(purchasesConfiguration.diagnosticsEnabled).isFalse
         assertThat(purchasesConfiguration.verificationMode).isEqualTo(EntitlementVerificationMode.DISABLED)
         assertThat(purchasesConfiguration.dangerousSettings).isEqualTo(DangerousSettings(autoSyncPurchases = true))
+        assertThat(purchasesConfiguration.showDeclinedPaymentMessagesAutomatically).isFalse
     }
 
     @Test
@@ -52,6 +53,12 @@ class PurchasesConfigurationTest {
         assertThat(purchasesConfiguration.observerMode).isTrue
     }
 
+    @Test
+    fun `PurchasesConfiguration sets showDeclinedPaymentMessagesAutomatically correctly`() {
+        val purchasesConfiguration = builder.showDeclinedPaymentMessagesAutomatically(true).build()
+        assertThat(purchasesConfiguration.showDeclinedPaymentMessagesAutomatically).isTrue
+    }
+
     @Test
     fun `PurchasesConfiguration sets service correctly`() {
         val serviceMock: ExecutorService = mockk()

purchases/src/test/java/com/revenuecat/purchases/PurchasesLifecycleTest.kt

@@ -0,0 +1,137 @@
+package com.revenuecat.purchases
+
+import android.app.Activity
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.revenuecat.purchases.common.AppConfig
+import com.revenuecat.purchases.common.PlatformInfo
+import io.mockk.Runs
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.verify
+import org.assertj.core.api.Assertions
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(manifest = Config.NONE)
+internal class PurchasesLifecycleTest: BasePurchasesTest() {
+
+    // region app lifecycle
+
+    @Test
+    fun `state appInBackground is updated when app foregrounded`() {
+        mockOfferingsManagerAppForeground()
+        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = true)
+        Purchases.sharedInstance.purchasesOrchestrator.onAppForegrounded()
+        Assertions.assertThat(purchases.purchasesOrchestrator.state.appInBackground).isFalse
+    }
+
+    @Test
+    fun `state appInBackground is updated when app backgrounded`() {
+        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = false)
+        Purchases.sharedInstance.purchasesOrchestrator.onAppBackgrounded()
+        Assertions.assertThat(purchases.purchasesOrchestrator.state.appInBackground).isTrue
+    }
+
+    @Test
+    fun `force update of caches when app foregrounded for the first time`() {
+        mockOfferingsManagerAppForeground()
+        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = false, firstTimeInForeground = true)
+        Purchases.sharedInstance.purchasesOrchestrator.onAppForegrounded()
+        Assertions.assertThat(purchases.purchasesOrchestrator.state.firstTimeInForeground).isFalse
+        verify(exactly = 1) {
+            mockCustomerInfoHelper.retrieveCustomerInfo(
+                appUserId,
+                CacheFetchPolicy.FETCH_CURRENT,
+                false,
+                any()
+            )
+        }
+        verify(exactly = 0) {
+            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
+        }
+    }
+
+    @Test
+    fun `don't force update of caches when app foregrounded not for the first time`() {
+        every {
+            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
+        } returns false
+        mockOfferingsManagerAppForeground()
+        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = false, firstTimeInForeground = false)
+        Purchases.sharedInstance.purchasesOrchestrator.onAppForegrounded()
+        Assertions.assertThat(purchases.purchasesOrchestrator.state.firstTimeInForeground).isFalse
+        verify(exactly = 0) {
+            mockCustomerInfoHelper.retrieveCustomerInfo(
+                appUserId,
+                CacheFetchPolicy.FETCH_CURRENT,
+                false,
+                any()
+            )
+        }
+        verify(exactly = 1) {
+            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
+        }
+    }
+
+    @Test
+    fun `update of caches when app foregrounded not for the first time and caches stale`() {
+        every {
+            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
+        } returns true
+        mockOfferingsManagerAppForeground()
+        purchases.purchasesOrchestrator.state = purchases.purchasesOrchestrator.state.copy(appInBackground = false, firstTimeInForeground = false)
+        Purchases.sharedInstance.purchasesOrchestrator.onAppForegrounded()
+        Assertions.assertThat(purchases.purchasesOrchestrator.state.firstTimeInForeground).isFalse
+        verify(exactly = 1) {
+            mockCustomerInfoHelper.retrieveCustomerInfo(
+                appUserId,
+                CacheFetchPolicy.FETCH_CURRENT,
+                false,
+                any()
+            )
+        }
+        verify(exactly = 1) {
+            mockCache.isCustomerInfoCacheStale(appInBackground = false, appUserID = appUserId)
+        }
+    }
+
+    // endregion
+
+    // region activity lifecycle
+
+    @Test
+    fun `activity on start does not show inapp messages if option disabled`() {
+        resetShowDeclinedPaymentMessagesAutomatically(false)
+        purchases.purchasesOrchestrator.onActivityStarted(mockk())
+        verify(exactly = 0) { mockBillingAbstract.showInAppMessagesIfNeeded(any()) }
+    }
+
+    @Test
+    fun `activity on start shows inapp messages if option enabled`() {
+        resetShowDeclinedPaymentMessagesAutomatically(true)
+        val activity = mockk<Activity>()
+        every { mockBillingAbstract.showInAppMessagesIfNeeded(activity) } just Runs
+        purchases.purchasesOrchestrator.onActivityStarted(activity)
+        verify(exactly = 1) { mockBillingAbstract.showInAppMessagesIfNeeded(activity) }
+    }
+
+    // endregion activity lifecycle
+
+    // region Private
+
+    private fun resetShowDeclinedPaymentMessagesAutomatically(showDeclinedPaymentMessagesAutomatically: Boolean) {
+        purchases.purchasesOrchestrator.appConfig = AppConfig(
+            mockContext,
+            observerMode = false,
+            showDeclinedPaymentMessagesAutomatically = showDeclinedPaymentMessagesAutomatically,
+            PlatformInfo("", null),
+            proxyURL = null,
+            Store.AMAZON
+        )
+    }
+
+    // endregion Private
+}