@hot-updater/react-native 0.36.7 → 1.0.0-rc.0

package/android/src/test/java/com/hotupdater/BundleFileStorageServiceTest.kt

@@ -153,7 +153,9 @@ class BundleFileStorageServiceTest {
         assertFalse(selection.shouldRollbackOnCrash)
         assertFalse(stagingDir.exists())
         assertEquals("RECOVERED", report["status"])
-        assertEquals(stagingDir.name, report["crashedBundleId"])
+        assertEquals(stagingDir.name, report["fromBundleId"])
+        assertEquals(stableDir.name, report["toBundleId"])
+        assertEquals("appVersion", report["updateStrategy"])
 
         val metadata = loadMetadata(rootDir)
         assertNotNull(metadata)
@@ -192,7 +194,9 @@ class BundleFileStorageServiceTest {
         assertFalse(selection.shouldRollbackOnCrash)
         assertFalse(stagingDir.exists())
         assertEquals("RECOVERED", report["status"])
-        assertEquals(stagingDir.name, report["crashedBundleId"])
+        assertEquals(stagingDir.name, report["fromBundleId"])
+        assertEquals(HotUpdaterImpl.getMinBundleId(), report["toBundleId"])
+        assertEquals("appVersion", report["updateStrategy"])
     }
 
     @Test
@@ -244,6 +248,97 @@ class BundleFileStorageServiceTest {
         assertEquals(stagingDir.name, service.getBundleId())
     }
 
+    @Test
+    fun `markLaunchCompleted records update applied transition`() {
+        val rootDir = temporaryFolder.newFolder("update-applied-transition")
+        val service = createService(rootDir)
+
+        val stableDir = createBundleDir(rootDir, "stable-bundle")
+        writeFile(stableDir, "index.android.bundle")
+        writeManifest(stableDir, listOf("index.android.bundle"))
+
+        val stagingDir = createBundleDir(rootDir, "staging-bundle")
+        writeFile(stagingDir, "index.android.bundle")
+        writeManifest(stagingDir, listOf("index.android.bundle"))
+
+        writeMetadata(
+            rootDir,
+            BundleMetadata(
+                isolationKey = TEST_ISOLATION_KEY,
+                stableBundleId = stableDir.name,
+                stagingBundleId = stagingDir.name,
+                verificationPending = true,
+            ),
+        )
+
+        assertEquals(mapOf("status" to "PENDING"), service.notifyAppReady())
+
+        service.markLaunchCompleted(stagingDir.name)
+
+        assertEquals(
+            mapOf(
+                "status" to "UPDATE_APPLIED",
+                "fromBundleId" to stableDir.name,
+                "toBundleId" to stagingDir.name,
+                "updateStrategy" to "appVersion",
+            ),
+            service.notifyAppReady(),
+        )
+    }
+
+    @Test
+    fun `install identity persists across service instances and user clear keeps install id`() {
+        val rootDir = temporaryFolder.newFolder("install-identity")
+        val firstService = createService(rootDir)
+
+        val firstInstallId = firstService.getInstallId()
+        assertTrue(firstInstallId.isNotBlank())
+
+        firstService.setUser("user-123", "alice")
+        assertEquals(
+            InstallationIdentity(
+                installId = firstInstallId,
+                userId = "user-123",
+                username = "alice",
+            ),
+            loadInstallationIdentity(rootDir),
+        )
+
+        val restartedService = createService(rootDir)
+        assertEquals(firstInstallId, restartedService.getInstallId())
+
+        restartedService.setUser(null, null)
+        assertEquals(
+            InstallationIdentity(
+                installId = firstInstallId,
+                userId = null,
+                username = null,
+            ),
+            loadInstallationIdentity(rootDir),
+        )
+    }
+
+    @Test
+    fun `user update keeps cached install id when persisted identity becomes unreadable`() {
+        val rootDir = temporaryFolder.newFolder("install-identity-corruption")
+        val service = createService(rootDir)
+        val installId = service.getInstallId()
+        val identityFile = File(bundleStoreDir(rootDir), InstallationIdentity.IDENTITY_FILENAME)
+        identityFile.writeText("{")
+
+        service.setUser("user-123", "alice")
+
+        assertEquals(installId, service.getInstallId())
+        assertEquals(
+            InstallationIdentity(
+                installId = installId,
+                userId = "user-123",
+                username = "alice",
+            ),
+            loadInstallationIdentity(rootDir),
+        )
+    }
+
     @Test
     fun `manifest driven install is disabled before first OTA`() {
         val rootDir = temporaryFolder.newFolder("first-ota-manifest-disabled")
@@ -280,6 +375,164 @@ class BundleFileStorageServiceTest {
         assertFalse(invokeCanUseManifestDrivenInstall(service))
     }
 
+    @Test
+    fun `catalog high water rejects replay and survives channel reset`() =
+        runBlocking {
+            val rootDir = temporaryFolder.newFolder("release-high-water")
+            val service = createService(rootDir)
+
+            assertTrue(
+                service.acceptReleaseCatalog(
+                    catalogId = "project-a",
+                    scopeKey = "scope-production",
+                    generation = 2,
+                    catalogHash = "hash-2",
+                    channel = "production",
+                    selectionContextHash = "context-2",
+                ),
+            )
+            assertFalse(
+                service.acceptReleaseCatalog(
+                    catalogId = "project-a",
+                    scopeKey = "scope-production",
+                    generation = 1,
+                    catalogHash = "hash-1",
+                    channel = "production",
+                    selectionContextHash = "context-1",
+                ),
+            )
+            assertFalse(
+                service.acceptReleaseCatalog(
+                    catalogId = "project-a",
+                    scopeKey = "scope-production",
+                    generation = 2,
+                    catalogHash = "different-hash",
+                    channel = "production",
+                    selectionContextHash = "context-2",
+                ),
+            )
+
+            assertTrue(service.resetChannel())
+            val metadata = loadMetadata(rootDir)
+            assertEquals(
+                CatalogHighWater(generation = 2, catalogHash = "hash-2"),
+                metadata?.highestSeenCatalogs?.get("project-a|scope-production"),
+            )
+        }
+
+    @Test
+    fun `same bundle adoption refreshes its receipt without changing bytes`() =
+        runBlocking {
+            val rootDir = temporaryFolder.newFolder("same-bundle-adoption")
+            val service = createService(rootDir)
+            val bundleDir = createBundleDir(rootDir, "bundle-one")
+            writeFile(bundleDir, "index.android.bundle")
+            writeManifest(bundleDir, listOf("index.android.bundle"))
+            val oldSelection =
+                releaseSelection(
+                    releaseId = "release-one",
+                    bundleId = bundleDir.name,
+                    generation = 1,
+                    catalogHash = "hash-1",
+                    selectionContextHash = "context-1",
+                )
+            writeMetadata(
+                rootDir,
+                BundleMetadata(
+                    isolationKey = TEST_ISOLATION_KEY,
+                    stagingBundleId = bundleDir.name,
+                    stagingSelection = oldSelection,
+                ),
+            )
+            assertTrue(
+                service.acceptReleaseCatalog(
+                    catalogId = "project-a",
+                    scopeKey = "scope-production",
+                    generation = 2,
+                    catalogHash = "hash-2",
+                    channel = "production",
+                    selectionContextHash = "context-2",
+                ),
+            )
+            val newSelection =
+                releaseSelection(
+                    releaseId = "release-two",
+                    bundleId = bundleDir.name,
+                    generation = 2,
+                    catalogHash = "hash-2",
+                    selectionContextHash = "context-2",
+                )
+
+            assertTrue(service.commitReleaseSelection(newSelection))
+
+            assertTrue(bundleDir.isDirectory)
+            assertEquals(newSelection, loadMetadata(rootDir)?.stagingSelection)
+            assertFalse(loadMetadata(rootDir)?.verificationPending ?: true)
+        }
+
+    @Test
+    fun `crash restores the complete stable receipt but retains newer high water`() {
+        val rootDir = temporaryFolder.newFolder("release-crash-ledger")
+        val service = createService(rootDir)
+        val stableDir = createBundleDir(rootDir, "bundle-one")
+        writeFile(stableDir, "index.android.bundle")
+        writeManifest(stableDir, listOf("index.android.bundle"))
+        val stagingDir = createBundleDir(rootDir, "bundle-two")
+        writeFile(stagingDir, "index.android.bundle")
+        writeManifest(stagingDir, listOf("index.android.bundle"))
+        val stableSelection =
+            releaseSelection("release-one", stableDir.name, 1, "hash-1", "context-1")
+        val stagingSelection =
+            releaseSelection("release-two", stagingDir.name, 2, "hash-2", "context-2")
+        writeMetadata(
+            rootDir,
+            BundleMetadata(
+                isolationKey = TEST_ISOLATION_KEY,
+                stableBundleId = stableDir.name,
+                stagingBundleId = stagingDir.name,
+                stableSelection = stableSelection,
+                stagingSelection = stagingSelection,
+                pendingUpdateStrategy = "appVersion",
+                pendingTransition =
+                    PendingSelectionTransition(
+                        fromReleaseId = stableSelection.releaseId,
+                        fromBundleId = stableSelection.bundleId,
+                        toReleaseId = stagingSelection.releaseId,
+                        toBundleId = stagingSelection.bundleId,
+                    ),
+                verificationPending = true,
+                highestSeenCatalogs =
+                    mapOf(
+                        "project-a|scope-production" to
+                            CatalogHighWater(generation = 2, catalogHash = "hash-2"),
+                    ),
+                currentSelectionContexts =
+                    mapOf("project-a|scope-production" to "production\ncontext-2"),
+            ),
+        )
+
+        val launch =
+            service.prepareLaunch(
+                PendingCrashRecovery(
+                    launchedBundleId = stagingDir.name,
+                    shouldRollback = true,
+                ),
+            )
+        val report = service.notifyAppReady()
+        val metadata = loadMetadata(rootDir)
+
+        assertEquals(stableDir.name, launch.launchedBundleId)
+        assertEquals("RECOVERED", report["status"])
+        assertEquals("release-two", report["fromReleaseId"])
+        assertEquals("release-one", report["toReleaseId"])
+        assertEquals(stableSelection, metadata?.stagingSelection)
+        assertEquals(
+            CatalogHighWater(generation = 2, catalogHash = "hash-2"),
+            metadata?.highestSeenCatalogs?.get("project-a|scope-production"),
+        )
+        assertTrue(service.getCrashHistory().contains(stagingDir.name))
+    }
+
     @Test
     fun `manifest driven install moves blocking work off caller dispatcher`() {
         val rootDir = temporaryFolder.newFolder("manifest-install-dispatcher")
@@ -354,6 +607,26 @@ class BundleFileStorageServiceTest {
             DecompressService(),
             preferences,
             TEST_ISOLATION_KEY,
+            { "production" },
+        )
+
+    private fun releaseSelection(
+        releaseId: String,
+        bundleId: String,
+        generation: Long,
+        catalogHash: String,
+        selectionContextHash: String,
+    ): PersistedSelection =
+        PersistedSelection(
+            kind = "BUNDLE",
+            releaseId = releaseId,
+            bundleId = bundleId,
+            catalogId = "project-a",
+            scopeKey = "scope-production",
+            generation = generation,
+            catalogHash = catalogHash,
+            channel = "production",
+            selectionContextHash = selectionContextHash,
         )
 
     private fun createBundleDir(
@@ -393,6 +666,11 @@ class BundleFileStorageServiceTest {
             TEST_ISOLATION_KEY,
         )
 
+    private fun loadInstallationIdentity(rootDir: File): InstallationIdentity? =
+        InstallationIdentity.loadFromFile(
+            File(bundleStoreDir(rootDir), InstallationIdentity.IDENTITY_FILENAME),
+        )
+
     private fun writeFile(
         rootDir: File,
         relativePath: String,

package/android/src/test/java/com/hotupdater/HotUpdaterImplTest.kt

@@ -107,6 +107,41 @@ class HotUpdaterImplTest {
         assertNull(impl.getBaseURL())
     }
 
+    @Test
+    fun `notifyAppReady reads the report without completing the current launch`() {
+        val storage = FakeBundleStorageService(bundleId = null)
+        val impl = allocateWithoutConstructor<HotUpdaterImpl>()
+        setField(impl, "bundleStorage", storage)
+        setCurrentLaunchSelection(
+            impl,
+            LaunchSelection(
+                bundleUrl = "file:///bundle-store/launched-bundle/index.android.bundle",
+                launchedBundleId = "launched-bundle",
+                shouldRollbackOnCrash = false,
+            ),
+        )
+
+        assertEquals(mapOf("status" to "UNCHANGED"), impl.notifyAppReady())
+        assertNull(storage.lastCompletedBundleId)
+    }
+
+    @Test
+    fun `getInstallId and setUser delegate to bundle storage`() {
+        val storage = FakeBundleStorageService(bundleId = null)
+        val impl = allocateWithoutConstructor<HotUpdaterImpl>()
+        setField(impl, "bundleStorage", storage)
+
+        assertEquals("test-install-id", impl.getInstallId())
+
+        impl.setUser("user-123", "alice")
+        assertEquals("user-123", storage.lastUserId)
+        assertEquals("alice", storage.lastUsername)
+
+        impl.setUser(null, null)
+        assertNull(storage.lastUserId)
+        assertNull(storage.lastUsername)
+    }
+
     private fun createImpl(
         storageBundleId: String?,
         storageManifest: Map<String, Any?> = emptyMap(),
@@ -162,6 +197,10 @@ class HotUpdaterImplTest {
             emptyMap(),
         private val launchedBundleBaseURLs: Map<String, String> = emptyMap(),
     ) : BundleStorageService {
+        var lastCompletedBundleId: String? = null
+        var lastUserId: String? = null
+        var lastUsername: String? = null
+
         override fun setBundleURL(localPath: String?): Boolean = true
 
         override fun getCachedBundleURL(): String? = null
@@ -185,9 +224,25 @@ class HotUpdaterImplTest {
             progressCallback: (UpdateProgressPayload) -> Unit,
         ) = Unit
 
-        override fun markLaunchCompleted(currentBundleId: String?) = Unit
+        override fun markLaunchCompleted(currentBundleId: String?) {
+            lastCompletedBundleId = currentBundleId
+        }
+
+        override fun notifyAppReady(): Map<String, Any?> = mapOf("status" to "UNCHANGED")
+
+        override fun getInstallId(): String = "test-install-id"
 
-        override fun notifyAppReady(): Map<String, Any?> = mapOf("status" to "STABLE")
+        override fun getUserId(): String? = lastUserId
+
+        override fun getUsername(): String? = lastUsername
+
+        override fun setUser(
+            userId: String?,
+            username: String?,
+        ) {
+            lastUserId = userId
+            lastUsername = username
+        }
 
         override fun getCrashHistory(): CrashedHistory = CrashedHistory()
 

package/android/src/test/java/com/hotupdater/ReleaseCatalogCacheServiceTest.kt

@@ -0,0 +1,118 @@
+package com.hotupdater
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+
+class ReleaseCatalogCacheServiceTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `persists checksum verified entries without credential filenames`() {
+        val root = temporaryFolder.newFolder("catalog-cache")
+        val first = createService(root)
+        val partition = "https://updates.example.com|x-api-key=raw-secret"
+
+        assertTrue(first.set(partition, "validated-catalog"))
+        assertEquals("validated-catalog", createService(root).get(partition))
+
+        val entry = root.listFiles()!!.single()
+        assertTrue(entry.name.matches(Regex("[0-9a-f]{64}\\.catalog")))
+        assertFalse(entry.name.contains("raw-secret"))
+        assertFalse(entry.readText().contains("raw-secret"))
+
+        entry.appendText("corrupt")
+        assertNull(createService(root).get(partition))
+        assertFalse(entry.exists())
+    }
+
+    @Test
+    fun `failed atomic replacement preserves the previous entry`() {
+        val root = temporaryFolder.newFolder("interrupted-write")
+        val partition = "partition"
+        assertTrue(createService(root).set(partition, "previous"))
+
+        val interrupted =
+            ReleaseCatalogCacheService(
+                rootDirectory = root,
+                atomicReader = ::readForTest,
+                atomicWriter = { _, _ -> false },
+                atomicRemover = ::removeForTest,
+            )
+        assertFalse(interrupted.set(partition, "replacement"))
+        assertEquals("previous", createService(root).get(partition))
+    }
+
+    @Test
+    fun `evicts least recently used entries and rejects oversized payloads`() {
+        val root = temporaryFolder.newFolder("bounded-cache")
+        val service =
+            ReleaseCatalogCacheService(
+                rootDirectory = root,
+                maxEntries = 2,
+                maxEntryBytes = 16,
+                maxTotalBytes = 200,
+                atomicReader = ::readForTest,
+                atomicWriter = ::writeForTest,
+                atomicRemover = ::removeForTest,
+            )
+
+        assertTrue(service.set("one", "first"))
+        Thread.sleep(5)
+        assertTrue(service.set("two", "second"))
+        Thread.sleep(5)
+        assertTrue(service.set("three", "third"))
+
+        assertNull(service.get("one"))
+        assertEquals("second", service.get("two"))
+        assertEquals("third", service.get("three"))
+        assertFalse(service.set("two", "x".repeat(17)))
+        assertEquals("second", service.get("two"))
+    }
+
+    private fun createService(root: File): ReleaseCatalogCacheService =
+        ReleaseCatalogCacheService(
+            rootDirectory = root,
+            atomicReader = ::readForTest,
+            atomicWriter = ::writeForTest,
+            atomicRemover = ::removeForTest,
+        )
+
+    private fun readForTest(file: File): ByteArray? = if (file.isFile) file.readBytes() else null
+
+    private fun removeForTest(file: File): Boolean = !file.exists() || file.delete()
+
+    private fun writeForTest(
+        destination: File,
+        bytes: ByteArray,
+    ): Boolean =
+        try {
+            val temporary = File.createTempFile("entry", ".tmp", destination.parentFile)
+            temporary.writeBytes(bytes)
+            try {
+                Files.move(
+                    temporary.toPath(),
+                    destination.toPath(),
+                    StandardCopyOption.ATOMIC_MOVE,
+                    StandardCopyOption.REPLACE_EXISTING,
+                )
+            } catch (_: Exception) {
+                Files.move(
+                    temporary.toPath(),
+                    destination.toPath(),
+                    StandardCopyOption.REPLACE_EXISTING,
+                )
+            }
+            true
+        } catch (_: Exception) {
+            false
+        }
+}