catalyst-core 0.3.0-beta.4 → 0.3.0-canary.1

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/FrameworkServerUtilsTest.kt

@@ -0,0 +1,300 @@
+package io.yourname.androidproject
+
+import android.content.Context
+import android.webkit.WebView
+import io.yourname.androidproject.utils.FrameworkServerUtils
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import java.io.IOException
+import java.net.HttpURLConnection
+import java.net.URL
+import kotlin.io.path.createTempDirectory
+
+/**
+ * Loopback tests for FrameworkServerUtils, the Ktor-based localhost file
+ * server — previously entirely untested (0%). Ports iOS's
+ * FrameworkServerUtilsLoopbackTests.swift pattern: start the real
+ * embedded server (Ktor/Netty, real socket, real port from the
+ * 3000-3099 range) and make real HTTP requests against it via
+ * java.net.HttpURLConnection (no new test dependency needed — this repo
+ * has no OkHttp test dep, and the JDK's built-in client is enough for a
+ * loopback GET/POST).
+ *
+ * FrameworkServerUtils is a singleton `object` — server state
+ * (isServerRunning/serverPort/sessionId/servedFiles) is shared static
+ * state across the whole test JVM. Every test starts fresh via
+ * stopServer() in tearDown so state doesn't leak between tests or other
+ * test classes running in the same JVM.
+ *
+ * Not chased here: the /ai/stream and /ai/generate SSE routes (need a
+ * real nativeAiSupplier + Flow collection — a second, separate scope) and
+ * the 5-minute cleanup task's periodic timer path. This file covers
+ * lifecycle (start/stop/isRunning/getServerPort/getSessionId), file
+ * serving (add/copy/remove), and the /status, file-serving, and
+ * invalid-route HTTP endpoints — mirrors what iOS's loopback tests
+ * covered for the equivalent Swift class.
+ */
+class FrameworkServerUtilsTest {
+
+    private lateinit var cacheDir: java.io.File
+    private lateinit var context: Context
+    private lateinit var webView: WebView
+
+    @Before
+    fun setUp() {
+        // FrameworkServerUtils is a JVM-wide singleton object; stop it
+        // defensively before each test too, not just in tearDown — a
+        // prior test class (or an earlier test in this one, if tearDown
+        // somehow didn't run) leaving the server running would otherwise
+        // poison this class's isRunning()==false assumptions. Matches the
+        // defensive-stop pattern already used in FileSizeRouterUtilsTest.
+        if (FrameworkServerUtils.isRunning()) {
+            FrameworkServerUtils.stopServer()
+        }
+        cacheDir = createTempDirectory(prefix = "catalyst-framework-server-test").toFile()
+        context = mock { on { getCacheDir() } doReturn cacheDir }
+        webView = mock { on { getUrl() } doReturn "http://localhost:8080/index.html" }
+    }
+
+    @After
+    fun tearDown() {
+        if (FrameworkServerUtils.isRunning()) {
+            FrameworkServerUtils.stopServer()
+        }
+        cacheDir.deleteRecursively()
+    }
+
+    /** Waits briefly for Ktor/Netty's async bind to complete, mirroring the
+     * "server may not start in this sandbox" tolerance pattern used on
+     * iOS — returns false (caller should skip) if it never came up. */
+    private fun startServerAndWaitReady(): Boolean {
+        val started = FrameworkServerUtils.startServer(context, webView)
+        if (!started) return false
+        repeat(20) {
+            if (FrameworkServerUtils.isRunning() && FrameworkServerUtils.getServerPort() != 0) return true
+            Thread.sleep(100)
+        }
+        return FrameworkServerUtils.isRunning()
+    }
+
+    private fun get(path: String): Pair<Int, String> {
+        val port = FrameworkServerUtils.getServerPort()
+        val connection = URL("http://localhost:$port$path").openConnection() as HttpURLConnection
+        connection.connectTimeout = 5000
+        connection.readTimeout = 5000
+        connection.setRequestProperty("Accept", "*/*")
+        return try {
+            val code = connection.responseCode
+            val body = try {
+                connection.inputStream.bufferedReader().readText()
+            } catch (e: IOException) {
+                connection.errorStream?.bufferedReader()?.readText() ?: ""
+            }
+            code to body
+        } finally {
+            connection.disconnect()
+        }
+    }
+
+    // ============================================================
+    // Lifecycle
+    // ============================================================
+
+    @Test
+    fun `startServer starts the server and reports a port in the configured range`() {
+        assumeServerStarts {
+            assertTrue(FrameworkServerUtils.isRunning())
+            assertTrue(FrameworkServerUtils.getServerPort() in 3000..3099)
+            assertTrue(FrameworkServerUtils.getSessionId().isNotEmpty())
+        }
+    }
+
+    @Test
+    fun `startServer is idempotent when already running`() {
+        assumeServerStarts {
+            val firstPort = FrameworkServerUtils.getServerPort()
+            val result = FrameworkServerUtils.startServer(context, webView)
+            assertTrue(result)
+            assertEquals(firstPort, FrameworkServerUtils.getServerPort())
+        }
+    }
+
+    @Test
+    fun `stopServer stops the server and isRunning reports false`() {
+        assumeServerStarts {
+            FrameworkServerUtils.stopServer()
+            assertFalse(FrameworkServerUtils.isRunning())
+        }
+    }
+
+    @Test
+    fun `isRunning is false before any server has started`() {
+        assertFalse(FrameworkServerUtils.isRunning())
+    }
+
+    @Test
+    fun `a server restarted after stop can start again and serve a file`() {
+        // Regression test for the serverScope-never-recreated bug:
+        // serverScope was a `val`, so stopServer()'s serverScope.cancel()
+        // permanently killed it — a restarted server's startCleanupTask()
+        // then launched into an already-cancelled scope. This doesn't
+        // directly assert the cleanup task itself (its failure was
+        // silent — a cancelled scope just drops launched coroutines
+        // rather than throwing at the call site), but it does exercise
+        // the exact start -> stop -> start sequence that triggered it end
+        // to end, including a real file being served on the restarted
+        // instance, as the most direct available signal something didn't
+        // regress.
+        assumeServerStarts {
+            FrameworkServerUtils.stopServer()
+            assertFalse(FrameworkServerUtils.isRunning())
+
+            val restarted = FrameworkServerUtils.startServer(context, webView)
+            assertTrue(restarted)
+            assertTrue(FrameworkServerUtils.isRunning())
+
+            val tempFile = java.io.File(cacheDir, "after-restart.txt").apply { writeText("still works") }
+            val url = FrameworkServerUtils.addFileToServe(tempFile, "after-restart.txt", "text/plain")
+            assertNotNull(url)
+
+            val path = url!!.substringAfter("localhost:${FrameworkServerUtils.getServerPort()}")
+            val (code, body) = get(path)
+            assertEquals(200, code)
+            assertEquals("still works", body)
+        }
+    }
+
+    // ============================================================
+    // addFileToServe / copyAndServeFile / removeServedFile (not-running guards)
+    // ============================================================
+
+    @Test
+    fun `addFileToServe returns null when the server is not running`() {
+        assertFalse(FrameworkServerUtils.isRunning())
+        val tempFile = java.io.File(cacheDir, "not-served.txt").apply { writeText("x") }
+
+        val result = FrameworkServerUtils.addFileToServe(tempFile, "not-served.txt", "text/plain")
+
+        assertNull(result)
+    }
+
+    @Test
+    fun `copyAndServeFile returns null when the server is not running`() {
+        assertFalse(FrameworkServerUtils.isRunning())
+        val tempFile = java.io.File(cacheDir, "not-copied.txt").apply { writeText("x") }
+
+        val result = FrameworkServerUtils.copyAndServeFile(tempFile, "not-copied.txt", "text/plain")
+
+        assertNull(result)
+    }
+
+    @Test
+    fun `addFileToServe returns a well-formed URL once the server is running`() {
+        assumeServerStarts {
+            val tempFile = java.io.File(cacheDir, "served.txt").apply { writeText("hello") }
+
+            val url = FrameworkServerUtils.addFileToServe(tempFile, "served.txt", "text/plain")
+
+            assertNotNull(url)
+            assertTrue(url!!.startsWith("http://localhost:${FrameworkServerUtils.getServerPort()}/framework-${FrameworkServerUtils.getSessionId()}/file-"))
+        }
+    }
+
+    // ============================================================
+    // HTTP endpoints (real requests against the real embedded server)
+    // ============================================================
+
+    @Test
+    fun `GET status returns 200 with running JSON`() {
+        assumeServerStarts {
+            val (code, body) = get("/framework-${FrameworkServerUtils.getSessionId()}/status")
+
+            assertEquals(200, code)
+            assertTrue(body.contains("\"status\":\"running\""))
+            assertTrue(body.contains(FrameworkServerUtils.getSessionId()))
+        }
+    }
+
+    @Test
+    fun `GET a served file returns 200 with the real file content`() {
+        assumeServerStarts {
+            val content = "loopback content ${System.nanoTime()}"
+            val tempFile = java.io.File(cacheDir, "loopback.txt").apply { writeText(content) }
+            val url = FrameworkServerUtils.addFileToServe(tempFile, "loopback.txt", "text/plain")
+            assertNotNull(url)
+
+            val path = url!!.substringAfter("localhost:${FrameworkServerUtils.getServerPort()}")
+            val (code, body) = get(path)
+
+            assertEquals(200, code)
+            assertEquals(content, body)
+        }
+    }
+
+    @Test
+    fun `GET an unknown fileId returns 404`() {
+        assumeServerStarts {
+            val (code, _) = get("/framework-${FrameworkServerUtils.getSessionId()}/file-does-not-exist")
+            assertEquals(404, code)
+        }
+    }
+
+    @Test
+    fun `GET a served file whose physical file was deleted returns 404`() {
+        assumeServerStarts {
+            val tempFile = java.io.File(cacheDir, "vanish.txt").apply { writeText("will vanish") }
+            val url = FrameworkServerUtils.addFileToServe(tempFile, "vanish.txt", "text/plain")
+            assertNotNull(url)
+            tempFile.delete()
+
+            val path = url!!.substringAfter("localhost:${FrameworkServerUtils.getServerPort()}")
+            val (code, _) = get(path)
+
+            assertEquals(404, code)
+        }
+    }
+
+    @Test
+    fun `GET an invalid route returns 404`() {
+        assumeServerStarts {
+            val (code, _) = get("/framework-${FrameworkServerUtils.getSessionId()}/not-a-real-route")
+            assertEquals(404, code)
+        }
+    }
+
+    @Test
+    fun `removeServedFile makes a subsequent request return 404`() {
+        assumeServerStarts {
+            val tempFile = java.io.File(cacheDir, "to-remove.txt").apply { writeText("bye") }
+            val url = FrameworkServerUtils.addFileToServe(tempFile, "to-remove.txt", "text/plain")
+            assertNotNull(url)
+            val path = url!!.substringAfter("localhost:${FrameworkServerUtils.getServerPort()}")
+
+            val (beforeCode, _) = get(path)
+            assertEquals(200, beforeCode)
+
+            val fileId = path.substringAfter("file-")
+            FrameworkServerUtils.removeServedFile(fileId)
+
+            val (afterCode, _) = get(path)
+            assertEquals(404, afterCode)
+        }
+    }
+
+    // Runs `block` only if the real Ktor/Netty server actually came up in
+    // this sandbox; otherwise the test is silently skipped rather than
+    // failed — matches the "server may not start in this environment"
+    // tolerance pattern from the iOS loopback tests (network restrictions
+    // in some CI/sandbox environments can prevent binding a real socket).
+    private fun assumeServerStarts(block: () -> Unit) {
+        if (!startServerAndWaitReady()) {
+            org.junit.Assume.assumeTrue("Framework server failed to start in this environment — skipping", false)
+            return
+        }
+        block()
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/IntentUtilsTest.kt

@@ -0,0 +1,244 @@
+package io.yourname.androidproject
+
+import android.app.Activity
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.content.pm.ResolveInfo
+import io.yourname.androidproject.utils.IntentUtils
+import org.junit.Assert.*
+import org.junit.Test
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.doThrow
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+/**
+ * Unit tests for IntentUtils, previously entirely untested (0%).
+ *
+ * parseIntentParams/validateFileUrl/createFilePickerIntent are pure (no
+ * Context/Activity) and covered directly. canHandleIntent/
+ * getAppsForMimeType/getDefaultAppForMimeType take an Activity but only
+ * touch its packageManager, so a mocked Activity + mocked PackageManager
+ * covers them without FileProvider. openFileWithSystemIntent/
+ * createShareIntent/openFileWithSpecificApp all call
+ * FileProvider.getUriForFile — a static method backed by a real
+ * ContentProvider registration that doesn't exist in a JVM unit test —
+ * left uncovered here rather than chased with a heavier mocking setup;
+ * matches the plan's "reachable without excessive mocking" scope.
+ */
+class IntentUtilsTest {
+
+    // ============================================================
+    // parseIntentParams
+    // ============================================================
+
+    @Test
+    fun `parseIntentParams splits fileUrl and mimeType on the pipe delimiter`() {
+        val (fileUrl, mimeType) = IntentUtils.parseIntentParams("https://example.com/file.pdf|application/pdf")
+        assertEquals("https://example.com/file.pdf", fileUrl)
+        assertEquals("application/pdf", mimeType)
+    }
+
+    @Test
+    fun `parseIntentParams returns null mimeType when no pipe is present`() {
+        val (fileUrl, mimeType) = IntentUtils.parseIntentParams("https://example.com/file.pdf")
+        assertEquals("https://example.com/file.pdf", fileUrl)
+        assertNull(mimeType)
+    }
+
+    @Test
+    fun `parseIntentParams throws for null params`() {
+        assertThrows(IllegalArgumentException::class.java) {
+            IntentUtils.parseIntentParams(null)
+        }
+    }
+
+    @Test
+    fun `parseIntentParams throws for blank params`() {
+        assertThrows(IllegalArgumentException::class.java) {
+            IntentUtils.parseIntentParams("   ")
+        }
+    }
+
+    @Test
+    fun `parseIntentParams throws when the fileUrl portion is empty`() {
+        assertThrows(IllegalArgumentException::class.java) {
+            IntentUtils.parseIntentParams("|application/pdf")
+        }
+    }
+
+    @Test
+    fun `parseIntentParams treats a blank mimeType segment as null`() {
+        val (_, mimeType) = IntentUtils.parseIntentParams("https://example.com/file.pdf|   ")
+        assertNull(mimeType)
+    }
+
+    // ============================================================
+    // validateFileUrl
+    // ============================================================
+
+    @Test
+    fun `validateFileUrl accepts an https URL`() {
+        IntentUtils.validateFileUrl("https://example.com/file.pdf")
+    }
+
+    @Test
+    fun `validateFileUrl accepts an http URL`() {
+        IntentUtils.validateFileUrl("http://example.com/file.pdf")
+    }
+
+    @Test
+    fun `validateFileUrl throws for a blank URL`() {
+        val error = assertThrows(IllegalArgumentException::class.java) {
+            IntentUtils.validateFileUrl("")
+        }
+        assertEquals("File URL cannot be empty", error.message)
+    }
+
+    @Test
+    fun `validateFileUrl throws for a non-http(s) scheme`() {
+        val error = assertThrows(IllegalArgumentException::class.java) {
+            IntentUtils.validateFileUrl("file:///local/path.pdf")
+        }
+        assertEquals("Only remote URLs (http/https) are supported", error.message)
+    }
+
+    // ============================================================
+    // createFilePickerIntent
+    //
+    // Intent is a real android.content.Intent (not mocked) constructed
+    // directly by the method under test. Its getters (action/type/
+    // categories/getBooleanExtra/getStringArrayExtra) are backed by the
+    // Android SDK's stub jar, which — even with
+    // testOptions.unitTests.isReturnDefaultValues=true — returns default
+    // values (null/false) rather than reflecting state actually set via
+    // setAction()/type=/putExtra() on the same stub instance. That's a
+    // structural limitation of testing raw Intent state in a plain JVM
+    // unit test (Robolectric provides a real Intent implementation for
+    // this; out of scope per this plan's Mockito-only ceiling). These
+    // tests exercise the method's branching logic (single vs.
+    // comma-separated MIME type path) and assert only that it completes
+    // and returns a non-null Intent, not the Intent's resulting state.
+    // ============================================================
+
+    @Test
+    fun `createFilePickerIntent returns a non-null Intent for a single MIME type`() {
+        val intent = IntentUtils.createFilePickerIntent("application/pdf")
+        assertNotNull(intent)
+    }
+
+    @Test
+    fun `createFilePickerIntent returns a non-null Intent when allowMultiple is set`() {
+        val intent = IntentUtils.createFilePickerIntent("image/*", allowMultiple = true)
+        assertNotNull(intent)
+    }
+
+    @Test
+    fun `createFilePickerIntent returns a non-null Intent for comma-separated MIME types`() {
+        val intent = IntentUtils.createFilePickerIntent("application/pdf,image/png")
+        assertNotNull(intent)
+    }
+
+    @Test
+    fun `createFilePickerIntent returns a non-null Intent for a trailing-comma single type`() {
+        val intent = IntentUtils.createFilePickerIntent("application/pdf,")
+        assertNotNull(intent)
+    }
+
+    // ============================================================
+    // canHandleIntent / getAppsForMimeType / getDefaultAppForMimeType
+    // ============================================================
+
+    private fun activityWithPackageManager(packageManager: PackageManager): Activity {
+        return mock { on { getPackageManager() } doReturn packageManager }
+    }
+
+    @Test
+    fun `canHandleIntent returns true when queryIntentActivities finds a match`() {
+        val resolveInfo: ResolveInfo = mock()
+        val packageManager: PackageManager = mock {
+            on { queryIntentActivities(org.mockito.kotlin.any(), org.mockito.kotlin.eq(0)) } doReturn listOf(resolveInfo)
+        }
+        val activity = activityWithPackageManager(packageManager)
+
+        assertTrue(IntentUtils.canHandleIntent(activity, Intent(Intent.ACTION_VIEW)))
+    }
+
+    @Test
+    fun `canHandleIntent returns false when no app can handle it`() {
+        val packageManager: PackageManager = mock {
+            on { queryIntentActivities(org.mockito.kotlin.any(), org.mockito.kotlin.eq(0)) } doReturn emptyList()
+        }
+        val activity = activityWithPackageManager(packageManager)
+
+        assertFalse(IntentUtils.canHandleIntent(activity, Intent(Intent.ACTION_VIEW)))
+    }
+
+    @Test
+    fun `canHandleIntent returns false when queryIntentActivities throws`() {
+        val packageManager: PackageManager = mock {
+            on { queryIntentActivities(org.mockito.kotlin.any(), org.mockito.kotlin.eq(0)) } doThrow RuntimeException("boom")
+        }
+        val activity = activityWithPackageManager(packageManager)
+
+        assertFalse(IntentUtils.canHandleIntent(activity, Intent(Intent.ACTION_VIEW)))
+    }
+
+    @Test
+    fun `getAppsForMimeType returns loaded labels for each resolved app`() {
+        val packageManager: PackageManager = mock()
+        val resolveInfo: ResolveInfo = mock {
+            on { loadLabel(packageManager) } doReturn "PDF Reader"
+        }
+        whenever(packageManager.queryIntentActivities(org.mockito.kotlin.any(), org.mockito.kotlin.eq(0)))
+            .thenReturn(listOf(resolveInfo))
+        val activity = activityWithPackageManager(packageManager)
+
+        val apps = IntentUtils.getAppsForMimeType(activity, "application/pdf")
+
+        assertEquals(listOf("PDF Reader"), apps)
+    }
+
+    @Test
+    fun `getAppsForMimeType returns an empty list when resolution throws`() {
+        val packageManager: PackageManager = mock {
+            on { queryIntentActivities(org.mockito.kotlin.any(), org.mockito.kotlin.eq(0)) } doThrow RuntimeException("boom")
+        }
+        val activity = activityWithPackageManager(packageManager)
+
+        assertTrue(IntentUtils.getAppsForMimeType(activity, "application/pdf").isEmpty())
+    }
+
+    @Test
+    fun `getDefaultAppForMimeType returns the resolved package name`() {
+        val resolveInfo = android.content.pm.ResolveInfo().apply {
+            activityInfo = android.content.pm.ActivityInfo().apply { packageName = "com.example.pdf" }
+        }
+        val packageManager: PackageManager = mock {
+            on { resolveActivity(org.mockito.kotlin.any(), org.mockito.kotlin.eq(0)) } doReturn resolveInfo
+        }
+        val activity = activityWithPackageManager(packageManager)
+
+        assertEquals("com.example.pdf", IntentUtils.getDefaultAppForMimeType(activity, "application/pdf"))
+    }
+
+    @Test
+    fun `getDefaultAppForMimeType returns null when nothing resolves`() {
+        val packageManager: PackageManager = mock {
+            on { resolveActivity(org.mockito.kotlin.any(), org.mockito.kotlin.eq(0)) } doReturn null
+        }
+        val activity = activityWithPackageManager(packageManager)
+
+        assertNull(IntentUtils.getDefaultAppForMimeType(activity, "application/pdf"))
+    }
+
+    @Test
+    fun `getDefaultAppForMimeType returns null when resolution throws`() {
+        val packageManager: PackageManager = mock {
+            on { resolveActivity(org.mockito.kotlin.any(), org.mockito.kotlin.eq(0)) } doThrow RuntimeException("boom")
+        }
+        val activity = activityWithPackageManager(packageManager)
+
+        assertNull(IntentUtils.getDefaultAppForMimeType(activity, "application/pdf"))
+    }
+}