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

package/android/src/test/amazon/java/ml/nami/expo/iap/amazon/AmazonIapBackendTest.kt

@@ -0,0 +1,974 @@
+package ml.nami.expo.iap.amazon
+
+import android.app.Activity
+import android.content.Context
+import com.amazon.device.iap.PurchasingListener
+import com.amazon.device.iap.PurchasingService
+import com.amazon.device.iap.model.FulfillmentResult
+import com.amazon.device.iap.model.Product
+import com.amazon.device.iap.model.ProductDataResponse
+import com.amazon.device.iap.model.ProductType
+import com.amazon.device.iap.model.PurchaseResponse
+import com.amazon.device.iap.model.PurchaseUpdatesResponse
+import com.amazon.device.iap.model.Receipt
+import com.amazon.device.iap.model.RequestId
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.slot
+import io.mockk.unmockkStatic
+import io.mockk.verify
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import ml.nami.expo.iap.ExpoNamiIapException
+import org.junit.After
+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
+import java.util.Date
+
+class AmazonIapBackendTest {
+    private lateinit var backend: AmazonIapBackend
+    private lateinit var mockContext: Context
+    private lateinit var mockActivity: Activity
+    private var capturedListener: PurchasingListener? = null
+
+    @Before
+    fun setUp() {
+        mockContext = mockk(relaxed = true)
+        mockActivity = mockk(relaxed = true)
+        backend = AmazonIapBackend()
+
+        ExpoNamiIapAmazon.resetForTesting()
+
+        mockkStatic(PurchasingService::class)
+
+        val listenerSlot = slot<PurchasingListener>()
+        every {
+            PurchasingService.registerListener(any(), capture(listenerSlot))
+        } answers {
+            capturedListener = listenerSlot.captured
+        }
+    }
+
+    @After
+    fun tearDown() {
+        unmockkStatic(PurchasingService::class)
+        ExpoNamiIapAmazon.resetForTesting()
+    }
+
+    // ── Helpers ─────────────────────────────────────────────────────────
+
+    private fun mockRequestId(value: String = "req-001"): RequestId {
+        val reqId = mockk<RequestId>()
+        every { reqId.toString() } returns value
+        return reqId
+    }
+
+    private fun mockProduct(
+        sku: String = "com.example.sku",
+        title: String = "Test Product",
+        description: String = "A test product",
+        price: String = "$9.99",
+        productType: ProductType = ProductType.SUBSCRIPTION,
+    ): Product {
+        val product = mockk<Product>()
+        every { product.sku } returns sku
+        every { product.title } returns title
+        every { product.description } returns description
+        every { product.price } returns price
+        every { product.productType } returns productType
+        return product
+    }
+
+    private fun mockProductDataResponse(
+        requestId: RequestId,
+        status: ProductDataResponse.RequestStatus,
+        products: Map<String, Product> = emptyMap(),
+    ): ProductDataResponse {
+        val response = mockk<ProductDataResponse>()
+        every { response.requestId } returns requestId
+        every { response.requestStatus } returns status
+        every { response.productData } returns products
+        every { response.unavailableSkus } returns emptySet()
+        return response
+    }
+
+    private fun mockReceipt(
+        receiptId: String = "receipt-001",
+        sku: String = "sku-a",
+        purchaseDate: Date = Date(1_700_000_000_000L),
+        cancelDate: Date? = null,
+    ): Receipt {
+        val receipt = mockk<Receipt>()
+        every { receipt.receiptId } returns receiptId
+        every { receipt.sku } returns sku
+        every { receipt.purchaseDate } returns purchaseDate
+        every { receipt.cancelDate } returns cancelDate
+        return receipt
+    }
+
+    private fun mockPurchaseResponse(
+        requestId: RequestId,
+        status: PurchaseResponse.RequestStatus,
+        receipt: Receipt? = null,
+    ): PurchaseResponse {
+        val response = mockk<PurchaseResponse>()
+        every { response.requestId } returns requestId
+        every { response.requestStatus } returns status
+        if (receipt != null) {
+            every { response.receipt } returns receipt
+        }
+        return response
+    }
+
+    private fun mockPurchaseUpdatesResponse(
+        requestId: RequestId,
+        status: PurchaseUpdatesResponse.RequestStatus,
+        receipts: List<Receipt> = emptyList(),
+    ): PurchaseUpdatesResponse {
+        val response = mockk<PurchaseUpdatesResponse>()
+        every { response.requestId } returns requestId
+        every { response.requestStatus } returns status
+        every { response.receipts } returns receipts
+        every { response.hasMore() } returns false
+        return response
+    }
+
+    // ── getProducts ────────────────────────────────────────────────────
+
+    @Test
+    fun `getProducts calls PurchasingService getProductData and resolves via listener`() =
+        runTest {
+            val reqId = mockRequestId("req-001")
+            every { PurchasingService.getProductData(any()) } returns reqId
+
+            val product = mockProduct(sku = "sku-a", price = "$9.99")
+
+            // Connect first
+            backend.initConnection(mockContext)
+
+            val resultDeferred = kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(backend.getProducts(listOf("sku-a")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Verify PurchasingService.getProductData was called
+            verify { PurchasingService.getProductData(match { "sku-a" in it }) }
+
+            // Simulate the listener response
+            val response =
+                mockProductDataResponse(
+                    requestId = reqId,
+                    status = ProductDataResponse.RequestStatus.SUCCESSFUL,
+                    products = mapOf("sku-a" to product),
+                )
+            capturedListener?.onProductDataResponse(response)
+
+            val result = resultDeferred.await()
+            assertEquals(1, result.size)
+            assertEquals("sku-a", result[0]["product_ref_id"])
+            assertEquals("Test Product", result[0]["name"])
+            job.cancel()
+        }
+
+    @Test
+    fun `getProducts auto-registers listener if not yet registered`() =
+        runTest {
+            val reqId = mockRequestId("req-002")
+            every { PurchasingService.getProductData(any()) } returns reqId
+
+            val product = mockProduct(sku = "sku-b")
+
+            // Do NOT call initConnection — getProducts should auto-register
+            backend.setContextForTesting(mockContext)
+
+            val resultDeferred = kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(backend.getProducts(listOf("sku-b")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Verify registerListener was called auto-defensively
+            verify { PurchasingService.registerListener(mockContext, any()) }
+
+            // Simulate the listener response
+            val response =
+                mockProductDataResponse(
+                    requestId = reqId,
+                    status = ProductDataResponse.RequestStatus.SUCCESSFUL,
+                    products = mapOf("sku-b" to product),
+                )
+            capturedListener?.onProductDataResponse(response)
+
+            val result = resultDeferred.await()
+            assertEquals(1, result.size)
+            assertEquals("sku-b", result[0]["product_ref_id"])
+            job.cancel()
+        }
+
+    @Test
+    fun `getProducts with FAILED status rejects with exception`() =
+        runTest {
+            val reqId = mockRequestId("req-003")
+            every { PurchasingService.getProductData(any()) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val resultDeferred = kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(backend.getProducts(listOf("sku-c")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Simulate a FAILED response
+            val response =
+                mockProductDataResponse(
+                    requestId = reqId,
+                    status = ProductDataResponse.RequestStatus.FAILED,
+                )
+            capturedListener?.onProductDataResponse(response)
+
+            try {
+                resultDeferred.await()
+                fail("Expected exception to be thrown")
+            } catch (e: ExpoNamiIapException.Unknown) {
+                assertTrue(e.message!!.contains("Product data failed"))
+            }
+            job.cancel()
+        }
+
+    @Test
+    fun `getProducts with NOT_SUPPORTED status rejects with exception`() =
+        runTest {
+            val reqId = mockRequestId("req-004")
+            every { PurchasingService.getProductData(any()) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val resultDeferred = kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(backend.getProducts(listOf("sku-d")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            val response =
+                mockProductDataResponse(
+                    requestId = reqId,
+                    status = ProductDataResponse.RequestStatus.NOT_SUPPORTED,
+                )
+            capturedListener?.onProductDataResponse(response)
+
+            try {
+                resultDeferred.await()
+                fail("Expected exception to be thrown")
+            } catch (e: ExpoNamiIapException.Unknown) {
+                assertTrue(e.message!!.contains("NOT_SUPPORTED"))
+            }
+            job.cancel()
+        }
+
+    // ── Price parsing ──────────────────────────────────────────────────
+
+    @Test
+    fun `price string parsing extracts correct amount`() {
+        val product = mockProduct(sku = "sku-price", price = "$9.99")
+        val mapped = AmazonProductMapper.toMap(product)
+
+        @Suppress("UNCHECKED_CAST")
+        val offers = mapped["offers"] as List<Map<String, Any?>>
+        assertEquals(1, offers.size)
+        assertEquals(9.99, offers[0]["price"] as Double, 0.001)
+    }
+
+    @Test
+    fun `price string with non-USD currency is parsed`() {
+        val product = mockProduct(sku = "sku-eur", price = "EUR 12.49")
+        val mapped = AmazonProductMapper.toMap(product)
+
+        @Suppress("UNCHECKED_CAST")
+        val offers = mapped["offers"] as List<Map<String, Any?>>
+        assertEquals(12.49, offers[0]["price"] as Double, 0.001)
+    }
+
+    @Test
+    fun `price string with comma decimal separator is parsed`() {
+        val product = mockProduct(sku = "sku-comma", price = "9,99 EUR")
+        val mapped = AmazonProductMapper.toMap(product)
+
+        @Suppress("UNCHECKED_CAST")
+        val offers = mapped["offers"] as List<Map<String, Any?>>
+        assertEquals(9.99, offers[0]["price"] as Double, 0.001)
+    }
+
+    // ── Product type mapping ───────────────────────────────────────────
+
+    @Test
+    fun `CONSUMABLE maps to one_time_purchase`() {
+        val product = mockProduct(productType = ProductType.CONSUMABLE)
+        val mapped = AmazonProductMapper.toMap(product)
+        assertEquals("one_time_purchase", mapped["product_type"])
+    }
+
+    @Test
+    fun `ENTITLED maps to one_time_purchase`() {
+        val product = mockProduct(productType = ProductType.ENTITLED)
+        val mapped = AmazonProductMapper.toMap(product)
+        assertEquals("one_time_purchase", mapped["product_type"])
+    }
+
+    @Test
+    fun `SUBSCRIPTION maps to subscription`() {
+        val product = mockProduct(productType = ProductType.SUBSCRIPTION)
+        val mapped = AmazonProductMapper.toMap(product)
+        assertEquals("subscription", mapped["product_type"])
+    }
+
+    // ── Listener callbacks ─────────────────────────────────────────────
+
+    @Test
+    fun `onTransactionUpdate stores callback`() {
+        var received: Map<String, Any?>? = null
+        backend.onTransactionUpdate { received = it }
+        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)
+    }
+
+    // ── initConnection / endConnection ─────────────────────────────────
+
+    @Test
+    fun `initConnection registers listener with PurchasingService`() =
+        runTest {
+            backend.initConnection(mockContext)
+            verify { PurchasingService.registerListener(mockContext, any()) }
+        }
+
+    @Test
+    fun `endConnection clears state`() =
+        runTest {
+            backend.initConnection(mockContext)
+            backend.endConnection()
+            // After endConnection, getProducts should auto-register again
+            // We just verify no exception is thrown by endConnection
+        }
+
+    // ── purchase ───────────────────────────────────────────────────────
+
+    @Test
+    fun `purchase calls PurchasingService purchase and resolves via listener`() =
+        runTest {
+            val reqId = mockRequestId("purchase-req-001")
+            every { PurchasingService.purchase(any<String>()) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val receipt = mockReceipt(receiptId = "rcpt-001", sku = "sku-a")
+            var transactionResult: Map<String, Any?>? = null
+            backend.onTransactionUpdate { transactionResult = it }
+
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "sku-a",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Verify PurchasingService.purchase was called
+            verify { PurchasingService.purchase("sku-a") }
+
+            // Simulate SUCCESSFUL purchase response
+            val response =
+                mockPurchaseResponse(
+                    requestId = reqId,
+                    status = PurchaseResponse.RequestStatus.SUCCESSFUL,
+                    receipt = receipt,
+                )
+            capturedListener?.onPurchaseResponse(response)
+
+            val result = purchaseResult.await()
+            assertEquals("sku-a", result["skuId"])
+            assertEquals("rcpt-001", result["transactionId"])
+            assertEquals("rcpt-001", result["originalTransactionId"])
+            assertEquals("rcpt-001", result["receipt"])
+            assertEquals("rcpt-001", result["purchaseToken"])
+            assertEquals(1_700_000_000_000L, result["purchaseTime"])
+
+            // Verify transactionListener was also called
+            assertNotNull("transactionListener should have been called", transactionResult)
+            assertEquals("sku-a", transactionResult!!["skuId"])
+            job.cancel()
+        }
+
+    @Test
+    fun `purchase FAILED rejects with Unknown and fires errorListener`() =
+        runTest {
+            val reqId = mockRequestId("purchase-req-002")
+            every { PurchasingService.purchase(any<String>()) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            var errorResult: Map<String, Any?>? = null
+            backend.onError { errorResult = it }
+
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "sku-a",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Simulate FAILED purchase response
+            val response =
+                mockPurchaseResponse(
+                    requestId = reqId,
+                    status = PurchaseResponse.RequestStatus.FAILED,
+                )
+            capturedListener?.onPurchaseResponse(response)
+
+            try {
+                purchaseResult.await()
+                fail("Expected exception to be thrown")
+            } catch (e: ExpoNamiIapException.Unknown) {
+                assertEquals("unknown", e.code)
+            }
+
+            // Verify errorListener was also called
+            assertNotNull("errorListener should have been called", errorResult)
+            assertEquals("unknown", errorResult!!["code"])
+            job.cancel()
+        }
+
+    @Test
+    fun `purchase INVALID_SKU rejects with ItemUnavailable`() =
+        runTest {
+            val reqId = mockRequestId("purchase-req-003")
+            every { PurchasingService.purchase(any<String>()) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "bad-sku",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            val response =
+                mockPurchaseResponse(
+                    requestId = reqId,
+                    status = PurchaseResponse.RequestStatus.INVALID_SKU,
+                )
+            capturedListener?.onPurchaseResponse(response)
+
+            try {
+                purchaseResult.await()
+                fail("Expected exception to be thrown")
+            } catch (e: ExpoNamiIapException.ItemUnavailable) {
+                assertEquals("item_unavailable", e.code)
+            }
+            job.cancel()
+        }
+
+    @Test
+    fun `purchase ALREADY_PURCHASED rejects with AlreadyOwned`() =
+        runTest {
+            val reqId = mockRequestId("purchase-req-004")
+            every { PurchasingService.purchase(any<String>()) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "sku-a",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            val response =
+                mockPurchaseResponse(
+                    requestId = reqId,
+                    status = PurchaseResponse.RequestStatus.ALREADY_PURCHASED,
+                )
+            capturedListener?.onPurchaseResponse(response)
+
+            try {
+                purchaseResult.await()
+                fail("Expected exception to be thrown")
+            } catch (e: ExpoNamiIapException.AlreadyOwned) {
+                assertEquals("already_owned", e.code)
+            }
+            job.cancel()
+        }
+
+    @Test
+    fun `purchase NOT_SUPPORTED rejects with NotAllowed`() =
+        runTest {
+            val reqId = mockRequestId("purchase-req-005")
+            every { PurchasingService.purchase(any<String>()) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val purchaseResult =
+                kotlinx.coroutines.CompletableDeferred<Map<String, Any?>>()
+            val job =
+                launch {
+                    try {
+                        purchaseResult.complete(
+                            backend.purchase(
+                                mockActivity,
+                                "sku-a",
+                                offerId = null,
+                                offerSignature = null,
+                                appAccountToken = null,
+                            ),
+                        )
+                    } catch (e: Exception) {
+                        purchaseResult.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            val response =
+                mockPurchaseResponse(
+                    requestId = reqId,
+                    status = PurchaseResponse.RequestStatus.NOT_SUPPORTED,
+                )
+            capturedListener?.onPurchaseResponse(response)
+
+            try {
+                purchaseResult.await()
+                fail("Expected exception to be thrown")
+            } catch (e: ExpoNamiIapException.NotAllowed) {
+                assertEquals("not_allowed", e.code)
+            }
+            job.cancel()
+        }
+
+    // ── restorePurchases ──────────────────────────────────────────────
+
+    @Test
+    fun `restorePurchases calls getPurchaseUpdates and returns mapped receipts`() =
+        runTest {
+            val reqId = mockRequestId("restore-req-001")
+            every { PurchasingService.getPurchaseUpdates(false) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val receipt1 = mockReceipt(receiptId = "rcpt-1", sku = "sku-a")
+            val receipt2 =
+                mockReceipt(
+                    receiptId = "rcpt-2",
+                    sku = "sku-b",
+                    purchaseDate = Date(1_700_000_001_000L),
+                )
+
+            val transactionResults = mutableListOf<Map<String, Any?>>()
+            backend.onTransactionUpdate { transactionResults.add(it) }
+
+            val resultDeferred =
+                kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(backend.restorePurchases())
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Verify getPurchaseUpdates was called
+            verify { PurchasingService.getPurchaseUpdates(false) }
+
+            // Simulate SUCCESSFUL response
+            val response =
+                mockPurchaseUpdatesResponse(
+                    requestId = reqId,
+                    status = PurchaseUpdatesResponse.RequestStatus.SUCCESSFUL,
+                    receipts = listOf(receipt1, receipt2),
+                )
+            capturedListener?.onPurchaseUpdatesResponse(response)
+
+            val result = resultDeferred.await()
+            assertEquals(2, result.size)
+
+            val first = result[0]
+            assertEquals("sku-a", first["skuId"])
+            assertEquals("rcpt-1", first["transactionId"])
+            assertEquals("rcpt-1", first["purchaseToken"])
+            assertEquals(1_700_000_000_000L, first["purchaseTime"])
+
+            val second = result[1]
+            assertEquals("sku-b", second["skuId"])
+            assertEquals("rcpt-2", second["transactionId"])
+            assertEquals(1_700_000_001_000L, second["purchaseTime"])
+
+            // Verify transactionListener was called for each receipt
+            assertEquals(2, transactionResults.size)
+            assertEquals("sku-a", transactionResults[0]["skuId"])
+            assertEquals("sku-b", transactionResults[1]["skuId"])
+            job.cancel()
+        }
+
+    // ── checkEligibility ──────────────────────────────────────────────
+
+    @Test
+    fun `checkEligibility with no existing receipt returns both booleans true`() =
+        runTest {
+            val reqId = mockRequestId("elig-req-001")
+            every { PurchasingService.getPurchaseUpdates(false) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val resultDeferred =
+                kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(backend.checkEligibility(listOf("sku-a")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Simulate empty receipts
+            val response =
+                mockPurchaseUpdatesResponse(
+                    requestId = reqId,
+                    status = PurchaseUpdatesResponse.RequestStatus.SUCCESSFUL,
+                    receipts = emptyList(),
+                )
+            capturedListener?.onPurchaseUpdatesResponse(response)
+
+            val result = resultDeferred.await()
+            assertEquals(1, result.size)
+            assertEquals("sku-a", result[0]["product_ref_id"])
+            assertEquals(true, result[0]["intro_eligible"])
+            assertEquals(true, result[0]["promo_eligible"])
+            job.cancel()
+        }
+
+    @Test
+    fun `checkEligibility with active receipt returns both booleans false`() =
+        runTest {
+            val reqId = mockRequestId("elig-req-002")
+            every { PurchasingService.getPurchaseUpdates(false) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val activeReceipt =
+                mockReceipt(
+                    receiptId = "rcpt-active",
+                    sku = "sku-a",
+                    cancelDate = null,
+                )
+
+            val resultDeferred =
+                kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(backend.checkEligibility(listOf("sku-a")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Simulate receipts with an active subscription for sku-a
+            val response =
+                mockPurchaseUpdatesResponse(
+                    requestId = reqId,
+                    status = PurchaseUpdatesResponse.RequestStatus.SUCCESSFUL,
+                    receipts = listOf(activeReceipt),
+                )
+            capturedListener?.onPurchaseUpdatesResponse(response)
+
+            val result = resultDeferred.await()
+            assertEquals(1, result.size)
+            assertEquals("sku-a", result[0]["product_ref_id"])
+            assertEquals(false, result[0]["intro_eligible"])
+            assertEquals(false, result[0]["promo_eligible"])
+            job.cancel()
+        }
+
+    @Test
+    fun `checkEligibility with cancelled receipt returns both booleans true`() =
+        runTest {
+            val reqId = mockRequestId("elig-req-003")
+            every { PurchasingService.getPurchaseUpdates(false) } returns reqId
+
+            backend.initConnection(mockContext)
+
+            val cancelledReceipt =
+                mockReceipt(
+                    receiptId = "rcpt-cancelled",
+                    sku = "sku-a",
+                    cancelDate = Date(1_700_000_999_000L),
+                )
+
+            val resultDeferred =
+                kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(backend.checkEligibility(listOf("sku-a")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            val response =
+                mockPurchaseUpdatesResponse(
+                    requestId = reqId,
+                    status = PurchaseUpdatesResponse.RequestStatus.SUCCESSFUL,
+                    receipts = listOf(cancelledReceipt),
+                )
+            capturedListener?.onPurchaseUpdatesResponse(response)
+
+            val result = resultDeferred.await()
+            assertEquals(1, result.size)
+            assertEquals("sku-a", result[0]["product_ref_id"])
+            assertEquals(true, result[0]["intro_eligible"])
+            assertEquals(true, result[0]["promo_eligible"])
+            job.cancel()
+        }
+
+    // ── finishTransaction ─────────────────────────────────────────────
+
+    @Test
+    fun `finishTransaction calls notifyFulfillment with FULFILLED`() =
+        runTest {
+            every {
+                PurchasingService.notifyFulfillment(any(), any())
+            } returns Unit
+
+            backend.finishTransaction("rcpt-001")
+
+            verify {
+                PurchasingService.notifyFulfillment("rcpt-001", FulfillmentResult.FULFILLED)
+            }
+        }
+
+    // ── receiptToDict ─────────────────────────────────────────────────
+
+    @Test
+    fun `receiptToDict maps all expected keys`() {
+        val receipt =
+            mockReceipt(
+                receiptId = "rcpt-map-001",
+                sku = "sku-mapped",
+                purchaseDate = Date(1_700_000_500_000L),
+            )
+        val dict = backend.receiptToDict(receipt)
+
+        assertEquals("sku-mapped", dict["skuId"])
+        assertEquals("rcpt-map-001", dict["transactionId"])
+        assertEquals("rcpt-map-001", dict["originalTransactionId"])
+        assertEquals("rcpt-map-001", dict["receipt"])
+        assertEquals("rcpt-map-001", dict["purchaseToken"])
+        assertEquals(1_700_000_500_000L, dict["purchaseTime"])
+    }
+
+    // ── Receiver mode ────────────────────────────────────────────────
+
+    @Test
+    fun `receiver mode - initConnection does NOT call registerListener`() =
+        runTest {
+            ExpoNamiIapAmazon.setAutoRegisterListener(false)
+
+            backend.initConnection(mockContext)
+
+            verify(exactly = 0) { PurchasingService.registerListener(any(), any()) }
+        }
+
+    @Test
+    fun `receiver mode - ExpoNamiIapAmazonReceiver forwards onProductDataResponse`() =
+        runTest {
+            val testDispatcher = StandardTestDispatcher(testScheduler)
+            val testBackend = AmazonIapBackend(scope = CoroutineScope(testDispatcher))
+
+            ExpoNamiIapAmazon.setAutoRegisterListener(false)
+            testBackend.setContextForTesting(mockContext)
+
+            val reqId = mockRequestId("recv-req-001")
+            every { PurchasingService.getProductData(any()) } returns reqId
+
+            val product = mockProduct(sku = "sku-recv", price = "$4.99")
+
+            val resultDeferred =
+                kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(testBackend.getProducts(listOf("sku-recv")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Verify registerListener was NOT called
+            verify(exactly = 0) { PurchasingService.registerListener(any(), any()) }
+
+            // Host app forwards the response via the receiver
+            val response =
+                mockProductDataResponse(
+                    requestId = reqId,
+                    status = ProductDataResponse.RequestStatus.SUCCESSFUL,
+                    products = mapOf("sku-recv" to product),
+                )
+            ExpoNamiIapAmazonReceiver.onProductDataResponse(response)
+
+            val result = resultDeferred.await()
+            assertEquals(1, result.size)
+            assertEquals("sku-recv", result[0]["product_ref_id"])
+            job.cancel()
+        }
+
+    @Test
+    fun `receiver mode - pending request times out after 30s with diagnostic error`() =
+        runTest {
+            val testDispatcher = StandardTestDispatcher(testScheduler)
+            val testBackend = AmazonIapBackend(scope = CoroutineScope(testDispatcher))
+
+            ExpoNamiIapAmazon.setAutoRegisterListener(false)
+            testBackend.setContextForTesting(mockContext)
+
+            val reqId = mockRequestId("recv-timeout-001")
+            every { PurchasingService.getProductData(any()) } returns reqId
+
+            val resultDeferred =
+                kotlinx.coroutines.CompletableDeferred<List<Map<String, Any?>>>()
+            val job =
+                launch {
+                    try {
+                        resultDeferred.complete(testBackend.getProducts(listOf("sku-timeout")))
+                    } catch (e: Exception) {
+                        resultDeferred.completeExceptionally(e)
+                    }
+                }
+            advanceUntilIdle()
+
+            // Advance time past the 30s timeout
+            advanceTimeBy(AmazonIapBackend.TIMEOUT_MS + 1)
+            advanceUntilIdle()
+
+            try {
+                resultDeferred.await()
+                fail("Expected timeout exception to be thrown")
+            } catch (e: ExpoNamiIapException.Unknown) {
+                assertTrue(
+                    "Timeout message should mention receiver mode",
+                    e.message!!.contains("receiver mode"),
+                )
+                assertTrue(
+                    "Timeout message should mention ExpoNamiIapAmazonReceiver",
+                    e.message!!.contains("ExpoNamiIapAmazonReceiver"),
+                )
+            }
+            job.cancel()
+        }
+
+    @Test
+    fun `auto mode regression - initConnection registers listener as before`() =
+        runTest {
+            // autoRegister is true by default (reset in setUp)
+            assertTrue(
+                "autoRegisterEnabled should default to true",
+                ExpoNamiIapAmazon.autoRegisterEnabled(),
+            )
+
+            backend.initConnection(mockContext)
+
+            verify(exactly = 1) { PurchasingService.registerListener(mockContext, any()) }
+        }
+}