react-native-iap 8.1.3 → 8.2.0

package/android/build.gradle

@@ -50,6 +50,9 @@ android {
       dimension "store"
     }
   }
+  testOptions {
+    unitTests.returnDefaultValues = true
+  }
 }
 
 repositories {
@@ -63,6 +66,8 @@ repositories {
 
 dependencies {
   implementation 'com.facebook.react:react-native:+'
+  testImplementation 'junit:junit:4.12'
+  testImplementation "io.mockk:mockk:1.12.4"
   playImplementation 'com.android.billingclient:billing:4.0.0'
   def playServicesVersion = safeExtGet('playServicesVersion', DEFAULT_PLAY_SERVICES_VERSION)
   playImplementation "com.google.android.gms:play-services-base:$playServicesVersion"

package/android/src/play/java/com/dooboolab/RNIap/PlayUtils.kt

@@ -49,7 +49,7 @@ class PlayUtils {
             }
             BillingClient.BillingResponseCode.ERROR -> {
                 errorData[0] = DoobooUtils.E_UNKNOWN
-                errorData[1] = "An unknown or unexpected error has occured. Please try again later."
+                errorData[1] = "An unknown or unexpected error has occurred. Please try again later."
             }
             BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED -> {
                 errorData[0] = DoobooUtils.E_ALREADY_OWNED

package/android/src/play/java/com/dooboolab/RNIap/RNIapModule.kt

@@ -32,12 +32,15 @@ import com.google.android.gms.common.GoogleApiAvailability
 import java.math.BigDecimal
 import java.util.ArrayList
 
-class RNIapModule(private val reactContext: ReactApplicationContext) :
+class RNIapModule(
+    private val reactContext: ReactApplicationContext,
+    private val builder: BillingClient.Builder = BillingClient.newBuilder(reactContext).enablePendingPurchases(),
+    private val googleApiAvailability: GoogleApiAvailability = GoogleApiAvailability.getInstance()
+) :
     ReactContextBaseJavaModule(reactContext),
     PurchasesUpdatedListener {
 
-    private val billingClient: BillingClient = BillingClient.newBuilder(reactContext).enablePendingPurchases().setListener(this)
-        .build()
+    private var billingClient: BillingClient = builder.setListener(this).build()
     private val skus: MutableMap<String, SkuDetails> = mutableMapOf()
     override fun getName(): String {
         return "RNIapModule"
@@ -80,7 +83,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
             promise.resolve(true)
             return
         }
-        if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(reactContext)
+        if (googleApiAvailability.isGooglePlayServicesAvailable(reactContext)
             != ConnectionResult.SUCCESS
         ) {
             Log.i(TAG, "Google Play Services are not available on this device")
@@ -88,6 +91,8 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
             return
         }
 
+        billingClient = builder.setListener(this).build()
+
         billingClient.startConnection(
             object : BillingClientStateListener {
                 override fun onBillingSetupFinished(billingResult: BillingResult) {
@@ -154,7 +159,6 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
         ensureConnection(
             promise
         ) {
-            val array = WritableNativeArray()
             billingClient.queryPurchasesAsync(
                 BillingClient.SkuType.INAPP
             ) { _: BillingResult?, list: List<Purchase>? ->
@@ -163,16 +167,11 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                     promise.resolve(false)
                     return@queryPurchasesAsync
                 }
-                val pendingPurchases: MutableList<Purchase> = ArrayList()
-                for (purchase in list) {
-                    // we only want to try to consume PENDING items, in order to force cache-refresh
-                    // for
-                    // them
-                    if (purchase.purchaseState == Purchase.PurchaseState.PENDING) {
-                        pendingPurchases.add(purchase)
-                    }
-                }
-                if (pendingPurchases.size == 0) {
+                // we only want to try to consume PENDING items, in order to force cache-refresh
+                // for  them
+                val pendingPurchases = list.filter { it.purchaseState == Purchase.PurchaseState.PENDING }
+
+                if (pendingPurchases.isEmpty()) {
                     promise.resolve(false)
                     return@queryPurchasesAsync
                 }

package/android/src/testPlay/java/com/dooboolab/RNIap/RNIapModuleTest.kt

@@ -0,0 +1,144 @@
+package com.dooboolab.RNIap
+
+import com.android.billingclient.api.BillingClient
+import com.android.billingclient.api.BillingClientStateListener
+import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.PurchasesResponseListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import io.mockk.MockKAnnotations
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.mockk
+import io.mockk.slot
+import io.mockk.verify
+import org.junit.Before
+import org.junit.Test
+
+class RNIapModuleTest {
+
+    @MockK
+    lateinit var context: ReactApplicationContext
+    @MockK
+    lateinit var builder: BillingClient.Builder
+    @MockK
+    lateinit var billingClient: BillingClient
+    @MockK
+    lateinit var availability: GoogleApiAvailability
+
+    private lateinit var module: RNIapModule
+
+    @Before
+    fun setUp() {
+        MockKAnnotations.init(this, relaxUnitFun = true)
+        every { builder.setListener(any()) } returns builder
+        every { builder.build() } returns billingClient
+        module = RNIapModule(context, builder, availability)
+    }
+
+    @Test
+    fun `initConnection Already connected should resolve to true`() {
+        every { billingClient.isReady } returns true
+        val promise = mockk<Promise>(relaxed = true)
+
+        module.initConnection(promise)
+        verify(exactly = 0) { promise.reject(any(), any<String>()) }
+        verify { promise.resolve(true) }
+    }
+
+    @Test
+    fun `initConnection Play Services not available on device should reject`() {
+        every { billingClient.isReady } returns false
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.DEVELOPER_ERROR
+        val promise = mockk<Promise>(relaxed = true)
+
+        module.initConnection(promise)
+        verify { promise.reject(any(), any<String>()) }
+        verify(exactly = 0) { promise.resolve(any()) }
+    }
+
+    @Test
+    fun `initConnection start new connection succeeds`() {
+        every { billingClient.isReady } returns false
+        val listener = slot<BillingClientStateListener>()
+        every { billingClient.startConnection(capture(listener)) } answers {
+            listener.captured.onBillingSetupFinished(BillingResult.newBuilder().setResponseCode(BillingClient.BillingResponseCode.OK).build())
+        }
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
+        val promise = mockk<Promise>(relaxed = true)
+
+        module.initConnection(promise)
+        verify(exactly = 0) { promise.reject(any(), any<String>()) }
+        verify { promise.resolve(any()) }
+    }
+
+    @Test
+    fun `initConnection start new connection fails`() {
+        every { billingClient.isReady } returns false
+        val listener = slot<BillingClientStateListener>()
+        every { billingClient.startConnection(capture(listener)) } answers {
+            listener.captured.onBillingSetupFinished(BillingResult.newBuilder().setResponseCode(BillingClient.BillingResponseCode.ERROR).build())
+        }
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
+        val promise = mockk<Promise>(relaxed = true)
+
+        module.initConnection(promise)
+        verify { promise.reject(any(), any<String>()) }
+        verify(exactly = 0) { promise.resolve(any()) }
+    }
+
+    @Test
+    fun `endConnection resolves`() {
+        val promise = mockk<Promise>(relaxed = true)
+
+        module.endConnection(promise)
+
+        verify { billingClient.endConnection() }
+        verify(exactly = 0) { promise.reject(any(), any<String>()) }
+        verify { promise.resolve(true) }
+    }
+
+    @Test
+    fun `flushFailedPurchasesCachedAsPending resolves to false if no pending purchases`() {
+        every { billingClient.isReady } returns true
+        val promise = mockk<Promise>(relaxed = true)
+        val listener = slot<PurchasesResponseListener>()
+        every { billingClient.queryPurchasesAsync(any(), capture(listener)) } answers {
+            listener.captured.onQueryPurchasesResponse(BillingResult.newBuilder().build(), listOf())
+        }
+        module.flushFailedPurchasesCachedAsPending(promise)
+
+        verify(exactly = 0) { promise.reject(any(), any<String>()) }
+        verify { promise.resolve(false) } // empty list
+    }
+
+    @Test
+    fun getItemsByType() {
+    }
+
+    @Test
+    fun getAvailableItemsByType() {
+    }
+
+    @Test
+    fun getPurchaseHistoryByType() {
+    }
+
+    @Test
+    fun buyItemByType() {
+    }
+
+    @Test
+    fun acknowledgePurchase() {
+    }
+
+    @Test
+    fun consumeProduct() {
+    }
+
+    @Test
+    fun onPurchasesUpdated() {
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-iap",
-  "version": "8.1.3",
+  "version": "8.2.0",
   "packageManager": "yarn@3.2.0",
   "description": "React Native In App Purchase Module.",
   "main": "index.js",