catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

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

@@ -0,0 +1,302 @@
+package io.yourname.androidproject
+
+import android.content.Context
+import android.net.Uri
+import android.webkit.CookieManager
+import org.junit.After
+import org.junit.Assert.assertFalse
+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.mockito.MockedStatic
+import org.mockito.Mockito.mockStatic
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+import java.io.File
+import kotlin.io.path.createTempDirectory
+
+/**
+ * #413: first Mockito-based test in this template, covering
+ * OfflineCacheService — previously untested because it takes a real
+ * android.content.Context in its constructor and calls the unmocked
+ * android.net.Uri / android.webkit.CookieManager Android-stub classes
+ * internally (JVM unit tests run against the SDK's stub jar, which throws
+ * on any call unless testOptions.unitTests.isReturnDefaultValues is set,
+ * or the class is mocked — see app/build.gradle.kts).
+ *
+ * Uri.parse(...) is mocked statically per test via Mockito's inline
+ * mock-maker (the mockito-core 5.x default) so isHttpUrl/isOfflineRouteUrl/
+ * shouldCacheAssetUrl exercise real logic against fake-but-realistic parsed
+ * URIs, rather than the SDK stub's default null/false behavior.
+ */
+class OfflineCacheServiceTest {
+
+    private lateinit var cacheDir: File
+    private lateinit var context: Context
+    private lateinit var uriMock: MockedStatic<Uri>
+    private lateinit var cookieManagerMock: MockedStatic<CookieManager>
+
+    @Before
+    fun setUp() {
+        cacheDir = createTempDirectory(prefix = "catalyst-offline-test").toFile()
+        context = mock {
+            on { getCacheDir() } doReturn cacheDir
+        }
+
+        uriMock = mockStatic(Uri::class.java)
+        uriMock.`when`<Uri> { Uri.parse(any()) }.thenAnswer { invocation ->
+            fakeUriFor(invocation.getArgument(0))
+        }
+
+        // CookieManager.getInstance() has no real webview in a JVM unit
+        // test; stub it to a mock that reports no cookies, matching what
+        // production sees on a fresh device before any cookies are set.
+        val cookieManager = mock<CookieManager> {
+            on { getCookie(any()) } doReturn null
+        }
+        cookieManagerMock = mockStatic(CookieManager::class.java)
+        cookieManagerMock.`when`<CookieManager> { CookieManager.getInstance() }.thenReturn(cookieManager)
+    }
+
+    @After
+    fun tearDown() {
+        uriMock.close()
+        cookieManagerMock.close()
+        cacheDir.deleteRecursively()
+    }
+
+    // A tiny fake of what Uri.parse() would return for the http(s) URLs
+    // this class actually deals with — just enough of the real contract
+    // (scheme/authority/path/fragment stripping) for the code under test.
+    private fun fakeUriFor(url: String): Uri {
+        val schemeEnd = url.indexOf("://")
+        val scheme = if (schemeEnd >= 0) url.substring(0, schemeEnd) else null
+        val afterScheme = if (schemeEnd >= 0) url.substring(schemeEnd + 3) else url
+        val pathStart = afterScheme.indexOf('/').let { if (it < 0) afterScheme.length else it }
+        val authority = if (schemeEnd >= 0) afterScheme.substring(0, pathStart) else null
+        val rawPath = afterScheme.substring(pathStart).substringBefore('#').ifEmpty { "/" }
+        val withoutFragment = url.substringBefore('#')
+
+        val withoutFragmentUri = mock<Uri>()
+        whenever(withoutFragmentUri.toString()) doReturn withoutFragment
+
+        val builder = mock<Uri.Builder>()
+        whenever(builder.fragment(org.mockito.kotlin.anyOrNull())) doReturn builder
+        whenever(builder.build()) doReturn withoutFragmentUri
+
+        val uri = mock<Uri>()
+        whenever(uri.scheme) doReturn scheme
+        whenever(uri.authority) doReturn authority
+        whenever(uri.path) doReturn rawPath
+        whenever(uri.toString()) doReturn withoutFragment
+        whenever(uri.buildUpon()) doReturn builder
+        return uri
+    }
+
+    @Test
+    fun `shouldCacheAssetUrl accepts known static-asset extensions over http(s)`() {
+        val service = OfflineCacheService(context)
+
+        assertTrue(service.shouldCacheAssetUrl("https://example.com/static/app.js"))
+        assertTrue(service.shouldCacheAssetUrl("https://example.com/static/app.CSS"))
+        assertFalse(service.shouldCacheAssetUrl("https://example.com/api/data"))
+    }
+
+    @Test
+    fun `shouldCacheAssetUrl rejects non-http(s) schemes`() {
+        val service = OfflineCacheService(context)
+
+        assertFalse(service.shouldCacheAssetUrl("file:///static/app.js"))
+    }
+
+    @Test
+    fun `hasRouteSnapshot is false when no manifest has been loaded`() {
+        val service = OfflineCacheService(context)
+
+        assertFalse(service.hasRouteSnapshot("https://example.com/some/route"))
+    }
+
+    @Test
+    fun `getRouteSnapshotResponse returns null when route is not offline-eligible`() {
+        val service = OfflineCacheService(context)
+
+        assertNull(service.getRouteSnapshotResponse("https://example.com/not-cached"))
+    }
+
+    @Test
+    fun `clearAll resets cached manifest state without throwing`() {
+        val service = OfflineCacheService(context)
+
+        service.clearAll()
+
+        assertFalse(service.hasRouteSnapshot("https://example.com/some/route"))
+        assertTrue(cacheDir.exists())
+    }
+
+    @Test
+    fun `context getCacheDir is consulted exactly once at construction`() {
+        OfflineCacheService(context)
+
+        org.mockito.kotlin.verify(context).getCacheDir()
+    }
+
+    // ============================================================
+    // Manifest-driven routing (batch 4 extension)
+    //
+    // The manifest is loaded once at construction time via
+    // loadCachedManifest() -> parseManifest(), reading a plain
+    // manifest.json file under context.cacheDir/catalyst_offline/ — no
+    // network involved. Pre-writing that file before constructing
+    // OfflineCacheService unlocks isOfflineRouteUrl/getRouteSnapshotResponse/
+    // hasRouteSnapshot's real-match branches, previously only exercised
+    // via their "no manifest loaded" empty-state paths above.
+    // ============================================================
+
+    private fun writeManifest(buildId: String, routes: List<Pair<String, String>>) {
+        val rootDir = File(cacheDir, "catalyst_offline")
+        rootDir.mkdirs()
+        val routesJson = routes.joinToString(",") { (pattern, regex) ->
+            """{"pattern":"$pattern","regex":"$regex"}"""
+        }
+        val json = """{"buildId":"$buildId","routes":[$routesJson]}"""
+        File(rootDir, "manifest.json").writeText(json)
+    }
+
+    @Test
+    fun `isOfflineRouteUrl matches a route whose regex matches the url path`() {
+        writeManifest("build-123", listOf("/docs/*" to "^/docs/.*$"))
+        val service = OfflineCacheService(context)
+
+        assertTrue(service.isOfflineRouteUrl("https://example.com/docs/getting-started"))
+    }
+
+    @Test
+    fun `isOfflineRouteUrl returns false when no route regex matches`() {
+        writeManifest("build-123", listOf("/docs/*" to "^/docs/.*$"))
+        val service = OfflineCacheService(context)
+
+        assertFalse(service.isOfflineRouteUrl("https://example.com/api/data"))
+    }
+
+    @Test
+    fun `isOfflineRouteUrl returns false for a non-http(s) url even with a loaded manifest`() {
+        writeManifest("build-123", listOf("/docs/*" to "^/docs/.*$"))
+        val service = OfflineCacheService(context)
+
+        assertFalse(service.isOfflineRouteUrl("file:///docs/local.html"))
+    }
+
+    @Test
+    fun `isOfflineRouteUrl treats an unparseable route regex as a non-match, not a crash`() {
+        // "[" is an invalid regex -- Regex(...).matches() should throw,
+        // caught internally and treated as "this route doesn't match"
+        // rather than propagating.
+        writeManifest("build-123", listOf("/broken" to "["))
+        val service = OfflineCacheService(context)
+
+        assertFalse(service.isOfflineRouteUrl("https://example.com/broken"))
+    }
+
+    @Test
+    fun `hasRouteSnapshot is true only when the route is eligible AND a snapshot file exists on disk`() {
+        writeManifest("build-123", listOf("/docs/*" to "^/docs/.*$"))
+        val service = OfflineCacheService(context)
+        val url = "https://example.com/docs/getting-started"
+
+        // Route is eligible per the manifest, but no snapshot has been
+        // written to disk yet.
+        assertFalse(service.hasRouteSnapshot(url))
+    }
+
+    private fun sha256Hex(value: String): String {
+        val digest = java.security.MessageDigest.getInstance("SHA-256").digest(value.toByteArray())
+        return digest.joinToString("") { "%02x".format(it) }
+    }
+
+    @Test
+    fun `getRouteSnapshotResponse serves a real snapshot file for an eligible, snapshotted route`() {
+        writeManifest("build-123", listOf("/docs/*" to "^/docs/.*$"))
+        val url = "https://example.com/docs/getting-started"
+
+        // snapshotFileForUrl/hash are private; reproduce their (simple,
+        // stable) SHA-256-based path layout here to place a snapshot file
+        // exactly where the production code will look for it:
+        //   routes/<hash(origin:buildId)>/<hash(normalizedUrl)>.html
+        val namespace = "https://example.com:build-123"
+        val namespaceDir = File(cacheDir, "catalyst_offline/routes/${sha256Hex(namespace)}")
+        namespaceDir.mkdirs()
+        File(namespaceDir, "${sha256Hex(url)}.html").writeText("<html>cached docs page</html>")
+
+        val service = OfflineCacheService(context)
+
+        // WebResourceResponse is an android.webkit SDK stub class: its
+        // constructor is a no-op under the mockable jar and its getters
+        // return defaults regardless of what was passed in (confirmed
+        // empirically earlier this session, see WebCacheManagerTest) --
+        // only "a response object was returned" is assertable here, not
+        // its field contents.
+        assertTrue(service.hasRouteSnapshot(url))
+        assertNotNull(service.getRouteSnapshotResponse(url))
+    }
+
+    @Test
+    fun `getRouteSnapshotResponse returns null when the route is eligible but no snapshot file exists yet`() {
+        writeManifest("build-123", listOf("/docs/*" to "^/docs/.*$"))
+        val service = OfflineCacheService(context)
+        val url = "https://example.com/docs/getting-started"
+
+        assertFalse(service.hasRouteSnapshot(url))
+        assertNull(service.getRouteSnapshotResponse(url))
+    }
+
+    @Test
+    fun `clearAll removes a manifest loaded from a previous instance`() {
+        writeManifest("build-123", listOf("/docs/*" to "^/docs/.*$"))
+        val service = OfflineCacheService(context)
+        assertTrue(service.isOfflineRouteUrl("https://example.com/docs/x"))
+
+        service.clearAll()
+
+        // manifest is nulled out by clearAll(); route matching should
+        // fall back to "no manifest" behavior immediately, in the same
+        // instance, without needing to reconstruct the service.
+        assertFalse(service.isOfflineRouteUrl("https://example.com/docs/x"))
+    }
+
+    @Test
+    fun `a second OfflineCacheService instance loads the manifest persisted by a previous one`() {
+        writeManifest("build-456", listOf("/blog/*" to "^/blog/.*$"))
+
+        // First instance's constructor already ran loadCachedManifest();
+        // this constructs a second instance against the SAME cacheDir to
+        // confirm the on-disk manifest.json (not just in-memory state) is
+        // what's actually being read.
+        OfflineCacheService(context)
+        val secondInstance = OfflineCacheService(context)
+
+        assertTrue(secondInstance.isOfflineRouteUrl("https://example.com/blog/post-1"))
+    }
+
+    @Test
+    fun `a malformed manifest json on disk is treated as no manifest, not a crash`() {
+        val rootDir = File(cacheDir, "catalyst_offline")
+        rootDir.mkdirs()
+        File(rootDir, "manifest.json").writeText("not valid json {{{")
+
+        val service = OfflineCacheService(context)
+
+        assertFalse(service.isOfflineRouteUrl("https://example.com/docs/x"))
+    }
+
+    @Test
+    fun `a manifest with an empty routes array loads without matching anything`() {
+        writeManifest("build-789", emptyList())
+        val service = OfflineCacheService(context)
+
+        assertFalse(service.isOfflineRouteUrl("https://example.com/anything"))
+    }
+}

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

@@ -0,0 +1,133 @@
+package io.yourname.androidproject
+
+import io.yourname.androidproject.utils.PerfEventBuffer
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Unit tests for PerfEventBuffer, previously entirely untested (0%).
+ *
+ * Scope: configure/isEnabled/add/bridgeCallReceived/bridgeCallDispatched/
+ * reset are exercised directly — pure state plus a ConcurrentLinkedQueue,
+ * no Handler/Looper dispatch involved. scheduleFlush/flushNow/
+ * startPeriodicFlush/the deliver-retry pipeline post through a real
+ * android.os.Handler(Looper.getMainLooper()) constructed at object-init
+ * time — Looper.getMainLooper() has no real Looper in a JVM unit test, so
+ * calling those methods either throws or silently never runs the posted
+ * work. Left uncovered here rather than chased with Robolectric, per the
+ * plan's Mockito-only scope.
+ *
+ * PerfEventBuffer is a singleton object — tests reset() in tearDown so
+ * state doesn't leak into other test classes running in the same JVM.
+ */
+class PerfEventBufferTest {
+
+    @Before
+    fun setUp() {
+        PerfEventBuffer.reset()
+    }
+
+    @After
+    fun tearDown() {
+        PerfEventBuffer.configure(enabled = false)
+        PerfEventBuffer.reset()
+    }
+
+    @Test
+    fun `configure(true) enables the buffer in a debug build`() {
+        // configure(true) only actually enables the buffer when
+        // BuildConfig.DEBUG is true — assert that precondition explicitly
+        // (via Assume) rather than just asserting isEnabled() and relying
+        // on an unchecked comment that this suite always runs under the
+        // debug variant. This task runs as testDebugUnitTest, so it does
+        // today, but making the check explicit means a future variant
+        // change surfaces as a skip, not a silent false-negative pass.
+        org.junit.Assume.assumeTrue(
+            "This test only applies to the debug variant",
+            io.yourname.androidproject.BuildConfig.DEBUG
+        )
+        PerfEventBuffer.configure(enabled = true)
+        assertTrue(PerfEventBuffer.isEnabled())
+    }
+
+    @Test
+    fun `configure(false) disables the buffer`() {
+        PerfEventBuffer.configure(enabled = true)
+        PerfEventBuffer.configure(enabled = false)
+        assertFalse(PerfEventBuffer.isEnabled())
+    }
+
+    @Test
+    fun `add is a no-op when disabled`() {
+        PerfEventBuffer.configure(enabled = false)
+        // Should not throw even though nothing is buffered.
+        PerfEventBuffer.add(JSONObject().apply { put("type", "test") })
+    }
+
+    @Test
+    fun `add does not throw when enabled`() {
+        PerfEventBuffer.configure(enabled = true)
+        PerfEventBuffer.add(JSONObject().apply { put("type", "test-event") })
+    }
+
+    @Test
+    fun `bridgeCallReceived followed by bridgeCallDispatched does not throw`() {
+        PerfEventBuffer.configure(enabled = true)
+
+        PerfEventBuffer.bridgeCallReceived("call-1", "getDeviceInfo")
+        PerfEventBuffer.bridgeCallDispatched("call-1")
+    }
+
+    @Test
+    fun `bridgeCallDispatched for an unknown callId is a no-op`() {
+        PerfEventBuffer.configure(enabled = true)
+
+        // No matching bridgeCallReceived — pendingCalls has no entry for
+        // "unknown-call", so this should return early without throwing.
+        PerfEventBuffer.bridgeCallDispatched("unknown-call")
+    }
+
+    @Test
+    fun `bridgeCallReceived and bridgeCallDispatched are no-ops when disabled`() {
+        PerfEventBuffer.configure(enabled = false)
+
+        PerfEventBuffer.bridgeCallReceived("call-1", "getDeviceInfo")
+        PerfEventBuffer.bridgeCallDispatched("call-1")
+    }
+
+    @Test
+    fun `reset disables flushed state and clears without throwing`() {
+        PerfEventBuffer.configure(enabled = true)
+        PerfEventBuffer.add(JSONObject().apply { put("type", "test") })
+
+        PerfEventBuffer.reset()
+
+        // Buffer cleared, no exception — isEnabled() state is untouched by
+        // reset() itself (only configure() changes it).
+        assertTrue(PerfEventBuffer.isEnabled())
+    }
+
+    @Test
+    fun `add with a cache-hit-memory type does not throw while updating the cache summary tally`() {
+        PerfEventBuffer.configure(enabled = true)
+
+        PerfEventBuffer.add(JSONObject().apply {
+            put("type", "cache-hit-memory")
+            put("url", "https://example.com/app.js")
+        })
+    }
+
+    @Test
+    fun `add with a network-fetch-complete type does not throw while updating the top-slow tracker`() {
+        PerfEventBuffer.configure(enabled = true)
+
+        PerfEventBuffer.add(JSONObject().apply {
+            put("type", "network-fetch-complete")
+            put("url", "https://example.com/big-asset.bin")
+            put("durationMs", 1234)
+        })
+    }
+}

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

@@ -0,0 +1,152 @@
+package io.yourname.androidproject
+
+import android.net.Uri
+import org.junit.After
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+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.mock
+import org.mockito.kotlin.whenever
+
+/**
+ * Unit tests for the top-level matchesCachePattern function in Utils.kt
+ * (Android coverage batch 4), previously entirely untested (0/18 lines,
+ * reported under the synthetic class name UtilsKt in jacoco).
+ *
+ * matchesCachePattern calls android.net.Uri.parse(url) internally, which
+ * returns null under the mockable android.jar (isReturnDefaultValues=true)
+ * unless statically mocked -- following the exact Uri.parse mockStatic
+ * pattern established in OfflineCacheServiceTest. Unlike that fake, this
+ * one only needs Uri.path stubbed (matchesCachePattern reads nothing else
+ * off the parsed Uri), and it deliberately strips both '?' and '#' when
+ * deriving the path -- matching what the real Uri.parse/getPath contract
+ * does (query and fragment are never part of getPath()), which is required
+ * for the KDoc's own "?v=123" and "#section" examples to actually match.
+ *
+ * Covered: the empty-cachePatterns short-circuit, the null-path guard (via
+ * a designated fake Uri with a null path), wildcard (*) pattern matching
+ * including hashed/versioned filenames and query/fragment stripping,
+ * case-insensitivity, exact (non-wildcard) pattern matching, and the
+ * empty-filename guard (trailing-slash URL). Not covered: the outer
+ * try/catch's Exception branch -- Uri.parse is mocked to never throw here,
+ * and the real Android Uri.parse implementation practically never throws
+ * (it does lenient parsing), so there is no reachable production input that
+ * exercises that branch; this mirrors DownloadUtilsTest's documented stance
+ * on similar defensively-written but practically unreachable catch blocks.
+ */
+class UtilsKtTest {
+
+    private lateinit var uriMock: MockedStatic<Uri>
+
+    @Before
+    fun setUp() {
+        uriMock = mockStatic(Uri::class.java)
+        uriMock.`when`<Uri> { Uri.parse(any()) }.thenAnswer { invocation ->
+            fakeUriFor(invocation.getArgument(0))
+        }
+    }
+
+    @After
+    fun tearDown() {
+        uriMock.close()
+    }
+
+    // Minimal fake of what Uri.parse(url).path would return: everything
+    // after the authority, with query params and fragment stripped, same
+    // as the real android.net.Uri contract. A url containing the sentinel
+    // "NULLPATH" simulates a Uri whose path is null (e.g. an opaque URI),
+    // to exercise matchesCachePattern's `?: return false` guard.
+    private fun fakeUriFor(url: String): Uri {
+        val uri = mock<Uri>()
+        if (url.contains("NULLPATH")) {
+            whenever(uri.path).thenReturn(null)
+            return uri
+        }
+        val schemeEnd = url.indexOf("://")
+        val afterScheme = if (schemeEnd >= 0) url.substring(schemeEnd + 3) else url
+        val pathStart = afterScheme.indexOf('/').let { if (it < 0) afterScheme.length else it }
+        val rawPath = afterScheme.substring(pathStart)
+            .substringBefore('?')
+            .substringBefore('#')
+        whenever(uri.path).thenReturn(rawPath.ifEmpty { "/" })
+        return uri
+    }
+
+    @Test
+    fun `returns false immediately when cachePatterns is empty`() {
+        assertFalse(matchesCachePattern("https://example.com/app.css", emptyList()))
+    }
+
+    @Test
+    fun `returns false when the parsed uri has a null path`() {
+        assertFalse(matchesCachePattern("opaque:NULLPATH", listOf("*.css")))
+    }
+
+    @Test
+    fun `wildcard pattern matches a plain filename`() {
+        assertTrue(matchesCachePattern("http://example.com/app.css", listOf("*.css")))
+    }
+
+    @Test
+    fun `wildcard pattern matches a hashed versioned filename`() {
+        assertTrue(matchesCachePattern("http://example.com/app.d4e5dea6.css", listOf("*.css")))
+    }
+
+    @Test
+    fun `wildcard pattern matches with query parameters stripped`() {
+        assertTrue(matchesCachePattern("http://example.com/app.css?v=123", listOf("*.css")))
+    }
+
+    @Test
+    fun `wildcard pattern matches with a fragment stripped`() {
+        assertTrue(matchesCachePattern("http://example.com/path/to/style.css#section", listOf("*.css")))
+    }
+
+    @Test
+    fun `wildcard pattern matches js bundle variants`() {
+        assertTrue(matchesCachePattern("http://example.com/bundle.js", listOf("*.js")))
+        assertTrue(matchesCachePattern("http://example.com/bundle.abc123.js", listOf("*.js")))
+        assertTrue(matchesCachePattern("http://example.com/bundle.js?t=456", listOf("*.js")))
+    }
+
+    @Test
+    fun `wildcard pattern matching is case-insensitive`() {
+        assertTrue(matchesCachePattern("http://example.com/APP.CSS", listOf("*.css")))
+        assertTrue(matchesCachePattern("http://example.com/app.css", listOf("*.CSS")))
+    }
+
+    @Test
+    fun `wildcard pattern does not match an unrelated extension`() {
+        assertFalse(matchesCachePattern("http://example.com/app.png", listOf("*.css")))
+    }
+
+    @Test
+    fun `exact pattern matches full filename case-insensitively`() {
+        assertTrue(matchesCachePattern("http://example.com/manifest.json", listOf("manifest.json")))
+        assertTrue(matchesCachePattern("http://example.com/MANIFEST.JSON", listOf("manifest.json")))
+    }
+
+    @Test
+    fun `exact pattern does not match a different filename`() {
+        assertFalse(matchesCachePattern("http://example.com/other.json", listOf("manifest.json")))
+    }
+
+    @Test
+    fun `returns false when the path has an empty filename (trailing slash)`() {
+        assertFalse(matchesCachePattern("http://example.com/", listOf("*.css")))
+    }
+
+    @Test
+    fun `matches if any pattern in the list matches`() {
+        assertTrue(matchesCachePattern("http://example.com/app.css", listOf("*.js", "*.css", "*.png")))
+    }
+
+    @Test
+    fun `returns false when no pattern in the list matches`() {
+        assertFalse(matchesCachePattern("http://example.com/app.css", listOf("*.js", "*.png")))
+    }
+}