@thelacanians/vue-native-cli 0.4.15 → 0.6.2

package/native/android/VueNativeCore/src/test/kotlin/com/vuenative/core/ErrorOverlayViewTest.kt

@@ -0,0 +1,183 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.widget.Button
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.ScrollView
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class ErrorOverlayViewTest {
+
+    private lateinit var context: Context
+
+    @Before
+    fun setUp() {
+        context = ApplicationProvider.getApplicationContext()
+    }
+
+    private fun createActivity(): AppCompatActivity {
+        val controller = Robolectric.buildActivity(AppCompatActivity::class.java)
+        val activity = controller.get()
+        activity.setTheme(androidx.appcompat.R.style.Theme_AppCompat)
+        controller.create().start().resume()
+        return activity
+    }
+
+    // -------------------------------------------------------------------------
+    // ErrorOverlayView is a singleton object
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testIsSingletonObject() {
+        val ref1 = ErrorOverlayView
+        val ref2 = ErrorOverlayView
+        assertTrue("ErrorOverlayView should be a singleton object", ref1 === ref2)
+    }
+
+    // -------------------------------------------------------------------------
+    // show() with non-activity context does not crash
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testShowWithNonActivityContext() {
+        // Application context is not an AppCompatActivity, so show() should return early
+        ErrorOverlayView.show(context, "Test error")
+        // Should not crash
+        assertTrue(true)
+    }
+
+    // -------------------------------------------------------------------------
+    // show() with Activity creates overlay
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testShowWithActivity() {
+        val activity = createActivity()
+
+        ErrorOverlayView.show(activity, "Runtime error: undefined is not a function")
+
+        val decorView = activity.window.decorView as? android.view.ViewGroup
+        assertNotNull("decorView should not be null", decorView)
+
+        val overlay = decorView?.findViewWithTag<FrameLayout>("vue_native_error_overlay")
+        assertNotNull("Overlay should be added to decorView", overlay)
+    }
+
+    // -------------------------------------------------------------------------
+    // Overlay contains title, error text, and dismiss button
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testOverlayContents() {
+        val activity = createActivity()
+
+        val errorMessage = "TypeError: Cannot read property 'value' of null"
+        ErrorOverlayView.show(activity, errorMessage)
+
+        val decorView = activity.window.decorView as android.view.ViewGroup
+        val overlay = decorView.findViewWithTag<FrameLayout>("vue_native_error_overlay")!!
+
+        // The overlay contains a card (LinearLayout)
+        val card = overlay.getChildAt(0) as LinearLayout
+
+        // Card should have 3 children: title, scroll (with error text), dismiss button
+        assertEquals("Card should have 3 children", 3, card.childCount)
+
+        // Title
+        val title = card.getChildAt(0) as TextView
+        assertEquals("Vue Native JS Error", title.text.toString())
+
+        // Scroll -> error text
+        val scroll = card.getChildAt(1) as ScrollView
+        val errorText = scroll.getChildAt(0) as TextView
+        assertEquals(errorMessage, errorText.text.toString())
+
+        // Dismiss button
+        val dismiss = card.getChildAt(2) as Button
+        assertEquals("Dismiss", dismiss.text.toString())
+    }
+
+    // -------------------------------------------------------------------------
+    // Dismiss button removes overlay
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testDismissRemovesOverlay() {
+        val activity = createActivity()
+
+        ErrorOverlayView.show(activity, "Some error")
+
+        val decorView = activity.window.decorView as android.view.ViewGroup
+        var overlay = decorView.findViewWithTag<FrameLayout>("vue_native_error_overlay")
+        assertNotNull("Overlay should exist", overlay)
+
+        // Find and click the dismiss button
+        val card = overlay!!.getChildAt(0) as LinearLayout
+        val dismiss = card.getChildAt(2) as Button
+        dismiss.performClick()
+
+        overlay = decorView.findViewWithTag<FrameLayout>("vue_native_error_overlay")
+        assertNull("Overlay should be removed after dismiss", overlay)
+    }
+
+    // -------------------------------------------------------------------------
+    // Showing twice replaces old overlay
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testShowTwiceReplacesOverlay() {
+        val activity = createActivity()
+
+        ErrorOverlayView.show(activity, "First error")
+        ErrorOverlayView.show(activity, "Second error")
+
+        val decorView = activity.window.decorView as android.view.ViewGroup
+
+        // Count overlays with the tag
+        var overlayCount = 0
+        for (i in 0 until decorView.childCount) {
+            if (decorView.getChildAt(i).tag == "vue_native_error_overlay") {
+                overlayCount++
+            }
+        }
+        assertEquals("Should only have one overlay", 1, overlayCount)
+
+        // Verify it shows the second error
+        val overlay = decorView.findViewWithTag<FrameLayout>("vue_native_error_overlay")!!
+        val card = overlay.getChildAt(0) as LinearLayout
+        val scroll = card.getChildAt(1) as ScrollView
+        val errorText = scroll.getChildAt(0) as TextView
+        assertEquals("Second error", errorText.text.toString())
+    }
+
+    // -------------------------------------------------------------------------
+    // Overlay tag is correct
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testOverlayTag() {
+        val activity = createActivity()
+
+        ErrorOverlayView.show(activity, "Error")
+
+        val decorView = activity.window.decorView as android.view.ViewGroup
+        val overlay = decorView.findViewWithTag<FrameLayout>("vue_native_error_overlay")
+        assertNotNull("Overlay should be findable by tag", overlay)
+        assertEquals("vue_native_error_overlay", overlay!!.tag)
+    }
+}

package/native/android/VueNativeCore/src/test/kotlin/com/vuenative/core/EventThrottleTest.kt

@@ -0,0 +1,203 @@
+package com.vuenative.core
+
+import android.os.Looper
+import java.time.Duration
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class EventThrottleTest {
+
+    private val firedPayloads = mutableListOf<Any?>()
+
+    @Before
+    fun setUp() {
+        firedPayloads.clear()
+    }
+
+    private fun flush() {
+        Shadows.shadowOf(Looper.getMainLooper()).idle()
+    }
+
+    /**
+     * Resets lastFireTime to a very old value via reflection so that
+     * the first fire() call sees elapsed >= intervalMs.
+     * This is needed because Robolectric's SystemClock.uptimeMillis()
+     * returns 0 and lastFireTime starts at 0, so elapsed=0 < intervalMs.
+     */
+    private fun ensureFirstFireImmediate(throttle: EventThrottle) {
+        val field = EventThrottle::class.java.getDeclaredField("lastFireTime")
+        field.isAccessible = true
+        field.setLong(throttle, -100_000L)
+    }
+
+    // -------------------------------------------------------------------------
+    // Initialization
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testCreation() {
+        val throttle = EventThrottle(intervalMs = 100L) { firedPayloads.add(it) }
+        // Should not fire anything on creation
+        assertEquals(0, firedPayloads.size)
+        throttle.cancel()
+    }
+
+    // -------------------------------------------------------------------------
+    // First event fires immediately
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testFirstEventFiresImmediately() {
+        val throttle = EventThrottle(intervalMs = 100L) { firedPayloads.add(it) }
+        ensureFirstFireImmediate(throttle)
+
+        throttle.fire("first")
+
+        assertEquals("First event should fire immediately", 1, firedPayloads.size)
+        assertEquals("first", firedPayloads[0])
+        throttle.cancel()
+    }
+
+    // -------------------------------------------------------------------------
+    // Events within window are throttled (trailing fires after delay)
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testEventsWithinWindowAreThrottled() {
+        val throttle = EventThrottle(intervalMs = 5000L) { firedPayloads.add(it) }
+        ensureFirstFireImmediate(throttle)
+
+        // First fires immediately
+        throttle.fire("first")
+        assertEquals(1, firedPayloads.size)
+
+        // Second should be throttled (within the 5000ms window)
+        throttle.fire("second")
+        assertEquals("Second event should be throttled", 1, firedPayloads.size)
+
+        // Third should update the pending payload but not fire
+        throttle.fire("third")
+        assertEquals("Third event should still be throttled", 1, firedPayloads.size)
+
+        // Advance the looper clock past the interval to let the trailing callback fire
+        Shadows.shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(6000))
+
+        assertEquals("Trailing event should fire with latest payload", 2, firedPayloads.size)
+        assertEquals("third", firedPayloads[1])
+        throttle.cancel()
+    }
+
+    // -------------------------------------------------------------------------
+    // Cancel stops pending trailing call
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testCancelStopsPendingTrailing() {
+        val throttle = EventThrottle(intervalMs = 5000L) { firedPayloads.add(it) }
+        ensureFirstFireImmediate(throttle)
+
+        // First fires immediately
+        throttle.fire("first")
+        assertEquals(1, firedPayloads.size)
+
+        // Second is throttled (trailing scheduled)
+        throttle.fire("second")
+        assertEquals(1, firedPayloads.size)
+
+        // Cancel before trailing fires
+        throttle.cancel()
+        flush()
+
+        assertEquals("Trailing should NOT fire after cancel", 1, firedPayloads.size)
+    }
+
+    // -------------------------------------------------------------------------
+    // Multiple fires with cancel in between
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testFireAfterCancel() {
+        val throttle = EventThrottle(intervalMs = 5000L) { firedPayloads.add(it) }
+        ensureFirstFireImmediate(throttle)
+
+        throttle.fire("first")
+        assertEquals(1, firedPayloads.size)
+
+        throttle.fire("second")
+        throttle.cancel()
+        flush()
+
+        assertEquals("Only the first event should have fired", 1, firedPayloads.size)
+    }
+
+    // -------------------------------------------------------------------------
+    // Payload is passed correctly
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testPayloadPassedCorrectly() {
+        val throttle = EventThrottle(intervalMs = 5000L) { firedPayloads.add(it) }
+        ensureFirstFireImmediate(throttle)
+
+        val payload = mapOf("x" to 10, "y" to 20)
+        throttle.fire(payload)
+
+        assertEquals(1, firedPayloads.size)
+        @Suppress("UNCHECKED_CAST")
+        val received = firedPayloads[0] as Map<String, Int>
+        assertEquals(10, received["x"])
+        assertEquals(20, received["y"])
+        throttle.cancel()
+    }
+
+    // -------------------------------------------------------------------------
+    // Null payload is valid
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testNullPayload() {
+        val throttle = EventThrottle(intervalMs = 5000L) { firedPayloads.add(it) }
+        ensureFirstFireImmediate(throttle)
+
+        throttle.fire(null)
+
+        assertEquals(1, firedPayloads.size)
+        assertEquals(null, firedPayloads[0])
+        throttle.cancel()
+    }
+
+    // -------------------------------------------------------------------------
+    // Default interval is 16ms
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testDefaultInterval() {
+        val throttle = EventThrottle { firedPayloads.add(it) }
+        ensureFirstFireImmediate(throttle)
+        throttle.fire("test")
+        assertEquals(1, firedPayloads.size)
+        throttle.cancel()
+    }
+
+    // -------------------------------------------------------------------------
+    // Multiple cancel calls don't crash
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testMultipleCancelCalls() {
+        val throttle = EventThrottle(intervalMs = 100L) { firedPayloads.add(it) }
+        throttle.cancel()
+        throttle.cancel()
+        throttle.cancel()
+        // Should not crash
+        assertTrue(true)
+    }
+}

package/native/android/VueNativeCore/src/test/kotlin/com/vuenative/core/HotReloadManagerTest.kt

@@ -0,0 +1,162 @@
+package com.vuenative.core
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class HotReloadManagerTest {
+
+    private lateinit var context: Context
+    private var lastReloadCode: String? = null
+    private lateinit var manager: HotReloadManager
+
+    @Before
+    fun setUp() {
+        // Reset ComponentRegistry singleton via reflection
+        val crField = ComponentRegistry::class.java.getDeclaredField("instance")
+        crField.isAccessible = true
+        crField.set(null, null)
+
+        // Reset NativeModuleRegistry singleton via reflection
+        val nmrField = NativeModuleRegistry::class.java.getDeclaredField("instance")
+        nmrField.isAccessible = true
+        nmrField.set(null, null)
+
+        context = ApplicationProvider.getApplicationContext()
+        lastReloadCode = null
+
+        val runtime = JSRuntime(context)
+        manager = HotReloadManager(runtime) { code ->
+            lastReloadCode = code
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Initialization
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testCreation() {
+        assertNotNull("HotReloadManager should be created", manager)
+    }
+
+    // -------------------------------------------------------------------------
+    // Initial connection state is disconnected
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testInitialConnectionState() {
+        val field = HotReloadManager::class.java.getDeclaredField("isConnected")
+        field.isAccessible = true
+        val connected = field.getBoolean(manager)
+        assertFalse("Should not be connected initially", connected)
+    }
+
+    // -------------------------------------------------------------------------
+    // disconnect() clears state
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testDisconnect() {
+        manager.disconnect()
+
+        val connField = HotReloadManager::class.java.getDeclaredField("isConnected")
+        connField.isAccessible = true
+        assertFalse("isConnected should be false after disconnect", connField.getBoolean(manager))
+
+        val devField = HotReloadManager::class.java.getDeclaredField("devServerUrl")
+        devField.isAccessible = true
+        val devUrl = devField.get(manager)
+        assertTrue("devServerUrl should be null after disconnect", devUrl == null)
+
+        val bundleField = HotReloadManager::class.java.getDeclaredField("bundleUrl")
+        bundleField.isAccessible = true
+        val bundleUrl = bundleField.get(manager)
+        assertTrue("bundleUrl should be null after disconnect", bundleUrl == null)
+
+        val wsField = HotReloadManager::class.java.getDeclaredField("wsSession")
+        wsField.isAccessible = true
+        val ws = wsField.get(manager)
+        assertTrue("wsSession should be null after disconnect", ws == null)
+    }
+
+    // -------------------------------------------------------------------------
+    // disconnect() is idempotent
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testDisconnectIdempotent() {
+        manager.disconnect()
+        manager.disconnect()
+        manager.disconnect()
+        // Should not throw
+        assertTrue(true)
+    }
+
+    // -------------------------------------------------------------------------
+    // connect() stores URLs
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testConnectStoresUrls() {
+        manager.connect("ws://localhost:3000", "http://localhost:3000/bundle.js")
+
+        val devField = HotReloadManager::class.java.getDeclaredField("devServerUrl")
+        devField.isAccessible = true
+        val devUrl = devField.get(manager) as? String
+        assertTrue("devServerUrl should be set", devUrl == "ws://localhost:3000")
+
+        val bundleField = HotReloadManager::class.java.getDeclaredField("bundleUrl")
+        bundleField.isAccessible = true
+        val bundleUrl = bundleField.get(manager) as? String
+        assertTrue("bundleUrl should be set", bundleUrl == "http://localhost:3000/bundle.js")
+
+        manager.disconnect()
+    }
+
+    // -------------------------------------------------------------------------
+    // After disconnect, can reconnect
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testReconnectAfterDisconnect() {
+        manager.connect("ws://localhost:3000", "http://localhost:3000/bundle.js")
+        manager.disconnect()
+
+        // Scope and job should be fresh after disconnect
+        val scopeJobField = HotReloadManager::class.java.getDeclaredField("scopeJob")
+        scopeJobField.isAccessible = true
+        val scopeJob = scopeJobField.get(manager) as kotlinx.coroutines.Job
+        assertFalse("scopeJob should not be cancelled after disconnect+reinit", scopeJob.isCancelled)
+
+        manager.connect("ws://localhost:4000", "http://localhost:4000/bundle.js")
+
+        val devField = HotReloadManager::class.java.getDeclaredField("devServerUrl")
+        devField.isAccessible = true
+        val devUrl = devField.get(manager) as? String
+        assertTrue("devServerUrl should be updated", devUrl == "ws://localhost:4000")
+
+        manager.disconnect()
+    }
+
+    // -------------------------------------------------------------------------
+    // httpClient exists
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testHttpClientExists() {
+        val field = HotReloadManager::class.java.getDeclaredField("httpClient")
+        field.isAccessible = true
+        val client = field.get(manager)
+        assertNotNull("httpClient should not be null", client)
+    }
+}