react-native-iap 8.1.3 → 8.2.2

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.13.1'
+  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/amazon/java/com/dooboolab/RNIap/RNIapAmazonModule.kt

@@ -2,6 +2,7 @@ package com.dooboolab.RNIap
 
 import com.amazon.device.iap.PurchasingService
 import com.amazon.device.iap.model.FulfillmentResult
+import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
@@ -10,9 +11,8 @@ import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.WritableNativeArray
 import java.util.HashSet
 
-class RNIapAmazonModule(reactContext: ReactApplicationContext?) :
+class RNIapAmazonModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
-    val TAG = "RNIapAmazonModule"
     override fun getName(): String {
         return TAG
     }
@@ -127,5 +127,23 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext?) :
         const val PROMISE_QUERY_PURCHASES = "PROMISE_QUERY_PURCHASES"
         const val PROMISE_QUERY_AVAILABLE_ITEMS = "PROMISE_QUERY_AVAILABLE_ITEMS"
         const val PROMISE_GET_USER_DATA = "PROMISE_GET_USER_DATA"
+
+        const val TAG = "RNIapAmazonModule"
+    }
+    init {
+        val lifecycleEventListener: LifecycleEventListener = object : LifecycleEventListener {
+            /**
+             * From https://developer.amazon.com/docs/in-app-purchasing/iap-implement-iap.html#getpurchaseupdates-responses
+             * We should fetch updates on resume
+             */
+            override fun onHostResume() {
+                PurchasingService.getUserData()
+                PurchasingService.getPurchaseUpdates(false)
+            }
+            override fun onHostPause() {}
+            override fun onHostDestroy() {
+            }
+        }
+        reactContext.addLifecycleEventListener(lifecycleEventListener)
     }
 }

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

@@ -7,7 +7,7 @@ import com.facebook.react.bridge.Promise
 class PlayUtils {
     fun rejectPromiseWithBillingError(promise: Promise, responseCode: Int) {
         val errorData = getBillingResponseData(responseCode)
-        promise.reject(errorData[0], errorData[1])
+        promise.safeReject(errorData[0], errorData[1])
     }
 
     fun getBillingResponseData(responseCode: Int): Array<String?> {
@@ -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/PromiseUtlis.kt

@@ -0,0 +1,33 @@
+package com.dooboolab.RNIap
+
+import android.util.Log
+import com.facebook.react.bridge.ObjectAlreadyConsumedException
+import com.facebook.react.bridge.Promise
+
+/**
+ * Extension functions used to simplify promise handling since we don't
+ * want to crash in the case of it being resolved/rejected more than once
+ */
+
+fun Promise.safeResolve(value: Any) {
+    try {
+        this.resolve(value)
+    } catch (oce: ObjectAlreadyConsumedException) {
+        Log.d(RNIapModule.TAG, "Already consumed ${oce.message}")
+    }
+}
+
+fun Promise.safeReject(message: String) = this.safeReject(message, null, null)
+
+fun Promise.safeReject(code: String?, message: String?) = this.safeReject(code, message, null)
+
+fun Promise.safeReject(code: String?, throwable: Throwable?) =
+    this.safeReject(code, null, throwable)
+
+fun Promise.safeReject(code: String?, message: String?, throwable: Throwable?) {
+    try {
+        this.reject(code, message, throwable)
+    } catch (oce: ObjectAlreadyConsumedException) {
+        Log.d(RNIapModule.TAG, "Already consumed ${oce.message}")
+    }
+}

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

@@ -15,7 +15,6 @@ import com.android.billingclient.api.SkuDetails
 import com.android.billingclient.api.SkuDetailsParams
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
-import com.facebook.react.bridge.ObjectAlreadyConsumedException
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.PromiseImpl
 import com.facebook.react.bridge.ReactApplicationContext
@@ -32,18 +31,21 @@ 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"
+        return TAG
     }
 
-    private fun ensureConnection(promise: Promise, callback: () -> Unit) {
+    internal fun ensureConnection(promise: Promise, callback: () -> Unit) {
         if (billingClient.isReady) {
             callback()
             return
@@ -58,7 +60,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                 },
                 {
                     if (it.size > 1 && it[0] is String && it[1] is String) {
-                        promise.reject(
+                        promise.safeReject(
                             it[0] as String, it[1] as String
                         )
                     } else {
@@ -77,31 +79,25 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                 TAG,
                 "Already initialized, you should only call initConnection() once when your app starts"
             )
-            promise.resolve(true)
+            promise.safeResolve(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")
-            promise.reject(DoobooUtils.E_NOT_PREPARED, "Google Play Services are not available on this device")
+            promise.safeReject(DoobooUtils.E_NOT_PREPARED, "Google Play Services are not available on this device")
             return
         }
 
+        billingClient = builder.setListener(this).build()
+
         billingClient.startConnection(
             object : BillingClientStateListener {
                 override fun onBillingSetupFinished(billingResult: BillingResult) {
-                    val responseCode = billingResult.responseCode
-                    try {
-                        if (responseCode == BillingClient.BillingResponseCode.OK) {
-                            promise.resolve(true)
-                        } else {
-                            PlayUtils.instance
-                                .rejectPromiseWithBillingError(promise, responseCode)
-                        }
-                    } catch (oce: ObjectAlreadyConsumedException) {
-                        Log.e(TAG, oce.message!!)
-                    }
+                    if (!isValidResult(billingResult, promise)) return
+
+                    promise.safeResolve(true)
                 }
 
                 override fun onBillingServiceDisconnected() {
@@ -113,7 +109,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
     @ReactMethod
     fun endConnection(promise: Promise) {
         billingClient.endConnection()
-        promise.resolve(true)
+        promise.safeResolve(true)
     }
 
     private fun consumeItems(
@@ -138,11 +134,8 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                                 )
                             return@ConsumeResponseListener
                         }
-                        try {
-                            promise.resolve(true)
-                        } catch (oce: ObjectAlreadyConsumedException) {
-                            promise.reject(oce.message)
-                        }
+
+                        promise.safeResolve(true)
                     }
                 billingClient.consumeAsync(consumeParams, listener)
             }
@@ -154,26 +147,21 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
         ensureConnection(
             promise
         ) {
-            val array = WritableNativeArray()
             billingClient.queryPurchasesAsync(
                 BillingClient.SkuType.INAPP
-            ) { _: BillingResult?, list: List<Purchase>? ->
+            ) { billingResult: BillingResult, list: List<Purchase>? ->
+                if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
                 if (list == null) {
                     // No purchases found
-                    promise.resolve(false)
+                    promise.safeResolve(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) {
-                    promise.resolve(false)
+                // 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.safeResolve(false)
                     return@queryPurchasesAsync
                 }
                 consumeItems(
@@ -186,7 +174,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun getItemsByType(type: String?, skuArr: ReadableArray, promise: Promise) {
+    fun getItemsByType(type: String, skuArr: ReadableArray, promise: Promise) {
         ensureConnection(
             promise
         ) {
@@ -198,22 +186,18 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                 }
             }
             val params = SkuDetailsParams.newBuilder()
-            params.setSkusList(skuList).setType(type!!)
+            params.setSkusList(skuList).setType(type)
             billingClient.querySkuDetailsAsync(
                 params.build()
             ) { billingResult: BillingResult, skuDetailsList: List<SkuDetails>? ->
-                Log.d(TAG, "responseCode: " + billingResult.responseCode)
-                if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                    PlayUtils.instance
-                        .rejectPromiseWithBillingError(promise, billingResult.responseCode)
-                    return@querySkuDetailsAsync
-                }
+                if (!isValidResult(billingResult, promise)) return@querySkuDetailsAsync
+
                 if (skuDetailsList != null) {
                     for (sku in skuDetailsList) {
                         skus[sku.sku] = sku
                     }
                 }
-                val items = WritableNativeArray()
+                val items = Arguments.createArray()
                 for (skuDetails in skuDetailsList!!) {
                     val item = Arguments.createMap()
                     item.putString("productId", skuDetails.sku)
@@ -263,15 +247,27 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                     item.putString("originalPrice", originalPrice)
                     items.pushMap(item)
                 }
-                try {
-                    promise.resolve(items)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    Log.e(TAG, oce.message!!)
-                }
+                promise.safeResolve(items)
             }
         }
     }
 
+    /**
+     * Rejects promise with billing code if BillingResult is not OK
+     */
+    private fun isValidResult(
+        billingResult: BillingResult,
+        promise: Promise
+    ): Boolean {
+        Log.d(TAG, "responseCode: " + billingResult.responseCode)
+        if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
+            PlayUtils.instance
+                .rejectPromiseWithBillingError(promise, billingResult.responseCode)
+            return false
+        }
+        return true
+    }
+
     @ReactMethod
     fun getAvailableItemsByType(type: String, promise: Promise) {
         ensureConnection(
@@ -280,7 +276,8 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
             val items = WritableNativeArray()
             billingClient.queryPurchasesAsync(
                 if (type == "subs") BillingClient.SkuType.SUBS else BillingClient.SkuType.INAPP
-            ) { billingResult: BillingResult?, purchases: List<Purchase>? ->
+            ) { billingResult: BillingResult, purchases: List<Purchase>? ->
+                if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
                 if (purchases != null) {
                     for (i in purchases.indices) {
                         val purchase = purchases[i]
@@ -310,11 +307,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                         items.pushMap(item)
                     }
                 }
-                try {
-                    promise.resolve(items)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    Log.e(TAG, oce.message!!)
-                }
+                promise.safeResolve(items)
             }
         }
     }
@@ -327,16 +320,12 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
             billingClient.queryPurchaseHistoryAsync(
                 if (type == "subs") BillingClient.SkuType.SUBS else BillingClient.SkuType.INAPP
             ) { billingResult, purchaseHistoryRecordList ->
-                if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                    PlayUtils.instance
-                        .rejectPromiseWithBillingError(promise, billingResult.responseCode)
-                    return@queryPurchaseHistoryAsync
-                }
+                if (!isValidResult(billingResult, promise)) return@queryPurchaseHistoryAsync
+
                 Log.d(TAG, purchaseHistoryRecordList.toString())
                 val items = Arguments.createArray()
-                for (i in purchaseHistoryRecordList!!.indices) {
+                purchaseHistoryRecordList?.forEach { purchase ->
                     val item = Arguments.createMap()
-                    val purchase = purchaseHistoryRecordList[i]
                     item.putString("productId", purchase.skus[0])
                     item.putDouble("transactionDate", purchase.purchaseTime.toDouble())
                     item.putString("transactionReceipt", purchase.originalJson)
@@ -346,11 +335,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                     item.putString("developerPayload", purchase.developerPayload)
                     items.pushMap(item)
                 }
-                try {
-                    promise.resolve(items)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    Log.e(TAG, oce.message!!)
-                }
+                promise.safeResolve(items)
             }
         }
     }
@@ -367,7 +352,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
     ) {
         val activity = currentActivity
         if (activity == null) {
-            promise.reject(DoobooUtils.E_UNKNOWN, "getCurrentActivity returned null")
+            promise.safeReject(DoobooUtils.E_UNKNOWN, "getCurrentActivity returned null")
             return
         }
         ensureConnection(
@@ -387,7 +372,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                 error.putString("message", debugMessage)
                 error.putString("productId", sku)
                 sendEvent(reactContext, "purchase-error", error)
-                promise.reject(PROMISE_BUY_ITEM, debugMessage)
+                promise.safeReject(PROMISE_BUY_ITEM, debugMessage)
                 return@ensureConnection
             }
             builder.setSkuDetails(selectedSku)
@@ -420,7 +405,7 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
                         error.putString("message", debugMessage)
                         error.putString("productId", sku)
                         sendEvent(reactContext, "purchase-error", error)
-                        promise.reject(PROMISE_BUY_ITEM, debugMessage)
+                        promise.safeReject(PROMISE_BUY_ITEM, debugMessage)
                         return@ensureConnection
                     }
                 } else if (prorationMode
@@ -457,8 +442,14 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
             }
             val flowParams = builder.build()
             val billingResult = billingClient.launchBillingFlow(activity, flowParams)
-            val errorData: Array<String?> =
-                PlayUtils.instance.getBillingResponseData(billingResult.responseCode)
+            if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
+                promise.safeResolve(true)
+                return@ensureConnection
+            } else {
+                val errorData: Array<String?> =
+                    PlayUtils.instance.getBillingResponseData(billingResult.responseCode)
+                promise.safeReject(errorData[0], errorData[1])
+            }
         }
     }
 
@@ -478,22 +469,16 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
             billingClient.acknowledgePurchase(
                 acknowledgePurchaseParams
             ) { billingResult: BillingResult ->
-                if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                    PlayUtils.instance
-                        .rejectPromiseWithBillingError(promise, billingResult.responseCode)
-                }
-                try {
-                    val map = Arguments.createMap()
-                    map.putInt("responseCode", billingResult.responseCode)
-                    map.putString("debugMessage", billingResult.debugMessage)
-                    val errorData: Array<String?> = PlayUtils.instance
-                        .getBillingResponseData(billingResult.responseCode)
-                    map.putString("code", errorData[0])
-                    map.putString("message", errorData[1])
-                    promise.resolve(map)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    Log.e(TAG, oce.message!!)
-                }
+                if (!isValidResult(billingResult, promise)) return@acknowledgePurchase
+
+                val map = Arguments.createMap()
+                map.putInt("responseCode", billingResult.responseCode)
+                map.putString("debugMessage", billingResult.debugMessage)
+                val errorData: Array<String?> = PlayUtils.instance
+                    .getBillingResponseData(billingResult.responseCode)
+                map.putString("code", errorData[0])
+                map.putString("message", errorData[1])
+                promise.safeResolve(map)
             }
         }
     }
@@ -511,22 +496,16 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
             billingClient.consumeAsync(
                 params
             ) { billingResult: BillingResult, purchaseToken: String? ->
-                if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                    PlayUtils.instance
-                        .rejectPromiseWithBillingError(promise, billingResult.responseCode)
-                }
-                try {
-                    val map = Arguments.createMap()
-                    map.putInt("responseCode", billingResult.responseCode)
-                    map.putString("debugMessage", billingResult.debugMessage)
-                    val errorData: Array<String?> = PlayUtils.instance
-                        .getBillingResponseData(billingResult.responseCode)
-                    map.putString("code", errorData[0])
-                    map.putString("message", errorData[1])
-                    promise.resolve(map)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    promise.reject(oce.message)
-                }
+                if (!isValidResult(billingResult, promise)) return@consumeAsync
+
+                val map = Arguments.createMap()
+                map.putInt("responseCode", billingResult.responseCode)
+                map.putString("debugMessage", billingResult.debugMessage)
+                val errorData: Array<String?> = PlayUtils.instance
+                    .getBillingResponseData(billingResult.responseCode)
+                map.putString("code", errorData[0])
+                map.putString("message", errorData[1])
+                promise.safeResolve(map)
             }
         }
     }
@@ -602,18 +581,14 @@ class RNIapModule(private val reactContext: ReactApplicationContext) :
             for (type in types) {
                 billingClient.queryPurchasesAsync(
                     type
-                ) { billingResult: BillingResult, list: List<Purchase>? ->
-                    val unacknowledgedPurchases = ArrayList<Purchase>()
+                ) { billingResult: BillingResult, list: List<Purchase> ->
+                    if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
 
-                    for (purchase in list!!) {
-                        if (!purchase.isAcknowledged) {
-                            unacknowledgedPurchases.add(purchase)
-                        }
-                    }
+                    val unacknowledgedPurchases = list.filter { !it.isAcknowledged }
                     onPurchasesUpdated(billingResult, unacknowledgedPurchases)
                 }
             }
-            promise.resolve(true)
+            promise.safeResolve(true)
         }
     }
 

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

@@ -0,0 +1,263 @@
+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.ConsumeResponseListener
+import com.android.billingclient.api.Purchase
+import com.android.billingclient.api.PurchasesResponseListener
+import com.android.billingclient.api.SkuDetailsResponseListener
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+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.just
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.runs
+import io.mockk.slot
+import io.mockk.verify
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+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.safeReject(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.safeReject(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 `flushFailedPurchasesCachedAsPending resolves to true if 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(
+                    // 4 = Pending
+                    mockk<Purchase> {
+                        every { purchaseState } returns 2
+                        every { purchaseToken } returns "token"
+                    },
+                    Purchase("", "1")
+                )
+            )
+        }
+        val consumeListener = slot<ConsumeResponseListener>()
+        every { billingClient.consumeAsync(any(), capture(consumeListener)) } answers {
+            consumeListener.captured.onConsumeResponse(
+                BillingResult.newBuilder()
+                    .setResponseCode(BillingClient.BillingResponseCode.ITEM_NOT_OWNED).build(),
+                ""
+            )
+        }
+
+        module.flushFailedPurchasesCachedAsPending(promise)
+
+        verify(exactly = 0) { promise.reject(any(), any<String>()) }
+        verify { promise.resolve(true) } // at least one pending transactions
+    }
+
+    @Test
+    fun `ensureConnection should attempt to reconnect, if not in ready state`() {
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
+        val promise = mockk<Promise>(relaxed = true)
+        var isCallbackCalled = false
+        val callback = {
+            isCallbackCalled = true
+            promise.resolve(true)
+        }
+
+        every { billingClient.isReady } returns false andThen true
+        module.ensureConnection(promise, callback)
+        verify { promise.resolve(true) } // at least one pending transactions
+        assertTrue("Should call callback", isCallbackCalled)
+    }
+
+    @Test
+    fun getItemsByType() {
+        every { billingClient.isReady } returns true
+        val promise = mockk<Promise>(relaxed = true)
+        val listener = slot<SkuDetailsResponseListener>()
+        every { billingClient.querySkuDetailsAsync(any(), capture(listener)) } answers {
+            listener.captured.onSkuDetailsResponse(
+                BillingResult.newBuilder().build(),
+                listOf(
+                    mockk {
+                        every { sku } returns "sku1"
+                        every { introductoryPriceAmountMicros } returns 0
+                        every { priceAmountMicros } returns 1
+                        every { priceCurrencyCode } returns "USD"
+                        every { type } returns "sub"
+                        every { price } returns "$10.0"
+                        every { title } returns "My product"
+                        every { description } returns "My desc"
+                        every { introductoryPrice } returns "$5.0"
+                        every { zzc() } returns "com.mypackage"
+                        every { originalPrice } returns "$13.0"
+                        every { subscriptionPeriod } returns "3 months"
+                        every { freeTrialPeriod } returns "1 week"
+                        every { introductoryPriceCycles } returns 1
+                        every { introductoryPricePeriod } returns "1"
+                        every { iconUrl } returns "http://myicon.com/icon"
+                        every { originalJson } returns "{}"
+                        every { originalPriceAmountMicros } returns 2
+                    }
+                )
+            )
+        }
+        val skus = mockk<ReadableArray>() {
+            every { size() } returns 1
+            every { getString(0) } returns "sku0"
+        }
+        mockkStatic(Arguments::class)
+
+        val itemsMap = mockk<WritableMap>()
+        val itemsArr = mockk<WritableArray>()
+        every { Arguments.createMap() } returns itemsMap
+        every { Arguments.createArray() } returns itemsArr
+        every { itemsMap.putString(any(), any()) } just runs
+        var itemsSize = 0
+        every { itemsArr.pushMap(any()) } answers {
+            itemsSize++
+        }
+
+        module.getItemsByType("subs", skus, promise)
+        verify { promise.resolve(any()) }
+        assertEquals(itemsSize, 1)
+    }
+
+    @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.2",
   "packageManager": "yarn@3.2.0",
   "description": "React Native In App Purchase Module.",
   "main": "index.js",