Align cache strategies and add regression coverage

Author: afreakyelf

app/build.gradle.kts

@@ -140,6 +140,7 @@ dependencies {
     androidTestImplementation("androidx.test.espresso:espresso-core:3.6.1")
     androidTestImplementation("androidx.test:rules:1.6.1")
     androidTestImplementation("androidx.test:runner:1.6.1")
+    androidTestImplementation("com.squareup.okhttp3:mockwebserver:4.12.0")
 
 
     // Optional - Integration with activities

app/src/androidTest/java/com/rajat/pdfviewer/BasePdfViewerTest.kt

@@ -3,7 +3,15 @@ package com.rajat.pdfviewer
 import android.content.Context
 import androidx.test.core.app.ActivityScenario
 import androidx.test.core.app.ApplicationProvider
+import androidx.test.platform.app.InstrumentationRegistry
+import com.rajat.pdfviewer.util.CacheManager
+import com.rajat.pdfviewer.util.CacheStrategy
 import com.rajat.pdfviewer.util.saveTo
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import okio.Buffer
 import java.io.File
 
 abstract class BasePdfViewerTest {
@@ -23,32 +31,84 @@ abstract class BasePdfViewerTest {
     protected fun launchPdfFromUrl(
         url: String = sampleUrl,
         title: String = "Remote PDF",
-        enableDownload: Boolean = true
+        enableDownload: Boolean = true,
+        cacheStrategy: CacheStrategy = CacheStrategy.MAXIMIZE_PERFORMANCE
     ): ActivityScenario<PdfViewerActivity> {
         val intent = PdfViewerActivity.launchPdfFromUrl(
             context = context,
             pdfUrl = url,
             pdfTitle = title,
             saveTo = saveTo.DOWNLOADS,
-            enableDownload = enableDownload
+            enableDownload = enableDownload,
+            cacheStrategy = cacheStrategy
         )
         return ActivityScenario.launch(intent)
     }
 
     protected fun launchPdfFromAssets(
         assetName: String = samplePdf,
         title: String = "PDF From Asset",
-        enableZoom: Boolean = true
+        enableZoom: Boolean = true,
+        cacheStrategy: CacheStrategy = CacheStrategy.MAXIMIZE_PERFORMANCE
     ): ActivityScenario<PdfViewerActivity> {
         val file = copyAssetPdfToCache(assetName)
+        return launchPdfFromFile(
+            file = file,
+            title = title,
+            enableZoom = enableZoom,
+            cacheStrategy = cacheStrategy
+        )
+    }
+
+    protected fun launchPdfFromFile(
+        file: File,
+        title: String = "PDF From File",
+        enableZoom: Boolean = true,
+        cacheStrategy: CacheStrategy = CacheStrategy.MAXIMIZE_PERFORMANCE
+    ): ActivityScenario<PdfViewerActivity> {
         val intent = PdfViewerActivity.launchPdfFromPath(
             context = context,
             path = file.absolutePath,
             pdfTitle = title,
             saveTo = saveTo.DOWNLOADS,
             fromAssets = false,
-            enableZoom = enableZoom
+            enableZoom = enableZoom,
+            cacheStrategy = cacheStrategy
         )
         return ActivityScenario.launch(intent)
     }
+
+    protected fun clearPdfCacheRoot() {
+        File(context.cacheDir, CacheManager.CACHE_PATH).deleteRecursively()
+    }
+
+    // Hermetic remote-cache tests use a local HTTP server so they don't depend on public hosts.
+    protected fun startPdfServer(assetName: String = samplePdf): MockWebServer {
+        val pdfBytes = context.assets.open(assetName).use { it.readBytes() }
+        return MockWebServer().apply {
+            dispatcher = object : Dispatcher() {
+                override fun dispatch(request: RecordedRequest): MockResponse {
+                    return MockResponse()
+                        .setResponseCode(200)
+                        .setHeader("Content-Type", "application/pdf")
+                        .setBody(Buffer().write(pdfBytes))
+                }
+            }
+            start()
+        }
+    }
+
+    protected fun waitForTestCondition(
+        timeoutMs: Long = 10_000,
+        intervalMs: Long = 100,
+        condition: () -> Boolean
+    ) {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (System.currentTimeMillis() < deadline) {
+            InstrumentationRegistry.getInstrumentation().waitForIdleSync()
+            if (condition()) return
+            Thread.sleep(intervalMs)
+        }
+        check(condition()) { "Condition not met within ${timeoutMs}ms" }
+    }
 }