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

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

@@ -0,0 +1,471 @@
+package io.yourname.androidproject
+
+import android.app.Activity
+import android.content.ContentResolver
+import android.net.Uri
+import android.util.Base64
+import android.webkit.MimeTypeMap
+import android.webkit.WebView
+import io.yourname.androidproject.utils.FileSizeRouterUtils
+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.MockedStatic
+import org.mockito.Mockito.mockStatic
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.doThrow
+import org.mockito.kotlin.mock
+import kotlin.io.path.createTempDirectory
+
+/**
+ * Unit tests for FileSizeRouterUtils, previously entirely untested (0%).
+ *
+ * determineTransport/getMimeType/formatFileSize operate on plain
+ * java.io.File and don't need a Context, so they're exercised directly
+ * against real temp files.
+ *
+ * processFile's three transport branches (added in a later pass):
+ *
+ * IMPORTANT, confirmed empirically: Mockito.mockStatic only intercepts
+ * genuine JVM static methods (Java classes like android.jar's Uri/
+ * Base64/MimeTypeMap). FileUtils/FrameworkServerUtils/IntentUtils are
+ * Kotlin `object`s — their "static-looking" members compile to instance
+ * methods on a singleton INSTANCE field, which mockStatic cannot
+ * intercept (attempting it throws MissingMethodInvocationException,
+ * since the real method runs instead of a mock). The PluginBridge
+ * coverage pass hit the identical wall with GeneratedPluginIndex. Real
+ * objects are used below instead, matching FrameworkServerUtilsTest's
+ * own established pattern (a real embedded server, not a mock):
+ * - processViaBridge: real FileUtils.convertUriToBase64 with a mocked
+ *   Context/ContentResolver — Uri.fromFile and Base64.encodeToString are
+ *   genuine android.jar statics, mockStatic'd normally.
+ * - processViaFrameworkServer: the real FrameworkServerUtils object,
+ *   started/stopped exactly as FrameworkServerUtilsTest.kt does (shared
+ *   JVM-wide singleton state — defensive stopServer() in both setUp and
+ *   tearDown so this class can't leak state into/from that one
+ *   depending on JVM test-class execution order).
+ * - processViaContentProvider: IntentUtils.createFileProviderUri needs
+ *   real FileProvider manifest metadata to succeed, which isn't
+ *   available in a JVM unit test — only its failure/exception paths
+ *   (non-Activity context, and a real call that throws) are covered;
+ *   the success path is Robolectric/instrumented-test territory.
+ */
+class FileSizeRouterUtilsTest {
+
+    private lateinit var tempDir: java.io.File
+    private lateinit var mimeTypeMapMock: MockedStatic<MimeTypeMap>
+
+    @Before
+    fun setUp() {
+        tempDir = createTempDirectory(prefix = "catalyst-router-test").toFile()
+
+        val mimeTypeMap: MimeTypeMap = mock {
+            // Mockito's stub-matching is most-recent-wins for overlapping
+            // matchers — the any() catch-all must be stubbed first so the
+            // specific "txt"/"jpg" stubs below take precedence for those
+            // exact arguments.
+            on { getMimeTypeFromExtension(org.mockito.kotlin.any()) } doReturn null
+            on { getMimeTypeFromExtension("txt") } doReturn "text/plain"
+            on { getMimeTypeFromExtension("jpg") } doReturn "image/jpeg"
+        }
+        mimeTypeMapMock = mockStatic(MimeTypeMap::class.java)
+        mimeTypeMapMock.`when`<MimeTypeMap> { MimeTypeMap.getSingleton() } doReturn mimeTypeMap
+
+        // FrameworkServerUtils is a JVM-wide singleton object; stop it
+        // defensively before each test so this class can't inherit
+        // running-server state left by FrameworkServerUtilsTest (or any
+        // other test class) depending on JVM test-class execution order.
+        FrameworkServerUtils.stopServer()
+    }
+
+    @After
+    fun tearDown() {
+        mimeTypeMapMock.close()
+        FrameworkServerUtils.stopServer()
+        tempDir.deleteRecursively()
+    }
+
+    private fun fileOfSize(name: String, bytes: Int): java.io.File {
+        val file = java.io.File(tempDir, name)
+        file.writeBytes(ByteArray(bytes))
+        return file
+    }
+
+    // ============================================================
+    // determineTransport
+    // ============================================================
+
+    @Test
+    fun `determineTransport reports UNSUPPORTED and cannot proceed for a missing file`() {
+        val missing = java.io.File(tempDir, "does-not-exist.txt")
+
+        val decision = FileSizeRouterUtils.determineTransport(missing)
+
+        assertEquals(FileSizeRouterUtils.TransportType.UNSUPPORTED, decision.transportType)
+        assertFalse(decision.canProceed)
+        assertEquals("Selected file no longer exists", decision.errorMessage)
+    }
+
+    @Test
+    fun `determineTransport routes a small file to BRIDGE_BASE64`() {
+        val file = fileOfSize("small.txt", 1024) // 1 KB, well under 2MB
+
+        val decision = FileSizeRouterUtils.determineTransport(file)
+
+        assertEquals(FileSizeRouterUtils.TransportType.BRIDGE_BASE64, decision.transportType)
+        assertTrue(decision.canProceed)
+        assertEquals("text/plain", decision.mimeType)
+        assertEquals(1024L, decision.fileSize)
+    }
+
+    @Test
+    fun `determineTransport routes a file just over the bridge threshold to CONTENT_PROVIDER when server is not running`() {
+        val file = fileOfSize("medium.jpg", FileSizeRouterUtils.MAX_BRIDGE_SIZE + 1)
+
+        val decision = FileSizeRouterUtils.determineTransport(file)
+
+        // FrameworkServerUtils.isRunning() is false by default (no server
+        // started anywhere in this test), so the >2MB branch falls back to
+        // CONTENT_PROVIDER rather than FRAMEWORK_SERVER.
+        assertEquals(FileSizeRouterUtils.TransportType.CONTENT_PROVIDER, decision.transportType)
+        assertTrue(decision.canProceed)
+    }
+
+    @Test
+    fun `MAX_SERVER_SIZE boundary exceeds MAX_BRIDGE_SIZE and a small file still routes to BRIDGE_BASE64`() {
+        // Not a real >100MB UNSUPPORTED case (impractical to allocate that
+        // much on disk in a unit test) -- this only asserts the threshold
+        // ordering the UNSUPPORTED branch depends on, plus that a small
+        // file's routing stays correct/unaffected by that boundary's
+        // existence. Renamed from a name that claimed to test the
+        // >100MB UNSUPPORTED path, which it never actually exercised.
+        val file = fileOfSize("huge.bin", 100) // real size doesn't matter, but must exist
+        assertTrue(FileSizeRouterUtils.MAX_SERVER_SIZE > FileSizeRouterUtils.MAX_BRIDGE_SIZE)
+
+        val decision = FileSizeRouterUtils.determineTransport(file)
+        assertEquals(FileSizeRouterUtils.TransportType.BRIDGE_BASE64, decision.transportType)
+    }
+
+    // ============================================================
+    // getMimeType
+    // ============================================================
+
+    @Test
+    fun `getMimeType resolves via MimeTypeMap when the extension is known`() {
+        val file = fileOfSize("photo.jpg", 10)
+        assertEquals("image/jpeg", FileSizeRouterUtils.getMimeType(file))
+    }
+
+    @Test
+    fun `getMimeType falls back to the office-document table for docx`() {
+        val file = fileOfSize("report.docx", 10)
+        assertEquals(
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            FileSizeRouterUtils.getMimeType(file)
+        )
+    }
+
+    @Test
+    fun `getMimeType falls back to octet-stream for a fully unknown extension`() {
+        val file = fileOfSize("mystery.xyz123", 10)
+        assertEquals("application/octet-stream", FileSizeRouterUtils.getMimeType(file))
+    }
+
+    // ============================================================
+    // formatFileSize
+    // ============================================================
+
+    @Test
+    fun `formatFileSize formats bytes without a decimal point`() {
+        assertEquals("512 B", FileSizeRouterUtils.formatFileSize(512))
+    }
+
+    @Test
+    fun `formatFileSize formats kilobytes with one decimal place`() {
+        assertEquals("2.0 KB", FileSizeRouterUtils.formatFileSize(2048))
+    }
+
+    @Test
+    fun `formatFileSize formats megabytes and gigabytes correctly`() {
+        assertEquals("5.0 MB", FileSizeRouterUtils.formatFileSize(5L * 1024 * 1024))
+        assertEquals("1.0 GB", FileSizeRouterUtils.formatFileSize(1024L * 1024 * 1024))
+    }
+
+    // ============================================================
+    // processFile — early return when the decision cannot proceed
+    // ============================================================
+
+    @Test
+    fun `processFile returns a failure result immediately when the decision cannot proceed`() {
+        val decision = FileSizeRouterUtils.determineTransport(java.io.File(tempDir, "does-not-exist.txt"))
+        val context: android.content.Context = mock()
+        val webView: WebView = mock()
+
+        val result = FileSizeRouterUtils.processFile(context, webView, decision)
+
+        assertFalse(result.success)
+        assertEquals(decision.errorMessage, result.error)
+        assertNull(result.fileSrc)
+    }
+
+    // ============================================================
+    // processFile — BRIDGE_BASE64 branch (processViaBridge)
+    //
+    // FileUtils is a real object (Kotlin objects can't be mockStatic'd,
+    // see class header) -- convertUriToBase64 is driven for real via a
+    // mocked Context.contentResolver. Uri.fromFile and Base64.encodeToString
+    // are genuine android.jar statics, mockStatic'd normally.
+    // ============================================================
+
+    @Test
+    fun `processFile via bridge succeeds when the content resolver returns real bytes`() {
+        val file = fileOfSize("small.txt", 100)
+        val decision = FileSizeRouterUtils.determineTransport(file)
+        assertEquals(FileSizeRouterUtils.TransportType.BRIDGE_BASE64, decision.transportType)
+
+        val fakeUri: Uri = mock()
+        val resolver: ContentResolver = mock {
+            on { openInputStream(fakeUri) } doReturn java.io.ByteArrayInputStream("hello".toByteArray())
+        }
+        val context: android.content.Context = mock {
+            on { getContentResolver() } doReturn resolver
+        }
+        val webView: WebView = mock()
+
+        val uriMock = mockStatic(Uri::class.java)
+        val base64Mock = mockStatic(Base64::class.java)
+        try {
+            uriMock.`when`<Uri> { Uri.fromFile(file) }.thenReturn(fakeUri)
+            base64Mock.`when`<String> { Base64.encodeToString(any(), any()) }.thenReturn("aGVsbG8=")
+
+            val result = FileSizeRouterUtils.processFile(context, webView, decision)
+
+            assertTrue(result.success)
+            assertEquals(FileSizeRouterUtils.TransportType.BRIDGE_BASE64, result.transportUsed)
+            assertEquals("data:${decision.mimeType};base64,aGVsbG8=", result.fileSrc)
+        } finally {
+            uriMock.close()
+            base64Mock.close()
+        }
+    }
+
+    @Test
+    fun `processFile via bridge fails when the content resolver cannot open the uri`() {
+        val file = fileOfSize("small.txt", 100)
+        val decision = FileSizeRouterUtils.determineTransport(file)
+
+        val fakeUri: Uri = mock()
+        val resolver: ContentResolver = mock {
+            on { openInputStream(fakeUri) } doReturn null
+        }
+        val context: android.content.Context = mock {
+            on { getContentResolver() } doReturn resolver
+        }
+        val webView: WebView = mock()
+
+        val uriMock = mockStatic(Uri::class.java)
+        try {
+            uriMock.`when`<Uri> { Uri.fromFile(file) }.thenReturn(fakeUri)
+
+            val result = FileSizeRouterUtils.processFile(context, webView, decision)
+
+            assertFalse(result.success)
+            assertEquals(FileSizeRouterUtils.TransportType.BRIDGE_BASE64, result.transportUsed)
+            assertNull(result.fileSrc)
+            assertNotNull(result.error)
+        } finally {
+            uriMock.close()
+        }
+    }
+
+    @Test
+    fun `processFile via bridge fails gracefully when the content resolver throws`() {
+        val file = fileOfSize("small.txt", 100)
+        val decision = FileSizeRouterUtils.determineTransport(file)
+
+        val fakeUri: Uri = mock()
+        val resolver: ContentResolver = mock {
+            on { openInputStream(fakeUri) } doThrow RuntimeException("permission denied")
+        }
+        val context: android.content.Context = mock {
+            on { getContentResolver() } doReturn resolver
+        }
+        val webView: WebView = mock()
+
+        val uriMock = mockStatic(Uri::class.java)
+        try {
+            uriMock.`when`<Uri> { Uri.fromFile(file) }.thenReturn(fakeUri)
+
+            val result = FileSizeRouterUtils.processFile(context, webView, decision)
+
+            assertFalse(result.success)
+            assertNotNull(result.error)
+        } finally {
+            uriMock.close()
+        }
+    }
+
+    // ============================================================
+    // processFile — FRAMEWORK_SERVER branch (processViaFrameworkServer)
+    //
+    // FrameworkServerUtils is a real, JVM-wide singleton object (can't be
+    // mockStatic'd, see class header) -- started/stopped exactly as
+    // FrameworkServerUtilsTest.kt does. Defensive stop in both setUp and
+    // tearDown so shared server state can't leak across test classes.
+    // ============================================================
+
+    @Test
+    fun `processFile via framework server succeeds against a real running server`() {
+        FrameworkServerUtils.stopServer()
+        try {
+            val file = fileOfSize("bigfile.bin", 3 * 1024 * 1024) // 3MB, over bridge threshold
+            val serverContext: android.content.Context = mock { on { getCacheDir() } doReturn tempDir }
+            val serverWebView: WebView = mock { on { getUrl() } doReturn "http://localhost:8080/index.html" }
+            // If the real bind fails in this environment (port contention
+            // on a shared CI runner), skip rather than fail confusingly on
+            // a downstream assertion -- matches FrameworkServerUtilsTest's
+            // own Assume-based tolerance for the same startServer() call.
+            org.junit.Assume.assumeTrue(
+                "Framework server failed to start in this environment — skipping",
+                FrameworkServerUtils.startServer(serverContext, serverWebView)
+            )
+
+            val decision = FileSizeRouterUtils.determineTransport(file)
+            assertEquals(FileSizeRouterUtils.TransportType.FRAMEWORK_SERVER, decision.transportType)
+
+            val context: android.content.Context = mock()
+            val webView: WebView = mock()
+            val result = FileSizeRouterUtils.processFile(context, webView, decision)
+
+            assertTrue(result.success)
+            assertEquals(FileSizeRouterUtils.TransportType.FRAMEWORK_SERVER, result.transportUsed)
+            assertNotNull(result.fileSrc)
+            assertTrue(result.fileSrc!!.startsWith("http://"))
+        } finally {
+            FrameworkServerUtils.stopServer()
+        }
+    }
+
+    @Test
+    fun `processFile via framework server fails when copyAndServeFile is called while stopped`() {
+        // Construct a FRAMEWORK_SERVER decision directly (determineTransport
+        // itself would route to CONTENT_PROVIDER once the server is
+        // confirmed stopped) to exercise processViaFrameworkServer's own
+        // failure branch: copyAndServeFile returns null when
+        // !isServerRunning, independent of how the decision was reached.
+        FrameworkServerUtils.stopServer()
+        try {
+            assertFalse(FrameworkServerUtils.isRunning())
+            val file = fileOfSize("bigfile.bin", 3 * 1024 * 1024)
+            val decision = FileSizeRouterUtils.FileRoutingDecision(
+                transportType = FileSizeRouterUtils.TransportType.FRAMEWORK_SERVER,
+                file = file,
+                fileName = file.name,
+                mimeType = "application/octet-stream",
+                fileSize = file.length(),
+                reason = "forced for test"
+            )
+
+            val context: android.content.Context = mock()
+            val webView: WebView = mock()
+            val result = FileSizeRouterUtils.processFile(context, webView, decision)
+
+            assertFalse(result.success)
+            assertNull(result.fileSrc)
+            assertNotNull(result.error)
+        } finally {
+            FrameworkServerUtils.stopServer()
+        }
+    }
+
+    // ============================================================
+    // processFile — CONTENT_PROVIDER branch (processViaContentProvider)
+    //
+    // IntentUtils.createFileProviderUri needs real FileProvider manifest
+    // metadata to succeed -- not available in a JVM unit test, so only
+    // its failure paths are covered here (non-Activity context, and a
+    // real call against a mocked Activity that throws for lack of
+    // provider registration). The success path is Robolectric/
+    // instrumented-test territory.
+    // ============================================================
+
+    @Test
+    fun `processFile via content provider fails when context is not an Activity`() {
+        FrameworkServerUtils.stopServer()
+        try {
+            val file = fileOfSize("bigfile.bin", 3 * 1024 * 1024)
+            val decision = FileSizeRouterUtils.determineTransport(file)
+            assertEquals(FileSizeRouterUtils.TransportType.CONTENT_PROVIDER, decision.transportType)
+
+            val nonActivityContext: android.content.Context = mock()
+            val webView: WebView = mock()
+
+            val result = FileSizeRouterUtils.processFile(nonActivityContext, webView, decision)
+
+            assertFalse(result.success)
+            assertTrue(result.error?.contains("Activity context") == true)
+        } finally {
+            FrameworkServerUtils.stopServer()
+        }
+    }
+
+    @Test
+    fun `processFile via content provider fails gracefully when the real call throws`() {
+        FrameworkServerUtils.stopServer()
+        try {
+            val file = fileOfSize("bigfile.bin", 3 * 1024 * 1024)
+            val decision = FileSizeRouterUtils.determineTransport(file)
+            assertEquals(FileSizeRouterUtils.TransportType.CONTENT_PROVIDER, decision.transportType)
+
+            // A mocked Activity has no real FileProvider manifest entry --
+            // IntentUtils.createFileProviderUri's real call against it is
+            // expected to throw, exercising the catch branch.
+            val activity: Activity = mock()
+            val webView: WebView = mock()
+
+            val result = FileSizeRouterUtils.processFile(activity, webView, decision)
+
+            assertFalse(result.success)
+            assertEquals(FileSizeRouterUtils.TransportType.CONTENT_PROVIDER, result.transportUsed)
+            assertNull(result.fileSrc)
+            assertNotNull(result.error)
+        } finally {
+            FrameworkServerUtils.stopServer()
+        }
+    }
+
+    // ============================================================
+    // processFile — UNSUPPORTED branch (the `else` in the when block)
+    // ============================================================
+
+    @Test
+    fun `processFile returns not-supported for an UNSUPPORTED decision that still has canProceed true`() {
+        // determineTransport never actually produces canProceed=true with
+        // UNSUPPORTED (the >100MB case sets canProceed=false, hitting the
+        // early-return branch tested above) -- this constructs that
+        // otherwise-unreachable combination directly to exercise
+        // processFile's own `when` branch for TransportType.UNSUPPORTED,
+        // which is defensive dead code from determineTransport's callers
+        // but still real code in processFile itself.
+        val file = fileOfSize("weird.bin", 10)
+        val decision = FileSizeRouterUtils.FileRoutingDecision(
+            transportType = FileSizeRouterUtils.TransportType.UNSUPPORTED,
+            file = file,
+            fileName = file.name,
+            mimeType = "application/octet-stream",
+            fileSize = 10,
+            reason = "forced for test",
+            canProceed = true
+        )
+
+        val context: android.content.Context = mock()
+        val webView: WebView = mock()
+        val result = FileSizeRouterUtils.processFile(context, webView, decision)
+
+        assertFalse(result.success)
+        assertEquals("Transport not supported", result.error)
+    }
+}