@namiml/expo-nami-iap 3.4.0-dev.202605060437

package/android/src/test/java/ml/nami/expo/iap/google/PlayBillingBackendTest.kt

@@ -0,0 +1,841 @@
+package ml.nami.expo.iap.google
+
+import android.app.Activity
+import android.content.Context
+import com.android.billingclient.api.AcknowledgePurchaseParams
+import com.android.billingclient.api.BillingClient
+import com.android.billingclient.api.BillingClient.BillingResponseCode
+import com.android.billingclient.api.BillingClient.ProductType
+import com.android.billingclient.api.BillingClientStateListener
+import com.android.billingclient.api.BillingFlowParams
+import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.ConsumeParams
+import com.android.billingclient.api.ProductDetails
+import com.android.billingclient.api.ProductDetailsResult
+import com.android.billingclient.api.Purchase
+import com.android.billingclient.api.PurchasesResult
+import com.android.billingclient.api.PurchasesUpdatedListener
+import com.android.billingclient.api.QueryProductDetailsParams
+import com.android.billingclient.api.QueryPurchasesParams
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.slot
+import io.mockk.verify
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import ml.nami.expo.iap.ExpoNamiIapException
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Before
+import org.junit.Test
+
+class PlayBillingBackendTest {
+    private lateinit var backend: PlayBillingBackend
+    private lateinit var mockContext: Context
+    private lateinit var mockActivity: Activity
+    private lateinit var mockBillingClient: BillingClient
+    private lateinit var mockBuilder: BillingClient.Builder
+    private var capturedPurchasesListener: PurchasesUpdatedListener? = null
+
+    // ── Helpers ─────────────────────────────────────────────────────────
+
+    private fun mockPricingPhase(
+        priceMicros: Long,
+        currency: String = "USD",
+        billingPeriod: String = "P1M",
+        billingCycleCount: Int = 0,
+        recurrenceMode: Int = 1,
+    ): ProductDetails.PricingPhase {
+        val phase = mockk<ProductDetails.PricingPhase>()
+        every { phase.priceAmountMicros } returns priceMicros
+        every { phase.priceCurrencyCode } returns currency
+        every { phase.billingPeriod } returns billingPeriod
+        every { phase.billingCycleCount } returns billingCycleCount
+        every { phase.recurrenceMode } returns recurrenceMode
+        every { phase.formattedPrice } returns "$${priceMicros / 1_000_000.0}"
+        return phase
+    }
+
+    private fun mockPricingPhases(phases: List<ProductDetails.PricingPhase>): ProductDetails.PricingPhases {
+        val pp = mockk<ProductDetails.PricingPhases>()
+        every { pp.pricingPhaseList } returns phases
+        return pp
+    }
+
+    private fun mockSubscriptionOfferDetails(
+        basePlanId: String = "base",
+        offerId: String? = null,
+        phases: List<ProductDetails.PricingPhase>,
+        offerToken: String = "token-$basePlanId-${offerId ?: "base"}",
+    ): ProductDetails.SubscriptionOfferDetails {
+        val sod = mockk<ProductDetails.SubscriptionOfferDetails>()
+        every { sod.basePlanId } returns basePlanId
+        every { sod.offerId } returns offerId
+        every { sod.pricingPhases } returns mockPricingPhases(phases)
+        every { sod.offerTags } returns emptyList()
+        every { sod.offerToken } returns offerToken
+        return sod
+    }
+
+    private fun mockInAppProduct(
+        productId: String = "com.nami.test.consumable",
+        name: String = "100 Coins",
+        description: String = "Pack of 100 coins",
+        priceMicros: Long = 4_990_000L,
+        currency: String = "USD",
+    ): ProductDetails {
+        val otp = mockk<ProductDetails.OneTimePurchaseOfferDetails>()
+        every { otp.priceAmountMicros } returns priceMicros
+        every { otp.priceCurrencyCode } returns currency
+        every { otp.formattedPrice } returns "$${priceMicros / 1_000_000.0}"
+
+        val pd = mockk<ProductDetails>()
+        every { pd.productId } returns productId
+        every { pd.name } returns name
+        every { pd.description } returns description
+        every { pd.productType } returns ProductType.INAPP
+        every { pd.oneTimePurchaseOfferDetails } returns otp
+        every { pd.subscriptionOfferDetails } returns null
+        return pd
+    }
+
+    private fun mockSubscriptionProduct(
+        productId: String = "com.nami.test.monthly",
+        name: String = "Monthly Premium",
+        description: String = "Premium monthly subscription",
+        basePriceMicros: Long = 9_990_000L,
+        currency: String = "USD",
+        billingPeriod: String = "P1M",
+        extraOffers: List<ProductDetails.SubscriptionOfferDetails> = emptyList(),
+    ): ProductDetails {
+        val basePlan =
+            mockSubscriptionOfferDetails(
+                phases =
+                    listOf(
+                        mockPricingPhase(
+                            priceMicros = basePriceMicros,
+                            currency = currency,
+                            billingPeriod = billingPeriod,
+                        ),
+                    ),
+            )
+
+        val pd = mockk<ProductDetails>()
+        every { pd.productId } returns productId
+        every { pd.name } returns name
+        every { pd.description } returns description
+        every { pd.productType } returns ProductType.SUBS
+        every { pd.oneTimePurchaseOfferDetails } returns null
+        every { pd.subscriptionOfferDetails } returns listOf(basePlan) + extraOffers
+        return pd
+    }
+
+    private fun billingResult(code: Int): BillingResult {
+        val br = mockk<BillingResult>()
+        every { br.responseCode } returns code
+        every { br.debugMessage } returns "mock"
+        return br
+    }
+
+    /**
+     * Configure the mock BillingClient so that startConnection immediately
+     * invokes onBillingSetupFinished with the given response code.
+     */
+    private fun stubConnection(responseCode: Int = BillingResponseCode.OK) {
+        val listenerSlot = slot<BillingClientStateListener>()
+        every { mockBillingClient.startConnection(capture(listenerSlot)) } answers {
+            listenerSlot.captured.onBillingSetupFinished(billingResult(responseCode))
+        }
+        every { mockBillingClient.isReady } returns (responseCode == BillingResponseCode.OK)
+    }
+
+    /**
+     * Stub queryProductDetails for a given product type returning the specified products.
+     */
+    private fun stubProductDetailsQuery(products: List<ProductDetails>) {
+        val result = mockk<ProductDetailsResult>()
+        every { result.billingResult } returns billingResult(BillingResponseCode.OK)
+        every { result.productDetailsList } returns products
+
+        coEvery { mockBillingClient.queryProductDetails(any<QueryProductDetailsParams>()) } returns result
+    }
+
+    /**
+     * Stub queryPurchasesAsync for SUBS type returning the specified purchases.
+     */
+    private fun stubPurchasesQuery(purchases: List<Purchase>) {
+        val subsResult = mockk<PurchasesResult>()
+        every { subsResult.billingResult } returns billingResult(BillingResponseCode.OK)
+        every { subsResult.purchasesList } returns purchases
+
+        coEvery {
+            mockBillingClient.queryPurchasesAsync(
+                match<QueryPurchasesParams> { true },
+            )
+        } returns subsResult
+    }
+
+    @Before
+    fun setUp() {
+        mockContext = mockk(relaxed = true)
+        mockActivity = mockk(relaxed = true)
+        mockBillingClient = mockk(relaxed = true)
+        mockBuilder = mockk(relaxed = true)
+
+        val listenerSlot = slot<PurchasesUpdatedListener>()
+        every { mockBuilder.setListener(capture(listenerSlot)) } answers {
+            capturedPurchasesListener = listenerSlot.captured
+            mockBuilder
+        }
+        every { mockBuilder.enablePendingPurchases(any()) } returns mockBuilder
+        every { mockBuilder.build() } returns mockBillingClient
+
+        backend = PlayBillingBackend()
+    }
+
+    /**
+     * Helper: create a mock [Purchase].
+     */
+    private fun mockPurchase(
+        productIds: List<String> = listOf("com.nami.test.product"),
+        orderId: String = "GPA.1234-5678-9012",
+        purchaseToken: String = "test-token",
+        purchaseTime: Long = 1_700_000_000_000L,
+        isAcknowledged: Boolean = false,
+        originalJson: String = """{"orderId":"$orderId"}""",
+    ): Purchase {
+        val purchase = mockk<Purchase>()
+        every { purchase.products } returns productIds
+        every { purchase.orderId } returns orderId
+        every { purchase.purchaseToken } returns purchaseToken
+        every { purchase.purchaseTime } returns purchaseTime
+        every { purchase.isAcknowledged } returns isAcknowledged
+        every { purchase.originalJson } returns originalJson
+        every { purchase.purchaseState } returns Purchase.PurchaseState.PURCHASED
+        return purchase
+    }
+
+    /**
+     * Connect the backend using a testing connection and populate products cache.
+     */
+    private suspend fun connectAndCacheProducts(products: List<ProductDetails>) {
+        stubConnection()
+        stubProductDetailsQuery(products)
+        val connection = PlayBillingConnection(mockContext, mockBuilder)
+        backend.setConnectionForTesting(connection)
+        connection.ensureConnected()
+        val skuIds = products.map { it.productId }
+        backend.getProducts(skuIds)
+    }
+
+    // ── getProducts ────────────────────────────────────────────────────
+
+    @Test
+    fun `getProducts issues SUBS and INAPP queries and combines results`() =
+        runTest {
+            stubConnection()
+
+            val subProduct = mockSubscriptionProduct(productId = "sub-1")
+            val inappProduct = mockInAppProduct(productId = "iap-1")
+
+            // Return both products from the query (the backend queries twice)
+            val subsResult = mockk<ProductDetailsResult>()
+            every { subsResult.billingResult } returns billingResult(BillingResponseCode.OK)
+            every { subsResult.productDetailsList } returns listOf(subProduct)
+
+            val inappResult = mockk<ProductDetailsResult>()
+            every { inappResult.billingResult } returns billingResult(BillingResponseCode.OK)
+            every { inappResult.productDetailsList } returns listOf(inappProduct)
+
+            // Match based on product type in the query params
+            coEvery {
+                mockBillingClient.queryProductDetails(
+                    match<QueryProductDetailsParams> { true },
+                )
+            } returns subsResult andThen inappResult
+
+            val connection = PlayBillingConnection(mockContext, mockBuilder)
+            backend.setConnectionForTesting(connection)
+            connection.ensureConnected()
+
+            val products = backend.getProducts(listOf("sub-1", "iap-1"))
+
+            assertEquals(2, products.size)
+            val productIds = products.map { it["product_ref_id"] }
+            assertTrue("sub-1" in productIds)
+            assertTrue("iap-1" in productIds)
+        }
+
+    @Test
+    fun `getProducts preserves input order`() =
+        runTest {
+            stubConnection()
+
+            val subProduct = mockSubscriptionProduct(productId = "sub-1")
+            val inappProduct = mockInAppProduct(productId = "iap-1")
+
+            val subsResult = mockk<ProductDetailsResult>()
+            every { subsResult.billingResult } returns billingResult(BillingResponseCode.OK)
+            every { subsResult.productDetailsList } returns listOf(subProduct)
+
+            val inappResult = mockk<ProductDetailsResult>()
+            every { inappResult.billingResult } returns billingResult(BillingResponseCode.OK)
+            every { inappResult.productDetailsList } returns listOf(inappProduct)
+
+            coEvery {
+                mockBillingClient.queryProductDetails(any<QueryProductDetailsParams>())
+            } returns subsResult andThen inappResult
+
+            val connection = PlayBillingConnection(mockContext, mockBuilder)
+            backend.setConnectionForTesting(connection)
+            connection.ensureConnected()
+
+            // Request iap-1 first, then sub-1
+            val products = backend.getProducts(listOf("iap-1", "sub-1"))
+
+            assertEquals(2, products.size)
+            assertEquals("iap-1", products[0]["product_ref_id"])
+            assertEquals("sub-1", products[1]["product_ref_id"])
+        }
+
+    @Test
+    fun `getProducts when disconnected auto-retries startConnection`() =
+        runTest {
+            // First call: connection succeeds, but isReady returns false then true
+            val listenerSlot = slot<BillingClientStateListener>()
+            var connectionAttempts = 0
+            every { mockBillingClient.startConnection(capture(listenerSlot)) } answers {
+                connectionAttempts++
+                listenerSlot.captured.onBillingSetupFinished(
+                    billingResult(BillingResponseCode.OK),
+                )
+            }
+            every { mockBillingClient.isReady } returns true
+
+            val subProduct = mockSubscriptionProduct(productId = "sub-1")
+            stubProductDetailsQuery(listOf(subProduct))
+
+            val connection = PlayBillingConnection(mockContext, mockBuilder)
+            backend.setConnectionForTesting(connection)
+            connection.ensureConnected()
+
+            val products = backend.getProducts(listOf("sub-1"))
+            assertTrue(connectionAttempts >= 1)
+            assertEquals(1, products.size)
+        }
+
+    // ── checkEligibility ───────────────────────────────────────────────
+
+    @Test
+    fun `checkEligibility with no prior purchase returns introEligible and promoEligible true`() =
+        runTest {
+            stubConnection()
+            stubPurchasesQuery(emptyList())
+
+            val trialOffer =
+                mockSubscriptionOfferDetails(
+                    offerId = "free-trial-7d",
+                    phases =
+                        listOf(
+                            mockPricingPhase(priceMicros = 0L, billingPeriod = "P1W"),
+                            mockPricingPhase(priceMicros = 9_990_000L, billingPeriod = "P1M"),
+                        ),
+                )
+            val subProduct =
+                mockSubscriptionProduct(
+                    productId = "sub-1",
+                    extraOffers = listOf(trialOffer),
+                )
+            stubProductDetailsQuery(listOf(subProduct))
+
+            val connection = PlayBillingConnection(mockContext, mockBuilder)
+            backend.setConnectionForTesting(connection)
+            connection.ensureConnected()
+
+            // Put the product in the cache by calling getProducts first
+            backend.getProducts(listOf("sub-1"))
+
+            val eligibility = backend.checkEligibility(listOf("sub-1"))
+            assertEquals(1, eligibility.size)
+            assertEquals("sub-1", eligibility[0]["product_ref_id"])
+            assertEquals(true, eligibility[0]["intro_eligible"])
+            assertEquals(true, eligibility[0]["promo_eligible"])
+        }
+
+    @Test
+    fun `checkEligibility after purchase of base plan returns introEligible false`() =
+        runTest {
+            stubConnection()
+
+            // Simulate a purchase of sub-1
+            val mockPurchase = mockk<Purchase>()
+            every { mockPurchase.products } returns listOf("sub-1")
+            every { mockPurchase.purchaseState } returns Purchase.PurchaseState.PURCHASED
+            every { mockPurchase.isAcknowledged } returns true
+            stubPurchasesQuery(listOf(mockPurchase))
+
+            val trialOffer =
+                mockSubscriptionOfferDetails(
+                    offerId = "free-trial-7d",
+                    phases =
+                        listOf(
+                            mockPricingPhase(priceMicros = 0L, billingPeriod = "P1W"),
+                            mockPricingPhase(priceMicros = 9_990_000L, billingPeriod = "P1M"),
+                        ),
+                )
+            val subProduct =
+                mockSubscriptionProduct(
+                    productId = "sub-1",
+                    extraOffers = listOf(trialOffer),
+                )
+            stubProductDetailsQuery(listOf(subProduct))
+
+            val connection = PlayBillingConnection(mockContext, mockBuilder)
+            backend.setConnectionForTesting(connection)
+            connection.ensureConnected()
+
+            // Populate the product cache
+            backend.getProducts(listOf("sub-1"))
+
+            val eligibility = backend.checkEligibility(listOf("sub-1"))
+            assertEquals(1, eligibility.size)
+            assertEquals("sub-1", eligibility[0]["product_ref_id"])
+            assertEquals(false, eligibility[0]["intro_eligible"])
+            assertEquals(false, eligibility[0]["promo_eligible"])
+        }
+
+    // ── onTransactionUpdate / onError ──────────────────────────────────
+
+    @Test
+    fun `onTransactionUpdate stores callback`() {
+        var received: Map<String, Any?>? = null
+        backend.onTransactionUpdate { received = it }
+        // Verify callback was stored (internal check via reflection or indirect test)
+        assertNotNull("Callback should be set", backend)
+    }
+
+    @Test
+    fun `onError stores callback`() {
+        var received: Map<String, Any?>? = null
+        backend.onError { received = it }
+        assertNotNull("Callback should be set", backend)
+    }
+
+    // ── purchase ───────────────────────────────────────────────────────
+
+    @Test
+    fun `purchase calls launchBillingFlow with obfuscatedAccountId`() =
+        runTest {
+            val inappProduct = mockInAppProduct(productId = "iap-1")
+            connectAndCacheProducts(listOf(inappProduct))
+
+            // Stub launchBillingFlow to return OK
+            val flowParamsSlot = slot<BillingFlowParams>()
+            every {
+                mockBillingClient.launchBillingFlow(any<Activity>(), capture(flowParamsSlot))
+            } returns billingResult(BillingResponseCode.OK)
+
+            // Launch the purchase in a separate coroutine so we can simulate the listener
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "iap-1",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = "test-uuid-123",
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Verify launchBillingFlow was called
+            verify { mockBillingClient.launchBillingFlow(mockActivity, any()) }
+
+            // Simulate the listener callback with a successful purchase
+            val purchase = mockPurchase(productIds = listOf("iap-1"))
+            capturedPurchasesListener?.onPurchasesUpdated(
+                billingResult(BillingResponseCode.OK),
+                listOf(purchase),
+            )
+
+            val result = purchaseResult.await()
+            assertEquals("iap-1", result["skuId"])
+            assertEquals("GPA.1234-5678-9012", result["transactionId"])
+            assertNotNull(result["receipt"])
+            assertNotNull(result["purchaseToken"])
+            job.cancel()
+        }
+
+    @Test
+    fun `purchase with offerId selects correct offer token`() =
+        runTest {
+            val trialOffer =
+                mockSubscriptionOfferDetails(
+                    offerId = "promo-offer-1",
+                    phases =
+                        listOf(
+                            mockPricingPhase(priceMicros = 0L, billingPeriod = "P1W"),
+                            mockPricingPhase(priceMicros = 9_990_000L, billingPeriod = "P1M"),
+                        ),
+                    offerToken = "token-promo-offer-1",
+                )
+            val subProduct =
+                mockSubscriptionProduct(
+                    productId = "sub-1",
+                    extraOffers = listOf(trialOffer),
+                )
+            connectAndCacheProducts(listOf(subProduct))
+
+            every {
+                mockBillingClient.launchBillingFlow(any<Activity>(), any())
+            } returns billingResult(BillingResponseCode.OK)
+
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "sub-1",
+                                offerId = "promo-offer-1",
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            verify { mockBillingClient.launchBillingFlow(mockActivity, any()) }
+
+            // Simulate successful purchase callback
+            val purchase = mockPurchase(productIds = listOf("sub-1"))
+            capturedPurchasesListener?.onPurchasesUpdated(
+                billingResult(BillingResponseCode.OK),
+                listOf(purchase),
+            )
+
+            val result = purchaseResult.await()
+            assertEquals("sub-1", result["skuId"])
+            job.cancel()
+        }
+
+    @Test
+    fun `purchase listener OK resolves continuation and fires transactionListener`() =
+        runTest {
+            val inappProduct = mockInAppProduct(productId = "iap-1")
+            connectAndCacheProducts(listOf(inappProduct))
+
+            every {
+                mockBillingClient.launchBillingFlow(any<Activity>(), any())
+            } returns billingResult(BillingResponseCode.OK)
+
+            var transactionCallbackResult: Map<String, Any?>? = null
+            backend.onTransactionUpdate { transactionCallbackResult = it }
+
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "iap-1",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Simulate the listener callback
+            val purchase = mockPurchase(productIds = listOf("iap-1"))
+            capturedPurchasesListener?.onPurchasesUpdated(
+                billingResult(BillingResponseCode.OK),
+                listOf(purchase),
+            )
+
+            val result = purchaseResult.await()
+            assertEquals("iap-1", result["skuId"])
+            assertEquals("test-token", result["purchaseToken"])
+            assertEquals(1_700_000_000_000L, result["purchaseTime"])
+            assertEquals(false, result["isAcknowledged"])
+
+            // Verify transactionListener was also called
+            assertNotNull("transactionListener should have been called", transactionCallbackResult)
+            assertEquals("iap-1", transactionCallbackResult!!["skuId"])
+            job.cancel()
+        }
+
+    @Test
+    fun `purchase listener USER_CANCELED rejects with UserCancelled and fires errorListener`() =
+        runTest {
+            val inappProduct = mockInAppProduct(productId = "iap-1")
+            connectAndCacheProducts(listOf(inappProduct))
+
+            every {
+                mockBillingClient.launchBillingFlow(any<Activity>(), any())
+            } returns billingResult(BillingResponseCode.OK)
+
+            var errorCallbackResult: Map<String, Any?>? = null
+            backend.onError { errorCallbackResult = it }
+
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "iap-1",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Simulate the listener callback with USER_CANCELED
+            capturedPurchasesListener?.onPurchasesUpdated(
+                billingResult(BillingResponseCode.USER_CANCELED),
+                null,
+            )
+
+            try {
+                purchaseResult.await()
+                fail("Expected exception to be thrown")
+            } catch (e: ExpoNamiIapException.UserCancelled) {
+                assertEquals("user_cancelled", e.code)
+            }
+
+            // Verify errorListener was also called
+            assertNotNull("errorListener should have been called", errorCallbackResult)
+            assertEquals("user_cancelled", errorCallbackResult!!["code"])
+            job.cancel()
+        }
+
+    @Test
+    fun `initConnection is idempotent across repeated calls`() =
+        runTest {
+            stubConnection()
+
+            val connection = PlayBillingConnection(mockContext, mockBuilder)
+            backend.setConnectionForTesting(connection)
+
+            // First call
+            connection.ensureConnected()
+            val client1 = connection.billingClient
+
+            // Second call should return immediately (isReady == true)
+            every { mockBillingClient.isReady } returns true
+            val client2 = connection.ensureConnected()
+
+            // Should be the same client instance
+            assertTrue("Should return same client", client1 === client2)
+        }
+
+    // ── finishTransaction ─────────────────────────────────────────────
+
+    @Test
+    fun `finishTransaction on cached subscription calls acknowledgePurchase`() =
+        runTest {
+            val subProduct = mockSubscriptionProduct(productId = "sub-1")
+            connectAndCacheProducts(listOf(subProduct))
+
+            // Stub acknowledgePurchase
+            coEvery {
+                mockBillingClient.acknowledgePurchase(any<AcknowledgePurchaseParams>())
+            } returns billingResult(BillingResponseCode.OK)
+
+            // Simulate a purchase via the listener so the purchase gets cached
+            every {
+                mockBillingClient.launchBillingFlow(any<Activity>(), any())
+            } returns billingResult(BillingResponseCode.OK)
+
+            val purchase =
+                mockPurchase(
+                    productIds = listOf("sub-1"),
+                    purchaseToken = "sub-token-123",
+                )
+
+            val purchaseResult = kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "sub-1",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Fire the PurchasesUpdatedListener to cache the purchase
+            capturedPurchasesListener?.onPurchasesUpdated(
+                billingResult(BillingResponseCode.OK),
+                listOf(purchase),
+            )
+            purchaseResult.await()
+            job.cancel()
+
+            // Now finish the transaction
+            backend.finishTransaction("sub-token-123")
+
+            coVerify {
+                mockBillingClient.acknowledgePurchase(
+                    match<AcknowledgePurchaseParams> {
+                        it.purchaseToken == "sub-token-123"
+                    },
+                )
+            }
+        }
+
+    @Test
+    fun `finishTransaction on cached consumable calls consumePurchase`() =
+        runTest {
+            val inappProduct = mockInAppProduct(productId = "iap-1")
+            connectAndCacheProducts(listOf(inappProduct))
+
+            // Stub consumePurchase — returns a mock ConsumeResult
+            coEvery {
+                mockBillingClient.consumePurchase(any<ConsumeParams>())
+            } returns mockk(relaxed = true)
+
+            // Simulate a purchase via the listener so the purchase gets cached
+            every {
+                mockBillingClient.launchBillingFlow(any<Activity>(), any())
+            } returns billingResult(BillingResponseCode.OK)
+
+            val purchase =
+                mockPurchase(
+                    productIds = listOf("iap-1"),
+                    purchaseToken = "iap-token-456",
+                )
+
+            val purchaseResult = kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "iap-1",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Fire the PurchasesUpdatedListener to cache the purchase
+            capturedPurchasesListener?.onPurchasesUpdated(
+                billingResult(BillingResponseCode.OK),
+                listOf(purchase),
+            )
+            purchaseResult.await()
+            job.cancel()
+
+            // Now finish the transaction
+            backend.finishTransaction("iap-token-456")
+
+            coVerify {
+                mockBillingClient.consumePurchase(
+                    match<ConsumeParams> {
+                        it.purchaseToken == "iap-token-456"
+                    },
+                )
+            }
+        }
+
+    // ── restorePurchases ──────────────────────────────────────────────
+
+    @Test
+    fun `restorePurchases returns mapped results for both SUBS and INAPP`() =
+        runTest {
+            val subProduct = mockSubscriptionProduct(productId = "sub-1")
+            val inappProduct = mockInAppProduct(productId = "iap-1")
+            connectAndCacheProducts(listOf(subProduct, inappProduct))
+
+            val subPurchase =
+                mockPurchase(
+                    productIds = listOf("sub-1"),
+                    orderId = "GPA.sub-order-1",
+                    purchaseToken = "sub-token-1",
+                    purchaseTime = 1_700_000_000_000L,
+                )
+            val inappPurchase =
+                mockPurchase(
+                    productIds = listOf("iap-1"),
+                    orderId = "GPA.iap-order-1",
+                    purchaseToken = "iap-token-1",
+                    purchaseTime = 1_700_000_001_000L,
+                )
+
+            // Stub queryPurchasesAsync to return different results per product type
+            val subsResult = mockk<PurchasesResult>()
+            every { subsResult.billingResult } returns billingResult(BillingResponseCode.OK)
+            every { subsResult.purchasesList } returns listOf(subPurchase)
+
+            val inappResult = mockk<PurchasesResult>()
+            every { inappResult.billingResult } returns billingResult(BillingResponseCode.OK)
+            every { inappResult.purchasesList } returns listOf(inappPurchase)
+
+            coEvery {
+                mockBillingClient.queryPurchasesAsync(
+                    match<QueryPurchasesParams> { true },
+                )
+            } returns subsResult andThen inappResult
+
+            val restored = backend.restorePurchases()
+
+            assertEquals(2, restored.size)
+
+            val subEntry = restored.first { it["skuId"] == "sub-1" }
+            assertEquals("GPA.sub-order-1", subEntry["transactionId"])
+            assertEquals("sub-token-1", subEntry["purchaseToken"])
+            assertEquals(1_700_000_000_000L, subEntry["purchaseTime"])
+
+            val inappEntry = restored.first { it["skuId"] == "iap-1" }
+            assertEquals("GPA.iap-order-1", inappEntry["transactionId"])
+            assertEquals("iap-token-1", inappEntry["purchaseToken"])
+            assertEquals(1_700_000_001_000L, inappEntry["purchaseTime"])
+        }
+}