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

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

@@ -0,0 +1,184 @@
+package ml.nami.expo.iap
+
+import com.android.billingclient.api.BillingClient.BillingResponseCode
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ErrorsTest {
+    // ── billingResponseToCode ───────────────────────────────────────────
+
+    @Test
+    fun `USER_CANCELED maps to user_cancelled`() {
+        assertEquals("user_cancelled", Errors.billingResponseToCode(BillingResponseCode.USER_CANCELED))
+    }
+
+    @Test
+    fun `SERVICE_DISCONNECTED maps to network`() {
+        assertEquals("network", Errors.billingResponseToCode(BillingResponseCode.SERVICE_DISCONNECTED))
+    }
+
+    @Test
+    fun `SERVICE_UNAVAILABLE maps to network`() {
+        assertEquals("network", Errors.billingResponseToCode(BillingResponseCode.SERVICE_UNAVAILABLE))
+    }
+
+    @Test
+    fun `ITEM_UNAVAILABLE maps to item_unavailable`() {
+        assertEquals("item_unavailable", Errors.billingResponseToCode(BillingResponseCode.ITEM_UNAVAILABLE))
+    }
+
+    @Test
+    fun `ITEM_ALREADY_OWNED maps to already_owned`() {
+        assertEquals("already_owned", Errors.billingResponseToCode(BillingResponseCode.ITEM_ALREADY_OWNED))
+    }
+
+    @Test
+    fun `FEATURE_NOT_SUPPORTED maps to not_allowed`() {
+        assertEquals("not_allowed", Errors.billingResponseToCode(BillingResponseCode.FEATURE_NOT_SUPPORTED))
+    }
+
+    @Test
+    fun `DEVELOPER_ERROR maps to not_allowed`() {
+        assertEquals("not_allowed", Errors.billingResponseToCode(BillingResponseCode.DEVELOPER_ERROR))
+    }
+
+    @Test
+    fun `BILLING_UNAVAILABLE maps to not_allowed`() {
+        assertEquals("not_allowed", Errors.billingResponseToCode(BillingResponseCode.BILLING_UNAVAILABLE))
+    }
+
+    @Test
+    fun `ERROR maps to unknown`() {
+        assertEquals("unknown", Errors.billingResponseToCode(BillingResponseCode.ERROR))
+    }
+
+    @Test
+    fun `ITEM_NOT_OWNED maps to unknown`() {
+        assertEquals("unknown", Errors.billingResponseToCode(BillingResponseCode.ITEM_NOT_OWNED))
+    }
+
+    @Test
+    fun `unrecognized code maps to unknown`() {
+        assertEquals("unknown", Errors.billingResponseToCode(9999))
+    }
+
+    // ── billingResponseToNativeCode ─────────────────────────────────────
+
+    @Test
+    fun `USER_CANCELED native code is USER_CANCELED`() {
+        assertEquals("USER_CANCELED", Errors.billingResponseToNativeCode(BillingResponseCode.USER_CANCELED))
+    }
+
+    @Test
+    fun `ITEM_UNAVAILABLE native code is ITEM_UNAVAILABLE`() {
+        assertEquals("ITEM_UNAVAILABLE", Errors.billingResponseToNativeCode(BillingResponseCode.ITEM_UNAVAILABLE))
+    }
+
+    @Test
+    fun `SERVICE_DISCONNECTED native code is SERVICE_DISCONNECTED`() {
+        assertEquals(
+            "SERVICE_DISCONNECTED",
+            Errors.billingResponseToNativeCode(BillingResponseCode.SERVICE_DISCONNECTED),
+        )
+    }
+
+    @Test
+    fun `OK native code is OK`() {
+        assertEquals("OK", Errors.billingResponseToNativeCode(BillingResponseCode.OK))
+    }
+
+    @Test
+    fun `NETWORK_ERROR native code is NETWORK_ERROR`() {
+        assertEquals("NETWORK_ERROR", Errors.billingResponseToNativeCode(BillingResponseCode.NETWORK_ERROR))
+    }
+
+    @Test
+    fun `unrecognized code returns UNKNOWN(code)`() {
+        assertEquals("UNKNOWN(9999)", Errors.billingResponseToNativeCode(9999))
+    }
+
+    // ── toException ─────────────────────────────────────────────────────
+
+    @Test
+    fun `toException USER_CANCELED returns UserCancelled`() {
+        val ex = Errors.toException(BillingResponseCode.USER_CANCELED)
+        assertTrue(ex is ExpoNamiIapException.UserCancelled)
+        assertEquals("user_cancelled", ex.code)
+        assertEquals("USER_CANCELED", ex.nativeCode)
+    }
+
+    @Test
+    fun `toException SERVICE_DISCONNECTED returns Network`() {
+        val ex = Errors.toException(BillingResponseCode.SERVICE_DISCONNECTED, "Service lost")
+        assertTrue(ex is ExpoNamiIapException.Network)
+        assertEquals("network", ex.code)
+        assertEquals("Service lost", ex.message)
+    }
+
+    @Test
+    fun `toException ITEM_UNAVAILABLE returns ItemUnavailable`() {
+        val ex = Errors.toException(BillingResponseCode.ITEM_UNAVAILABLE)
+        assertTrue(ex is ExpoNamiIapException.ItemUnavailable)
+        assertEquals("item_unavailable", ex.code)
+    }
+
+    @Test
+    fun `toException ITEM_ALREADY_OWNED returns AlreadyOwned`() {
+        val ex = Errors.toException(BillingResponseCode.ITEM_ALREADY_OWNED)
+        assertTrue(ex is ExpoNamiIapException.AlreadyOwned)
+        assertEquals("already_owned", ex.code)
+    }
+
+    @Test
+    fun `toException DEVELOPER_ERROR returns NotAllowed`() {
+        val ex = Errors.toException(BillingResponseCode.DEVELOPER_ERROR)
+        assertTrue(ex is ExpoNamiIapException.NotAllowed)
+        assertEquals("not_allowed", ex.code)
+    }
+
+    @Test
+    fun `toException ERROR returns Unknown`() {
+        val ex = Errors.toException(BillingResponseCode.ERROR, "Fatal error")
+        assertTrue(ex is ExpoNamiIapException.Unknown)
+        assertEquals("unknown", ex.code)
+        assertEquals("Fatal error", ex.message)
+    }
+
+    // ── Complete BillingResponseCode coverage ───────────────────────────
+
+    @Test
+    fun `all known BillingResponseCode values are mapped`() {
+        val allCodes =
+            listOf(
+                BillingResponseCode.SERVICE_TIMEOUT,
+                BillingResponseCode.FEATURE_NOT_SUPPORTED,
+                BillingResponseCode.SERVICE_DISCONNECTED,
+                BillingResponseCode.OK,
+                BillingResponseCode.USER_CANCELED,
+                BillingResponseCode.SERVICE_UNAVAILABLE,
+                BillingResponseCode.BILLING_UNAVAILABLE,
+                BillingResponseCode.ITEM_UNAVAILABLE,
+                BillingResponseCode.DEVELOPER_ERROR,
+                BillingResponseCode.ERROR,
+                BillingResponseCode.ITEM_ALREADY_OWNED,
+                BillingResponseCode.ITEM_NOT_OWNED,
+                BillingResponseCode.NETWORK_ERROR,
+            )
+        for (code in allCodes) {
+            val normalized = Errors.billingResponseToCode(code)
+            assertTrue(
+                "Code $code should map to a known normalized value, got: $normalized",
+                normalized in
+                    setOf(
+                        "user_cancelled",
+                        "network",
+                        "item_unavailable",
+                        "already_owned",
+                        "not_allowed",
+                        "unknown",
+                    ),
+            )
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+package ml.nami.expo.iap
+
+import ml.nami.expo.iap.google.PlayBillingBackend
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Smoke tests for [ExpoNamiIapModule] backend resolution logic.
+ *
+ * These tests verify the classpath-based backend selection without
+ * instantiating the full Expo Module (which requires the Expo runtime).
+ * Under the `google` flavor PlayBillingBackend is on the classpath,
+ * so [buildBackend] must resolve to it.
+ */
+class ExpoNamiIapModuleTest {
+    /**
+     * Verify that [PlayBillingBackend] is discoverable on the classpath
+     * via the same Class.forName call used by [ExpoNamiIapModule.buildBackend].
+     */
+    @Test
+    fun `buildBackend resolves PlayBillingBackend under google flavor`() {
+        val cls = Class.forName("ml.nami.expo.iap.google.PlayBillingBackend")
+        assertNotNull("PlayBillingBackend class should be on the classpath", cls)
+
+        val instance = cls.getDeclaredConstructor().newInstance()
+        assertTrue(
+            "Resolved backend should be an IapBackend",
+            instance is IapBackend,
+        )
+        assertEquals(
+            "Resolved backend should be PlayBillingBackend",
+            PlayBillingBackend::class.java,
+            instance::class.java,
+        )
+    }
+
+    /**
+     * Verify that the Google flavor classpath does NOT contain AmazonIapBackend,
+     * confirming that the flavor-based resolution logic would fall through to
+     * the Google path first.
+     */
+    @Test
+    fun `google flavor prefers PlayBillingBackend over AmazonIapBackend`() {
+        // PlayBillingBackend should be found first (no ClassNotFoundException)
+        val googleCls =
+            try {
+                Class.forName("ml.nami.expo.iap.google.PlayBillingBackend")
+            } catch (_: ClassNotFoundException) {
+                null
+            }
+        assertNotNull("PlayBillingBackend should be on the classpath", googleCls)
+
+        // Replicate the buildBackend resolution logic
+        val resolvedCls =
+            try {
+                Class.forName("ml.nami.expo.iap.google.PlayBillingBackend")
+            } catch (_: ClassNotFoundException) {
+                Class.forName("ml.nami.expo.iap.amazon.AmazonIapBackend")
+            }
+        val backend = resolvedCls.getDeclaredConstructor().newInstance() as IapBackend
+        assertTrue(
+            "Resolved backend should be PlayBillingBackend",
+            backend is PlayBillingBackend,
+        )
+    }
+
+    /**
+     * Verify that [PlayBillingBackend] correctly implements callback
+     * registration methods from [IapBackend].
+     */
+    @Test
+    fun `PlayBillingBackend supports onTransactionUpdate and onError callbacks`() {
+        val backend = PlayBillingBackend()
+        var transactionReceived = false
+        var errorReceived = false
+
+        backend.onTransactionUpdate { transactionReceived = true }
+        backend.onError { errorReceived = true }
+
+        // Callbacks are stored; they will be invoked by PurchasesUpdatedListener
+        // This test verifies no exception is thrown during registration
+        assertNotNull("Backend should be non-null after callback registration", backend)
+    }
+}

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

@@ -0,0 +1,8 @@
+package ml.nami.expo.iap
+
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PlaceholderTest {
+    @Test fun `scaffold compiles`() = assertTrue(true)
+}

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

@@ -0,0 +1,335 @@
+package ml.nami.expo.iap
+
+import com.android.billingclient.api.BillingClient.ProductType
+import com.android.billingclient.api.ProductDetails
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class ProductMapperTest {
+    // ── Helpers ─────────────────────────────────────────────────────────
+
+    private fun mockOneTimePurchaseOfferDetails(
+        priceMicros: Long = 4_990_000L,
+        currency: String = "USD",
+        formattedPrice: String = "$4.99",
+    ): ProductDetails.OneTimePurchaseOfferDetails {
+        val otp = mockk<ProductDetails.OneTimePurchaseOfferDetails>()
+        every { otp.priceAmountMicros } returns priceMicros
+        every { otp.priceCurrencyCode } returns currency
+        every { otp.formattedPrice } returns formattedPrice
+        return otp
+    }
+
+    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>,
+        offerTags: List<String> = emptyList(),
+        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 offerTags
+        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 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
+            mockOneTimePurchaseOfferDetails(
+                priceMicros = priceMicros,
+                currency = currency,
+            )
+        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
+    }
+
+    // ── Consumable / INAPP ──────────────────────────────────────────────
+
+    @Test
+    fun `consumable maps to one_time_purchase with default offer`() {
+        val pd = mockInAppProduct()
+        val result = ProductMapper.toMap(pd)
+
+        assertEquals("com.nami.test.consumable", result["product_ref_id"])
+        assertEquals("one_time_purchase", result["product_type"])
+        assertEquals("100 Coins", result["name"])
+        assertEquals("Pack of 100 coins", result["description"])
+        assertNull("Consumable must not have subscription_period", result["subscription_period"])
+
+        @Suppress("UNCHECKED_CAST")
+        val offers = result["offers"] as List<Map<String, Any?>>
+        assertEquals(1, offers.size)
+        assertEquals("default", offers[0]["offer_type"])
+        assertEquals(4.99, offers[0]["price"] as Double, 0.001)
+        assertEquals("USD", offers[0]["currency"])
+    }
+
+    // ── Subscription with single base plan (monthly, $9.99) ─────────────
+
+    @Test
+    fun `subscription with monthly base plan maps correctly`() {
+        val pd = mockSubscriptionProduct()
+        val result = ProductMapper.toMap(pd)
+
+        assertEquals("com.nami.test.monthly", result["product_ref_id"])
+        assertEquals("subscription", result["product_type"])
+
+        @Suppress("UNCHECKED_CAST")
+        val period = result["subscription_period"] as Map<String, Any>
+        assertEquals("month", period["type"])
+        assertEquals(1, period["count"])
+
+        @Suppress("UNCHECKED_CAST")
+        val offers = result["offers"] as List<Map<String, Any?>>
+        val defaultOffer = offers.first { it["offer_type"] == "default" }
+        assertEquals(9.99, defaultOffer["price"] as Double, 0.001)
+        assertEquals("USD", defaultOffer["currency"])
+    }
+
+    // ── Subscription with free-trial offer ──────────────────────────────
+
+    @Test
+    fun `subscription with free trial offer appends free_trial`() {
+        val trialOffer =
+            mockSubscriptionOfferDetails(
+                offerId = "free-trial-7d",
+                phases =
+                    listOf(
+                        mockPricingPhase(priceMicros = 0L, billingPeriod = "P1W"),
+                        mockPricingPhase(priceMicros = 9_990_000L, billingPeriod = "P1M"),
+                    ),
+            )
+
+        val pd =
+            mockSubscriptionProduct(
+                extraOffers = listOf(trialOffer),
+            )
+        val result = ProductMapper.toMap(pd)
+
+        @Suppress("UNCHECKED_CAST")
+        val offers = result["offers"] as List<Map<String, Any?>>
+        val freeTrialOffer = offers.firstOrNull { it["offer_type"] == "free_trial" }
+        assertNotNull("Should have a free_trial offer", freeTrialOffer)
+        assertEquals(0.0, freeTrialOffer!!["price"] as Double, 0.001)
+        assertEquals("free-trial-7d", freeTrialOffer["offer_ref_id"])
+
+        @Suppress("UNCHECKED_CAST")
+        val promoPeriod = freeTrialOffer["promo_period"] as Map<String, Any>
+        assertEquals("week", promoPeriod["type"])
+        assertEquals(1, promoPeriod["count"])
+    }
+
+    // ── Subscription with intro price offer ─────────────────────────────
+
+    @Test
+    fun `subscription with intro price offer appends intro`() {
+        val introOffer =
+            mockSubscriptionOfferDetails(
+                offerId = "intro-monthly",
+                phases =
+                    listOf(
+                        mockPricingPhase(priceMicros = 4_990_000L, billingPeriod = "P1M", billingCycleCount = 3),
+                        mockPricingPhase(priceMicros = 9_990_000L, billingPeriod = "P1M"),
+                    ),
+            )
+
+        val pd =
+            mockSubscriptionProduct(
+                extraOffers = listOf(introOffer),
+            )
+        val result = ProductMapper.toMap(pd)
+
+        @Suppress("UNCHECKED_CAST")
+        val offers = result["offers"] as List<Map<String, Any?>>
+        val introOfferResult = offers.firstOrNull { it["offer_type"] == "intro" }
+        assertNotNull("Should have an intro offer", introOfferResult)
+        assertEquals(4.99, introOfferResult!!["price"] as Double, 0.001)
+        assertEquals("intro-monthly", introOfferResult["offer_ref_id"])
+
+        @Suppress("UNCHECKED_CAST")
+        val promoPeriod = introOfferResult["promo_period"] as Map<String, Any>
+        assertEquals("month", promoPeriod["type"])
+        assertEquals(1, promoPeriod["count"])
+
+        @Suppress("UNCHECKED_CAST")
+        val promoPrice = introOfferResult["promo_price"] as Map<String, Any>
+        assertEquals(4.99, promoPrice["price"] as Double, 0.001)
+        assertEquals("USD", promoPrice["currency"])
+    }
+
+    // ── Period parsing ──────────────────────────────────────────────────
+
+    @Test
+    fun `P1D parses to day 1`() {
+        val p = ProductMapper.parsePeriod("P1D")
+        assertEquals("day", p["type"])
+        assertEquals(1, p["count"])
+    }
+
+    @Test
+    fun `P1W parses to week 1`() {
+        val p = ProductMapper.parsePeriod("P1W")
+        assertEquals("week", p["type"])
+        assertEquals(1, p["count"])
+    }
+
+    @Test
+    fun `P1M parses to month 1`() {
+        val p = ProductMapper.parsePeriod("P1M")
+        assertEquals("month", p["type"])
+        assertEquals(1, p["count"])
+    }
+
+    @Test
+    fun `P3M parses to month 3`() {
+        val p = ProductMapper.parsePeriod("P3M")
+        assertEquals("month", p["type"])
+        assertEquals(3, p["count"])
+    }
+
+    @Test
+    fun `P1Y parses to year 1`() {
+        val p = ProductMapper.parsePeriod("P1Y")
+        assertEquals("year", p["type"])
+        assertEquals(1, p["count"])
+    }
+
+    @Test
+    fun `invalid period falls back to unknown 0`() {
+        val p = ProductMapper.parsePeriod("INVALID")
+        assertEquals("unknown", p["type"])
+        assertEquals(0, p["count"])
+    }
+
+    // ── All required keys present ───────────────────────────────────────
+
+    @Test
+    fun `subscription result contains all required NamiProductDetails keys`() {
+        val pd = mockSubscriptionProduct()
+        val result = ProductMapper.toMap(pd)
+
+        assertNotNull(result["product_ref_id"])
+        assertNotNull(result["product_type"])
+        assertNotNull(result["offers"])
+        assertNotNull(result["name"])
+        assertNotNull(result["description"])
+        assertNotNull(result["subscription_period"])
+    }
+
+    @Test
+    fun `consumable has exactly one default offer`() {
+        val pd = mockInAppProduct()
+        val result = ProductMapper.toMap(pd)
+
+        @Suppress("UNCHECKED_CAST")
+        val offers = result["offers"] as List<Map<String, Any?>>
+        assertEquals(1, offers.size)
+        assertEquals("default", offers[0]["offer_type"])
+    }
+
+    // ── Yearly subscription ─────────────────────────────────────────────
+
+    @Test
+    fun `yearly subscription has correct period`() {
+        val pd =
+            mockSubscriptionProduct(
+                productId = "com.nami.test.yearly",
+                billingPeriod = "P1Y",
+            )
+        val result = ProductMapper.toMap(pd)
+
+        @Suppress("UNCHECKED_CAST")
+        val period = result["subscription_period"] as Map<String, Any>
+        assertEquals("year", period["type"])
+        assertEquals(1, period["count"])
+    }
+
+    // ── Weekly subscription ─────────────────────────────────────────────
+
+    @Test
+    fun `weekly subscription has correct period`() {
+        val pd =
+            mockSubscriptionProduct(
+                productId = "com.nami.test.weekly",
+                billingPeriod = "P1W",
+            )
+        val result = ProductMapper.toMap(pd)
+
+        @Suppress("UNCHECKED_CAST")
+        val period = result["subscription_period"] as Map<String, Any>
+        assertEquals("week", period["type"])
+        assertEquals(1, period["count"])
+    }
+}