@stripe/stripe-react-native 0.57.1 → 0.57.3

package/android/src/test/java/com/reactnativestripesdk/DrawableConversionPropertyTest.kt

@@ -0,0 +1,224 @@
+package com.reactnativestripesdk
+
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import kotlin.random.Random
+
+/**
+ * Property-based tests for drawable conversion.
+ * These tests verify mathematical properties that should always hold true.
+ */
+@RunWith(RobolectricTestRunner::class)
+class DrawableConversionPropertyTest {
+  @Test
+  fun `PROPERTY - conversion is idempotent`() =
+    runTest {
+      // Property: Converting the same drawable multiple times yields same result
+      repeat(20) {
+        val color =
+          Color.rgb(
+            Random.nextInt(256),
+            Random.nextInt(256),
+            Random.nextInt(256),
+          )
+        val width = Random.nextInt(50, 200)
+        val height = Random.nextInt(50, 200)
+
+        val drawable =
+          ColorDrawable(color).apply {
+            setBounds(0, 0, width, height)
+          }
+
+        val result1 = convertDrawableToBase64(drawable)
+        val result2 = convertDrawableToBase64(drawable)
+
+        assertEquals(
+          "Same drawable should always produce same base64 (iteration $it, ${width}x$height)",
+          result1,
+          result2,
+        )
+      }
+    }
+
+  @Test
+  fun `PROPERTY - different drawables produce different base64`() =
+    runTest {
+      val drawable1 =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 100, 100)
+        }
+      val drawable2 =
+        ColorDrawable(Color.BLUE).apply {
+          setBounds(0, 0, 100, 100)
+        }
+
+      val result1 = convertDrawableToBase64(drawable1)
+      val result2 = convertDrawableToBase64(drawable2)
+
+      assertNotEquals(
+        "Different colored drawables should produce different base64",
+        result1,
+        result2,
+      )
+    }
+
+  @Test
+  fun `PROPERTY - base64 length scales with drawable size`() =
+    runTest {
+      val small =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 50, 50)
+        }
+      val medium =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 100, 100)
+        }
+      val large =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 200, 200)
+        }
+
+      val smallResult = convertDrawableToBase64(small)
+      val mediumResult = convertDrawableToBase64(medium)
+      val largeResult = convertDrawableToBase64(large)
+
+      assertNotNull(smallResult)
+      assertNotNull(mediumResult)
+      assertNotNull(largeResult)
+
+      assertTrue(
+        "Medium drawable should produce longer base64 than small",
+        mediumResult!!.length > smallResult!!.length,
+      )
+      assertTrue(
+        "Large drawable should produce longer base64 than medium",
+        largeResult!!.length > mediumResult.length,
+      )
+    }
+
+  @Test
+  fun `PROPERTY - conversion preserves drawable dimensions`() =
+    runTest {
+      val testSizes =
+        listOf(
+          Pair(50, 50),
+          Pair(100, 75),
+          Pair(147, 105), // Typical card icon
+          Pair(200, 150),
+          Pair(250, 200),
+        )
+
+      testSizes.forEach { (width, height) ->
+        val drawable =
+          ColorDrawable(Color.GREEN).apply {
+            setBounds(0, 0, width, height)
+          }
+
+        val bitmap = getBitmapFromDrawable(drawable)
+
+        assertNotNull("Bitmap should not be null for ${width}x$height", bitmap)
+        assertEquals("Width should be preserved for ${width}x$height", width, bitmap!!.width)
+        assertEquals("Height should be preserved for ${width}x$height", height, bitmap.height)
+      }
+    }
+
+  @Test
+  fun `PROPERTY - null input produces null output consistently`() =
+    runTest {
+      // Invalid drawables (no bounds set) should consistently return null
+      val invalidDrawable1 = ColorDrawable(Color.RED)
+      val invalidDrawable2 = ColorDrawable(Color.BLUE)
+
+      val result1 = convertDrawableToBase64(invalidDrawable1)
+      val result2 = convertDrawableToBase64(invalidDrawable2)
+
+      assertNotNull("Result1 should be null for invalid drawable", result1 == null)
+      assertNotNull("Result2 should be null for invalid drawable", result2 == null)
+    }
+
+  @Test
+  fun `PROPERTY - aspect ratio is preserved in bitmap`() {
+    val testCases =
+      listOf(
+        Triple(100, 100, 1.0), // Square
+        Triple(200, 100, 2.0), // 2:1
+        Triple(147, 105, 1.4), // Card icon ratio
+        Triple(100, 200, 0.5), // Portrait
+      )
+
+    testCases.forEach { (width, height, expectedRatio) ->
+      val drawable =
+        ColorDrawable(Color.YELLOW).apply {
+          setBounds(0, 0, width, height)
+        }
+
+      val bitmap = getBitmapFromDrawable(drawable)
+
+      assertNotNull(bitmap)
+      val actualRatio = bitmap!!.width.toDouble() / bitmap.height.toDouble()
+      assertEquals(
+        "Aspect ratio should be preserved for ${width}x$height",
+        expectedRatio,
+        actualRatio,
+        0.01, // Allow small floating point error
+      )
+    }
+  }
+
+  @Test
+  fun `PROPERTY - conversion is deterministic across multiple runs`() =
+    runTest {
+      // Same drawable, converted multiple times in sequence, should always yield same result
+      val drawable =
+        ColorDrawable(Color.CYAN).apply {
+          setBounds(0, 0, 120, 90)
+        }
+
+      val results = (1..15).map { convertDrawableToBase64(drawable) }
+
+      // All results should be identical
+      val firstResult = results.first()
+      results.forEach { result ->
+        assertEquals("All conversions should be identical", firstResult, result)
+      }
+    }
+
+  @Test
+  fun `PROPERTY - different sizes with same color produce different base64`() =
+    runTest {
+      val color = Color.rgb(100, 150, 200)
+
+      val sizes =
+        listOf(
+          Pair(50, 50),
+          Pair(75, 75),
+          Pair(100, 100),
+          Pair(125, 125),
+        )
+
+      val results =
+        sizes.map { (width, height) ->
+          val drawable =
+            ColorDrawable(color).apply {
+              setBounds(0, 0, width, height)
+            }
+          convertDrawableToBase64(drawable)
+        }
+
+      // All results should be different (different sizes → different images)
+      val uniqueResults = results.toSet()
+      assertEquals(
+        "Different sizes should produce different base64 even with same color",
+        results.size,
+        uniqueResults.size,
+      )
+    }
+}

package/android/src/test/java/com/reactnativestripesdk/DrawableConversionTest.kt

@@ -0,0 +1,146 @@
+package com.reactnativestripesdk
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class DrawableConversionTest {
+  // ============================================
+  // convertDrawableToBase64 Tests
+  // ============================================
+
+  @Test
+  fun `convertDrawableToBase64 returns non-null for valid drawable`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 100, 100)
+        }
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNotNull("Base64 should not be null for valid drawable", result)
+      assertTrue("Base64 should not be empty", result!!.isNotEmpty())
+    }
+
+  @Test
+  fun `convertDrawableToBase64 returns consistent results for same drawable`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.BLUE).apply {
+          setBounds(0, 0, 100, 100)
+        }
+
+      val result1 = convertDrawableToBase64(drawable)
+      val result2 = convertDrawableToBase64(drawable)
+      val result3 = convertDrawableToBase64(drawable)
+
+      assertEquals("Multiple calls should return identical base64", result1, result2)
+      assertEquals("Multiple calls should return identical base64", result2, result3)
+    }
+
+  @Test
+  fun `convertDrawableToBase64 returns null for invalid drawable`() =
+    runTest {
+      // Drawable with 0 intrinsic size (never set bounds)
+      val drawable = ColorDrawable(Color.RED)
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNull("Base64 should be null for invalid drawable", result)
+    }
+
+  @Test
+  fun `convertDrawableToBase64 result is valid base64 format`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.GREEN).apply {
+          setBounds(0, 0, 50, 50)
+        }
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNotNull(result)
+      // Valid base64 should match pattern: [A-Za-z0-9+/=]+
+      assertTrue(
+        "Result should be valid base64",
+        result!!.matches(Regex("^[A-Za-z0-9+/=\\n]+$")),
+      )
+    }
+
+  @Test
+  fun `convertDrawableToBase64 result size is reasonable`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.YELLOW).apply {
+          setBounds(0, 0, 100, 100)
+        }
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNotNull(result)
+      // Should be larger than tiny placeholder (134 bytes)
+      // but smaller than unreasonably large
+      assertTrue(
+        "Base64 should be larger than 200 chars (not a 1x1 placeholder)",
+        result!!.length > 200,
+      )
+      assertTrue(
+        "Base64 should be smaller than 100KB",
+        result.length < 100_000,
+      )
+    }
+
+  // ============================================
+  // getBitmapFromDrawable Tests
+  // ============================================
+
+  @Test
+  fun `getBitmapFromDrawable returns correct size bitmap`() {
+    val drawable =
+      ColorDrawable(Color.CYAN).apply {
+        setBounds(0, 0, 150, 100)
+      }
+
+    val bitmap = getBitmapFromDrawable(drawable)
+
+    assertNotNull("Bitmap should not be null", bitmap)
+    assertEquals("Bitmap width should match drawable", 150, bitmap!!.width)
+    assertEquals("Bitmap height should match drawable", 100, bitmap.height)
+    assertEquals("Bitmap should use ARGB_8888", Bitmap.Config.ARGB_8888, bitmap.config)
+  }
+
+  @Test
+  fun `getBitmapFromDrawable returns null for zero-size drawable`() {
+    val drawable = ColorDrawable(Color.MAGENTA)
+    // Don't set bounds, intrinsic size will be -1
+
+    val bitmap = getBitmapFromDrawable(drawable)
+
+    assertNull("Bitmap should be null for invalid drawable", bitmap)
+  }
+
+  @Test
+  fun `getBitmapFromDrawable preserves drawable dimensions`() {
+    // Test with typical card icon dimensions
+    val drawable =
+      ColorDrawable(Color.RED).apply {
+        setBounds(0, 0, 147, 105)
+      }
+
+    val bitmap = getBitmapFromDrawable(drawable)
+
+    assertNotNull(bitmap)
+    assertEquals("Width should be preserved", 147, bitmap!!.width)
+    assertEquals("Height should be preserved", 105, bitmap.height)
+  }
+}

package/android/src/test/java/com/reactnativestripesdk/DrawableLoadingTest.kt

@@ -0,0 +1,150 @@
+package com.reactnativestripesdk
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.PixelFormat
+import android.graphics.drawable.Drawable
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class DrawableLoadingTest {
+  /**
+   * Mock drawable that simulates DelegateDrawable's async loading behavior
+   */
+  class MockAsyncDrawable : Drawable() {
+    private var loaded = false
+    private var width = 1
+    private var height = 1
+
+    override fun getIntrinsicWidth(): Int = width
+
+    override fun getIntrinsicHeight(): Int = height
+
+    suspend fun simulateLoading(delayMs: Long = 100) {
+      delay(delayMs)
+      width = 150
+      height = 100
+      loaded = true
+      invalidateSelf() // Trigger callback
+    }
+
+    override fun draw(canvas: Canvas) {
+      // Draw a simple colored rectangle
+      canvas.drawColor(Color.RED)
+    }
+
+    override fun setAlpha(alpha: Int) {}
+
+    override fun setColorFilter(colorFilter: ColorFilter?) {}
+
+    override fun getOpacity(): Int = PixelFormat.OPAQUE
+  }
+
+  @Test
+  fun `waitForDrawableToLoad returns immediately for already loaded drawable`() =
+    runTest {
+      val drawable = MockAsyncDrawable()
+      // Pre-load the drawable
+      drawable.simulateLoading(0)
+
+      val startTime = System.currentTimeMillis()
+      val result = waitForDrawableToLoad(drawable, timeoutMs = 3000)
+      val elapsed = System.currentTimeMillis() - startTime
+
+      assertNotNull(result)
+      assertTrue("Should return quickly (< 100ms)", elapsed < 100)
+      assertTrue("Drawable should be loaded", result.intrinsicWidth > 1)
+    }
+
+  @Test
+  fun `waitForDrawableToLoad waits for drawable to load`() =
+    runTest {
+      val drawable = MockAsyncDrawable()
+
+      // Start async loading
+      launch {
+        drawable.simulateLoading(100)
+      }
+
+      val result = waitForDrawableToLoad(drawable, timeoutMs = 3000)
+
+      assertNotNull(result)
+      assertTrue("Drawable should be loaded after waiting", result.intrinsicWidth > 1)
+      assertTrue("Drawable should be loaded after waiting", result.intrinsicHeight > 1)
+      assertTrue("Width should be 150", result.intrinsicWidth == 150)
+      assertTrue("Height should be 100", result.intrinsicHeight == 100)
+    }
+
+  @Test
+  fun `waitForDrawableToLoad times out gracefully for drawable that never loads`() =
+    runTest {
+      val drawable = MockAsyncDrawable() // Never call simulateLoading()
+
+      val result = waitForDrawableToLoad(drawable, timeoutMs = 500)
+
+      // Should return the drawable even if timeout (best effort)
+      assertNotNull(result)
+    }
+
+  @Test
+  fun `convertDrawableToBase64 with async drawable returns consistent results`() =
+    runTest {
+      val drawable1 = MockAsyncDrawable()
+      val drawable2 = MockAsyncDrawable()
+
+      // Simulate both loading
+      launch { drawable1.simulateLoading(50) }
+      launch { drawable2.simulateLoading(100) }
+
+      val result1 = convertDrawableToBase64(drawable1)
+      val result2 = convertDrawableToBase64(drawable2)
+
+      assertNotNull("Result1 should not be null", result1)
+      assertNotNull("Result2 should not be null", result2)
+
+      // Both should be non-empty and similar length (same dimensions)
+      assertTrue("Both results should be non-empty", result1!!.isNotEmpty())
+      assertTrue("Both results should be non-empty", result2!!.isNotEmpty())
+
+      // They should be similar length since both are 150x100
+      val lengthDiff = kotlin.math.abs(result1.length - result2.length)
+      assertTrue(
+        "Results should have similar length (both 150x100), diff: $lengthDiff",
+        lengthDiff < result1.length * 0.1, // Within 10%
+      )
+    }
+
+  @Test
+  fun `waitForDrawableToLoad handles multiple concurrent calls`() =
+    runTest {
+      val drawable1 = MockAsyncDrawable()
+      val drawable2 = MockAsyncDrawable()
+      val drawable3 = MockAsyncDrawable()
+
+      // Start all loading at the same time
+      launch { drawable1.simulateLoading(50) }
+      launch { drawable2.simulateLoading(75) }
+      launch { drawable3.simulateLoading(100) }
+
+      // Wait for all concurrently
+      val result1 = waitForDrawableToLoad(drawable1, timeoutMs = 3000)
+      val result2 = waitForDrawableToLoad(drawable2, timeoutMs = 3000)
+      val result3 = waitForDrawableToLoad(drawable3, timeoutMs = 3000)
+
+      assertNotNull(result1)
+      assertNotNull(result2)
+      assertNotNull(result3)
+
+      assertTrue("All drawables should be loaded", result1.intrinsicWidth > 1)
+      assertTrue("All drawables should be loaded", result2.intrinsicWidth > 1)
+      assertTrue("All drawables should be loaded", result3.intrinsicWidth > 1)
+    }
+}

package/android/src/test/java/com/reactnativestripesdk/PaymentOptionImageConsistencyTest.kt

@@ -0,0 +1,186 @@
+package com.reactnativestripesdk
+
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Regression tests for the payment option image consistency bug.
+ *
+ * Issue: PaymentOption.icon() was returning a DelegateDrawable that loaded asynchronously,
+ * causing inconsistent base64 strings across multiple calls. Sometimes it returned a 1x1
+ * placeholder (134 bytes), sometimes the full image (5650 bytes).
+ *
+ * These tests ensure this bug never returns.
+ */
+@RunWith(RobolectricTestRunner::class)
+class PaymentOptionImageConsistencyTest {
+  @Test
+  fun `REGRESSION - multiple calls return consistent base64 strings`() =
+    runTest {
+      // This test specifically guards against the original bug where
+      // multiple calls to icon() returned inconsistent results
+      val drawable =
+        ColorDrawable(Color.BLUE).apply {
+          setBounds(0, 0, 147, 105) // Typical card icon size
+        }
+
+      val results = mutableListOf<String?>()
+      repeat(10) {
+        results.add(convertDrawableToBase64(drawable))
+      }
+
+      // All results should be identical
+      val uniqueResults = results.toSet()
+      assertEquals(
+        "All 10 calls should return identical base64 (was returning different values due to async loading bug)",
+        1,
+        uniqueResults.size,
+      )
+
+      // Verify the result is not null
+      assertNotNull("Base64 result should not be null", results.first())
+    }
+
+  @Test
+  fun `REGRESSION - base64 is not 1x1 placeholder`() =
+    runTest {
+      // This test guards against returning the 1x1 placeholder image
+      // Original bug: Sometimes returned 134-byte 1x1 black placeholder
+      val drawable =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 147, 105)
+        }
+
+      val result = convertDrawableToBase64(drawable)
+
+      assertNotNull(result)
+      // Original bug: 1x1 placeholder was 134 bytes
+      // Real image should be much larger
+      assertTrue(
+        "Base64 should be > 200 chars (original bug returned 134-byte 1x1 placeholder)",
+        result!!.length > 200,
+      )
+    }
+
+  @Test
+  fun `REGRESSION - bitmap has correct dimensions not 1x1`() =
+    runTest {
+      val drawable =
+        ColorDrawable(Color.GREEN).apply {
+          setBounds(0, 0, 147, 105)
+        }
+
+      val bitmap = getBitmapFromDrawable(drawable)
+
+      assertNotNull(bitmap)
+      assertNotEquals(
+        "Bitmap width should not be 1 (original bug captured 1x1 placeholder)",
+        1,
+        bitmap!!.width,
+      )
+      assertNotEquals(
+        "Bitmap height should not be 1 (original bug captured 1x1 placeholder)",
+        1,
+        bitmap.height,
+      )
+      assertEquals("Bitmap width should match drawable", 147, bitmap.width)
+      assertEquals("Bitmap height should match drawable", 105, bitmap.height)
+    }
+
+  @Test
+  fun `REGRESSION - rapid successive calls all return full image`() =
+    runTest {
+      // Simulate rapid successive calls like what happens when
+      // retrievePaymentOptionSelection() is called multiple times quickly
+      val drawable =
+        ColorDrawable(Color.MAGENTA).apply {
+          setBounds(0, 0, 147, 105)
+        }
+
+      val results = mutableListOf<String?>()
+      // Rapid fire - no delays
+      repeat(20) {
+        results.add(convertDrawableToBase64(drawable))
+      }
+
+      // All should be non-null
+      assertTrue(
+        "All results should be non-null",
+        results.all { it != null },
+      )
+
+      // All should be full images, not placeholders
+      assertTrue(
+        "All results should be > 200 chars (not 1x1 placeholders)",
+        results.all { it!!.length > 200 },
+      )
+
+      // All should be identical
+      val uniqueResults = results.toSet()
+      assertEquals(
+        "All 20 rapid calls should return identical base64",
+        1,
+        uniqueResults.size,
+      )
+    }
+
+  @Test
+  fun `REGRESSION - consistent results across different payment method types`() =
+    runTest {
+      // Test with different typical payment method icon sizes
+      val visaDrawable =
+        ColorDrawable(Color.BLUE).apply {
+          setBounds(0, 0, 147, 105) // Visa
+        }
+      val mastercardDrawable =
+        ColorDrawable(Color.RED).apply {
+          setBounds(0, 0, 147, 105) // Mastercard (same size)
+        }
+      val amexDrawable =
+        ColorDrawable(Color.CYAN).apply {
+          setBounds(0, 0, 147, 105) // Amex (same size)
+        }
+
+      val visa1 = convertDrawableToBase64(visaDrawable)
+      val visa2 = convertDrawableToBase64(visaDrawable)
+
+      val mc1 = convertDrawableToBase64(mastercardDrawable)
+      val mc2 = convertDrawableToBase64(mastercardDrawable)
+
+      val amex1 = convertDrawableToBase64(amexDrawable)
+      val amex2 = convertDrawableToBase64(amexDrawable)
+
+      // Each card type should return consistent results
+      assertEquals("Visa should be consistent", visa1, visa2)
+      assertEquals("Mastercard should be consistent", mc1, mc2)
+      assertEquals("Amex should be consistent", amex1, amex2)
+
+      // Different card types should have different images
+      assertNotEquals("Visa and Mastercard should differ", visa1, mc1)
+      assertNotEquals("Mastercard and Amex should differ", mc1, amex1)
+    }
+
+  @Test
+  fun `REGRESSION - setBounds is applied before drawing`() {
+    // This test ensures the original fix (setBounds) is still working
+    val drawable =
+      ColorDrawable(Color.YELLOW).apply {
+        setBounds(0, 0, 100, 80)
+      }
+
+    val bitmap = getBitmapFromDrawable(drawable)
+
+    assertNotNull(bitmap)
+    // The bitmap dimensions should match the bounds we set
+    assertEquals("Bitmap should respect setBounds width", 100, bitmap!!.width)
+    assertEquals("Bitmap should respect setBounds height", 80, bitmap.height)
+  }
+}