@dynamic-labs-sdk/client 1.6.0 → 1.8.0

package/android/src/test/java/xyz/dynamic/client/webview/DynamicWebViewModuleTest.kt

@@ -0,0 +1,191 @@
+package xyz.dynamic.client.webview
+
+import android.app.Activity
+import android.net.Uri
+import android.os.Looper
+import android.webkit.WebView
+import androidx.webkit.JavaScriptReplyProxy
+import androidx.webkit.WebMessageCompat
+import androidx.webkit.WebViewCompat
+import androidx.webkit.WebViewFeature
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import io.mockk.CapturingSlot
+import io.mockk.Runs
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.slot
+import io.mockk.unmockkAll
+import io.mockk.verify
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+
+// The androidx.webkit + Arguments statics are mocked (they delegate to the
+// device WebView / JNI). A real Robolectric Activity backs WebView construction
+// so open() reaches the live-host state needed to exercise invalidate().
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class DynamicWebViewModuleTest {
+
+    private lateinit var activity: Activity
+    private lateinit var reactContext: ReactApplicationContext
+    private lateinit var module: DynamicWebViewModule
+    private lateinit var eventEmitter: RCTDeviceEventEmitter
+    private lateinit var webSlot: CapturingSlot<WebView>
+    private lateinit var listenerSlot: CapturingSlot<WebViewCompat.WebMessageListener>
+
+    @Before
+    fun setUp() {
+        activity = Robolectric.buildActivity(Activity::class.java).setup().get()
+        reactContext = mockk(relaxed = true)
+        every { reactContext.currentActivity } returns activity
+        every { reactContext.runOnUiQueueThread(any()) } answers { firstArg<Runnable>().run() }
+
+        eventEmitter = mockk(relaxed = true)
+        every {
+            reactContext.getJSModule(RCTDeviceEventEmitter::class.java)
+        } returns eventEmitter
+
+        mockkStatic(Arguments::class)
+        every { Arguments.createMap() } answers { JavaOnlyMap() }
+        every { Arguments.createArray() } answers { JavaOnlyArray() }
+
+        mockkStatic(WebViewFeature::class)
+        every { WebViewFeature.isFeatureSupported(any()) } returns false
+        every {
+            WebViewFeature.isFeatureSupported(WebViewFeature.WEB_MESSAGE_LISTENER)
+        } returns true
+
+        mockkStatic(WebViewCompat::class)
+        webSlot = slot()
+        listenerSlot = slot()
+        every {
+            WebViewCompat.addWebMessageListener(
+                capture(webSlot),
+                any(),
+                any(),
+                capture(listenerSlot),
+            )
+        } just Runs
+        every {
+            WebViewCompat.addDocumentStartJavaScript(any(), any(), any())
+        } returns mockk(relaxed = true)
+        every { WebViewCompat.setProfile(any(), any()) } just Runs
+
+        module = DynamicWebViewModule(reactContext)
+    }
+
+    @After
+    fun tearDown() {
+        unmockkAll()
+    }
+
+    private fun idleMain() = shadowOf(Looper.getMainLooper()).idle()
+
+    // region invalidate (#12 — ConcurrentModificationException)
+
+    @Test
+    fun invalidate_closesEveryActiveHostWithoutConcurrentModification() {
+        val p1 = mockk<Promise>(relaxed = true)
+        val p2 = mockk<Promise>(relaxed = true)
+
+        module.open("a", "https://app.dynamicauth.com/x", p1)
+        module.open("b", "https://app.dynamicauth.com/y", p2)
+        idleMain() // run the posted opens → two live hosts
+
+        module.invalidate()
+        idleMain() // run the posted close-all; the .toList() snapshot avoids CME
+
+        // Both hosts torn down (cancelled) proves the iteration completed across
+        // >1 host — without the snapshot this throws ConcurrentModificationException.
+        verify { p1.reject("webview_cancelled", any<String>(), any<WritableMap>()) }
+        verify { p2.reject("webview_cancelled", any<String>(), any<WritableMap>()) }
+    }
+
+    // endregion
+
+    // region emitMessage payload mapping (#13 — array payloads)
+
+    @Test
+    fun putBridgeData_mapsArrayPayloadOntoDataField() {
+        val target = JavaOnlyMap()
+        putBridgeData(target, JavaOnlyArray().apply { pushString("x") })
+        assertEquals(ReadableType.Array, target.getType("data"))
+    }
+
+    @Test
+    fun putBridgeData_mapsMapStringNullAndUnknownFallthrough() {
+        val map = JavaOnlyMap()
+
+        putBridgeData(map, JavaOnlyMap())
+        assertEquals(ReadableType.Map, map.getType("data"))
+
+        putBridgeData(map, "s")
+        assertEquals(ReadableType.String, map.getType("data"))
+
+        putBridgeData(map, null)
+        assertEquals(ReadableType.Null, map.getType("data"))
+
+        putBridgeData(map, 42)
+        assertEquals(ReadableType.Null, map.getType("data"))
+    }
+
+    // endregion
+
+    // region pre-listener event buffering (F4 — handshake not dropped)
+
+    // Drives a bridge message into the host's WebMessageListener so it flows
+    // through onBridgeMessage -> onMessage -> module.emitMessage.
+    private fun deliverBridgeMessage(payload: String) {
+        listenerSlot.captured.onPostMessage(
+            webSlot.captured,
+            mockk<WebMessageCompat> { every { data } returns payload },
+            Uri.parse("https://app.dynamicauth.com"),
+            true,
+            mockk<JavaScriptReplyProxy>(relaxed = true),
+        )
+    }
+
+    @Test
+    fun emitMessage_buffersBeforeFirstListenerThenFlushesOnSubscribe() {
+        module.open("a", "https://app.dynamicauth.com/x", mockk(relaxed = true))
+        idleMain()
+
+        // Handshake arrives before any JS listener subscribed → must be buffered,
+        // not emitted (RCTDeviceEventEmitter.emit would otherwise drop it).
+        deliverBridgeMessage("{\"type\":\"iframe-ready\"}")
+        verify(exactly = 0) { eventEmitter.emit(any(), any()) }
+
+        // First subscriber attaches → buffered event flushes.
+        module.addListener(DynamicWebViewModule.MESSAGE_EVENT_NAME)
+        verify { eventEmitter.emit(DynamicWebViewModule.MESSAGE_EVENT_NAME, any()) }
+    }
+
+    @Test
+    fun emitMessage_emitsDirectlyAfterListenerAttached() {
+        module.open("a", "https://app.dynamicauth.com/x", mockk(relaxed = true))
+        idleMain()
+        module.addListener(DynamicWebViewModule.MESSAGE_EVENT_NAME)
+
+        deliverBridgeMessage("{\"type\":\"sign\"}")
+
+        verify { eventEmitter.emit(DynamicWebViewModule.MESSAGE_EVENT_NAME, any()) }
+    }
+
+    // endregion
+}