@hot-updater/react-native 1.0.0-rc.15 → 1.0.0-rc.17

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

@@ -0,0 +1,220 @@
+package com.hotupdater
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Test
+import java.io.IOException
+import java.io.InterruptedIOException
+import java.net.ConnectException
+import java.net.MalformedURLException
+import java.net.NoRouteToHostException
+import java.net.SocketException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+import javax.net.ssl.SSLHandshakeException
+import javax.net.ssl.SSLPeerUnverifiedException
+
+class HotUpdaterExceptionTest {
+    private val invalidResponse = UpdateFailure.download(UpdateFailureReason.INVALID_RESPONSE)
+    private val network = UpdateFailure.download(UpdateFailureReason.NETWORK)
+    private val signature = UpdateFailure.download(UpdateFailureReason.SIGNATURE)
+    private val storage = UpdateFailure.install(UpdateFailureReason.STORAGE)
+
+    @Test
+    fun `enum values match the JS contract`() {
+        assertEquals(listOf("download", "install"), UpdateFailureStage.entries.map { it.value })
+        assertEquals(
+            listOf(
+                "network",
+                "http",
+                "invalid_response",
+                "hash_mismatch",
+                "signature",
+                "patch",
+                "extract",
+                "storage",
+                "unknown",
+            ),
+            UpdateFailureReason.entries.map { it.value },
+        )
+        assertEquals(listOf("manifest", "file", "patch", "archive"), UpdateFailureResource.entries.map { it.value })
+        assertEquals(
+            listOf("timeout", "dns", "tls", "connection", "offline", "cancelled"),
+            UpdateFailureTransport.entries.map { it.value },
+        )
+    }
+
+    @Test
+    fun `userInfo carries each optional key only with its reason`() {
+        assertEquals(
+            mapOf("stage" to "download", "reason" to "http", "httpStatus" to 404),
+            UpdateFailure.http(404).toUserInfo(),
+        )
+        assertEquals(
+            mapOf(
+                "stage" to "download",
+                "reason" to "http",
+                "resource" to "manifest",
+                "httpStatus" to 403,
+                "originCode" to "AccessDenied",
+            ),
+            UpdateFailure.http(403, originCode = "AccessDenied").copy(resource = UpdateFailureResource.MANIFEST).toUserInfo(),
+        )
+        assertEquals(mapOf("stage" to "install", "reason" to "storage"), storage.toUserInfo())
+        assertEquals(
+            mapOf("stage" to "download", "reason" to "network", "resource" to "file", "transport" to "timeout"),
+            UpdateFailure(
+                UpdateFailureStage.DOWNLOAD,
+                UpdateFailureReason.NETWORK,
+                httpStatus = 500,
+                resource = UpdateFailureResource.FILE,
+                transport = UpdateFailureTransport.TIMEOUT,
+                originCode = "Ignored",
+            ).toUserInfo(),
+        )
+        assertEquals(
+            mapOf("stage" to "download", "reason" to "http", "httpStatus" to 502),
+            UpdateFailure.http(502).copy(transport = UpdateFailureTransport.DNS).toUserInfo(),
+        )
+    }
+
+    @Test
+    fun `download errors are classified by their cause`() {
+        val cases =
+            listOf(
+                HttpStatusException(403, "Forbidden") to UpdateFailure.http(403),
+                HttpStatusException(404, "Not Found", originCode = "NoSuchKey") to UpdateFailure.http(404, originCode = "NoSuchKey"),
+                UnknownHostException("updates.example.com") to network.copy(transport = UpdateFailureTransport.DNS),
+                SocketTimeoutException("connect timed out") to network.copy(transport = UpdateFailureTransport.TIMEOUT),
+                InterruptedIOException("timeout") to network.copy(transport = UpdateFailureTransport.TIMEOUT),
+                SSLHandshakeException("Chain validation failed") to network.copy(transport = UpdateFailureTransport.TLS),
+                SSLPeerUnverifiedException("Hostname not verified") to network.copy(transport = UpdateFailureTransport.TLS),
+                ConnectException("Connection refused") to network.copy(transport = UpdateFailureTransport.CONNECTION),
+                NoRouteToHostException("No route to host") to network.copy(transport = UpdateFailureTransport.CONNECTION),
+                SocketException("Connection reset") to network.copy(transport = UpdateFailureTransport.CONNECTION),
+                IOException("Canceled") to network.copy(transport = UpdateFailureTransport.CANCELLED),
+                IOException("unexpected end of stream") to network,
+                IncompleteDownloadException(expectedSize = 10, actualSize = 4) to network,
+                LocalStorageException(IOException("No space left on device")) to storage,
+                MalformedURLException("no protocol: bundle") to invalidResponse,
+                IllegalArgumentException("Expected URL scheme 'http' or 'https' but was 'ftp'") to invalidResponse,
+                Exception("Response body is null") to UpdateFailure.download(UpdateFailureReason.UNKNOWN),
+            )
+
+        cases.forEach { (cause, failure) ->
+            val error = HotUpdaterException.downloadFailed(cause)
+            assertEquals("DOWNLOAD_FAILED", error.code)
+            assertEquals("$cause", failure, error.failure)
+        }
+        assertEquals(network, HotUpdaterException.incompleteDownload(expectedSize = 10, actualSize = 4).failure)
+    }
+
+    @Test
+    fun `a failed host lookup without an active network is offline`() {
+        assertEquals(
+            network.copy(transport = UpdateFailureTransport.OFFLINE),
+            UpdateFailure.ofDownloadError(UnknownHostException("updates.example.com")) { true },
+        )
+        assertEquals(
+            network.copy(transport = UpdateFailureTransport.TIMEOUT),
+            UpdateFailure.ofDownloadError(SocketTimeoutException("timeout")) { error("Only a failed host lookup asks") },
+        )
+    }
+
+    @Test
+    fun `verification errors report hash mismatch storage or signature`() {
+        val cases =
+            listOf(
+                SignatureVerificationException.FileHashMismatch() to UpdateFailure.download(UpdateFailureReason.HASH_MISMATCH),
+                SignatureVerificationException.FileReadFailed() to storage,
+                SignatureVerificationException.PublicKeyNotConfigured() to signature,
+                SignatureVerificationException.InvalidPublicKeyFormat() to signature,
+                SignatureVerificationException.MissingFileHash() to signature,
+                SignatureVerificationException.InvalidSignatureFormat() to signature,
+                SignatureVerificationException.SignatureVerificationFailed() to signature,
+                SignatureVerificationException.UnsignedNotAllowed() to signature,
+                SignatureVerificationException.SecurityFrameworkError(IllegalStateException("provider")) to signature,
+            )
+
+        cases.forEach { (cause, failure) ->
+            val error = HotUpdaterException.signatureVerificationFailed(cause)
+            assertEquals("SIGNATURE_VERIFICATION_FAILED", error.code)
+            assertEquals("$cause", failure, error.failure)
+        }
+    }
+
+    @Test
+    fun `parameter validation keeps its codes and reports an invalid response`() {
+        val cases =
+            listOf(
+                Triple(HotUpdaterException.missingBundleId(), "MISSING_BUNDLE_ID", "Missing or empty 'bundleId'") to invalidResponse,
+                Triple(HotUpdaterException.invalidManifestParams(), "INVALID_MANIFEST", "Manifest URL, hash, and assets are required") to
+                    invalidResponse.copy(resource = UpdateFailureResource.MANIFEST),
+                Triple(
+                    HotUpdaterException.invalidFileUrl("archiveUrl", "not a url", UpdateFailureResource.ARCHIVE),
+                    "INVALID_FILE_URL",
+                    "Invalid 'archiveUrl' provided: not a url",
+                ) to invalidResponse.copy(resource = UpdateFailureResource.ARCHIVE),
+            )
+
+        cases.forEach { (rejection, failure) ->
+            val (error, code, message) = rejection
+            assertEquals(code, error.code)
+            assertEquals(message, error.message)
+            assertEquals(failure, error.failure)
+        }
+        assertEquals(invalidResponse, HotUpdaterException.invalidBundle().failure)
+    }
+
+    @Test
+    fun `storage failures report install storage`() {
+        val cases =
+            listOf(
+                HotUpdaterException.directoryCreationFailed() to "DIRECTORY_CREATION_FAILED",
+                HotUpdaterException.moveOperationFailed() to "MOVE_OPERATION_FAILED",
+                HotUpdaterException.insufficientDiskSpace(required = 10, available = 1) to "INSUFFICIENT_DISK_SPACE",
+                HotUpdaterException.storageFailed("Failed to persist bundle metadata") to "UNKNOWN_ERROR",
+            )
+
+        cases.forEach { (error, code) ->
+            assertEquals(code, error.code)
+            assertEquals(storage, error.failure)
+        }
+    }
+
+    @Test
+    fun `unexpected errors keep the UNKNOWN_ERROR code and message`() {
+        val cause = IllegalStateException("boom")
+        val error = HotUpdaterException.unexpected(cause, UpdateFailure.ofUnexpectedError(cause, UpdateFailureStage.INSTALL))
+
+        assertEquals("UNKNOWN_ERROR", error.code)
+        assertEquals("boom", error.message)
+        assertSame(cause, error.cause)
+        assertEquals(UpdateFailure.install(UpdateFailureReason.UNKNOWN), error.failure)
+        assertEquals(storage, UpdateFailure.ofUnexpectedError(IOException("read failed"), UpdateFailureStage.DOWNLOAD))
+        assertEquals(invalidResponse, UpdateFailure.ofUnexpectedError(MalformedURLException(), UpdateFailureStage.DOWNLOAD))
+    }
+
+    @Test
+    fun `withResource names the resource only when none is named`() {
+        val cause = IOException("reset")
+        val error = HotUpdaterException.downloadFailed(cause)
+
+        val named = error.withResource(UpdateFailureResource.FILE)
+        assertEquals("DOWNLOAD_FAILED", named.code)
+        assertEquals(error.message, named.message)
+        assertSame(cause, named.cause)
+        assertEquals(error.failure?.copy(resource = UpdateFailureResource.FILE), named.failure)
+
+        assertSame(named, named.withResource(UpdateFailureResource.MANIFEST))
+        assertSame(error, error.withResource(null))
+        val crashed = HotUpdaterException.bundleInCrashedHistory("crashed-bundle")
+        assertSame(crashed, crashed.withResource(UpdateFailureResource.FILE))
+    }
+
+    @Test
+    fun `a bundle in the crashed history is not an update failure`() {
+        assertNull(HotUpdaterException.bundleInCrashedHistory("crashed-bundle").failure)
+    }
+}

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

@@ -3,9 +3,15 @@ package com.hotupdater
 import org.junit.Assert.assertEquals
 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
 
 class HotUpdaterImplTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
     @Test
     fun `getBundleId returns built in while native launch selection is missing`() {
         val impl =
@@ -126,20 +132,22 @@ class HotUpdaterImplTest {
     }
 
     @Test
-    fun `getInstallId and setUser delegate to bundle storage`() {
-        val storage = FakeBundleStorageService(bundleId = null)
+    fun `install id and storage items come from their no backup stores`() {
+        val identityFile = File(temporaryFolder.root, "hot-updater/install-identity.json")
+        val storageFile = File(temporaryFolder.root, "hot-updater/storage.json")
         val impl = allocateWithoutConstructor<HotUpdaterImpl>()
-        setField(impl, "bundleStorage", storage)
+        setField(impl, "installIdentity", InstallIdentityService(identityFile))
+        setField(impl, "keyValueStorage", KeyValueStorageService(storageFile))
 
-        assertEquals("test-install-id", impl.getInstallId())
+        val installId = impl.getInstallId()
+        assertEquals(installId, InstallationIdentity.loadFromFile(identityFile)?.installId)
 
-        impl.setUser("user-123", "alice")
-        assertEquals("user-123", storage.lastUserId)
-        assertEquals("alice", storage.lastUsername)
+        impl.setStorageItem("plugins/insights/queue", "[]")
+        assertEquals("[]", impl.getStorageItem("plugins/insights/queue"))
+        assertEquals("[]", KeyValueStorageService(storageFile).getItem("plugins/insights/queue"))
 
-        impl.setUser(null, null)
-        assertNull(storage.lastUserId)
-        assertNull(storage.lastUsername)
+        impl.setStorageItem("plugins/insights/queue", null)
+        assertNull(impl.getStorageItem("plugins/insights/queue"))
     }
 
     private fun createImpl(
@@ -198,8 +206,6 @@ class HotUpdaterImplTest {
         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
 
@@ -221,7 +227,7 @@ class HotUpdaterImplTest {
             assets: Map<String, ChangedAssetDescriptor>,
             archiveUrl: String?,
             progressCallback: (UpdateProgressPayload) -> Unit,
-        ) = Unit
+        ) = UpdateBundleResult(BundleDelivery.MANIFEST, patchFallback = false)
 
         override fun markLaunchCompleted(currentBundleId: String?) {
             lastCompletedBundleId = currentBundleId
@@ -229,20 +235,6 @@ class HotUpdaterImplTest {
 
         override fun notifyAppReady(): Map<String, Any?> = mapOf("status" to "UNCHANGED")
 
-        override fun getInstallId(): String = "test-install-id"
-
-        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()
 
         override fun clearCrashHistory(): Boolean = true

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

@@ -0,0 +1,71 @@
+package com.hotupdater
+
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+import java.util.UUID
+
+class InstallIdentityServiceTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `creates a random install id once and keeps it across instances`() {
+        val identityFile = File(temporaryFolder.root, "hot-updater/install-identity.json")
+        val service = InstallIdentityService(identityFile)
+
+        val installId = service.getInstallId()
+
+        assertEquals(installId, UUID.fromString(installId).toString())
+        assertEquals(installId, service.getInstallId())
+        assertEquals(installId, InstallIdentityService(identityFile).getInstallId())
+        assertEquals(
+            listOf("installId"),
+            JSONObject(identityFile.readText()).keys().asSequence().toList(),
+        )
+    }
+
+    @Test
+    fun `lives under noBackupFilesDir and never reads the old bundle store identity`() {
+        val noBackupDirectory = temporaryFolder.newFolder("no_backup")
+        val oldIdentityJson = "{\"installId\":\"old-install-id\",\"userId\":\"user-1\",\"username\":\"alice\"}"
+        val oldIdentityFile =
+            File(temporaryFolder.newFolder("files"), "bundle-store/identity.json").apply {
+                parentFile?.mkdirs()
+                writeText(oldIdentityJson)
+            }
+
+        val installId = InstallIdentityService.create(NoBackupContext(noBackupDirectory)).getInstallId()
+
+        assertNotEquals("old-install-id", installId)
+        assertEquals(
+            InstallationIdentity(installId),
+            InstallationIdentity.loadFromFile(File(noBackupDirectory, "hot-updater/install-identity.json")),
+        )
+        assertEquals(oldIdentityJson, oldIdentityFile.readText())
+    }
+
+    @Test
+    fun `replaces an unreadable identity with a new id`() {
+        val identityFile = File(temporaryFolder.root, "install-identity.json").apply { writeText("{") }
+
+        val installId = InstallIdentityService(identityFile).getInstallId()
+
+        assertEquals(InstallationIdentity(installId), InstallationIdentity.loadFromFile(identityFile))
+    }
+
+    @Test
+    fun `keeps the install id for the process after its file becomes unreadable`() {
+        val identityFile = File(temporaryFolder.root, "install-identity.json")
+        val service = InstallIdentityService(identityFile)
+        val installId = service.getInstallId()
+
+        identityFile.writeText("{")
+
+        assertEquals(installId, service.getInstallId())
+    }
+}

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

@@ -0,0 +1,106 @@
+package com.hotupdater
+
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+class KeyValueStorageServiceTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `sets replaces and removes values`() {
+        val storage = KeyValueStorageService(storageFile())
+        assertNull(storage.getItem("plugins/insights/queue"))
+
+        storage.setItem("plugins/insights/queue", "[1]")
+        storage.setItem("plugins/insights/day", "2026-09-30")
+        storage.setItem("plugins/insights/queue", "[1,2]")
+        storage.setItem("plugins/other/empty", "")
+        assertEquals("[1,2]", storage.getItem("plugins/insights/queue"))
+        assertEquals("", storage.getItem("plugins/other/empty"))
+
+        storage.setItem("plugins/insights/queue", null)
+        storage.setItem("plugins/never-set", null)
+        assertNull(storage.getItem("plugins/insights/queue"))
+        assertEquals("2026-09-30", storage.getItem("plugins/insights/day"))
+    }
+
+    @Test
+    fun `values persist across instances`() {
+        val file = storageFile()
+        KeyValueStorageService(file).apply {
+            setItem("plugins/insights/queue", "[{\"id\":\"é\",\"note\":\"line\\nbreak\"}]")
+            setItem("plugins/insights/day", "2026-09-30")
+            setItem("plugins/insights/day", null)
+        }
+
+        val reloaded = KeyValueStorageService(file)
+
+        assertEquals("[{\"id\":\"é\",\"note\":\"line\\nbreak\"}]", reloaded.getItem("plugins/insights/queue"))
+        assertNull(reloaded.getItem("plugins/insights/day"))
+    }
+
+    @Test
+    fun `a corrupt file reads as empty and the next set replaces it`() {
+        val file = storageFile().apply { writeText("{\"plugins/a\":") }
+        val storage = KeyValueStorageService(file)
+
+        assertNull(storage.getItem("plugins/a"))
+        storage.setItem("plugins/b", "value")
+
+        assertEquals(mapOf("plugins/b" to "value"), readStored(file))
+    }
+
+    @Test
+    fun `values that are not strings read as missing`() {
+        val file = storageFile().apply { writeText("{\"plugins/a\":1,\"plugins/b\":\"kept\",\"plugins/c\":null}") }
+        val storage = KeyValueStorageService(file)
+
+        assertNull(storage.getItem("plugins/a"))
+        assertEquals("kept", storage.getItem("plugins/b"))
+        assertNull(storage.getItem("plugins/c"))
+    }
+
+    @Test
+    fun `concurrent sets are all persisted`() {
+        val file = storageFile()
+        val storage = KeyValueStorageService(file)
+
+        (0 until 4)
+            .map { worker ->
+                Thread {
+                    repeat(25) { index -> storage.setItem("plugins/worker-$worker/$index", "$worker:$index") }
+                }.apply { start() }
+            }.forEach(Thread::join)
+
+        val stored = readStored(file)
+        assertEquals(100, stored.size)
+        (0 until 4).forEach { worker ->
+            repeat(25) { index -> assertEquals("$worker:$index", stored["plugins/worker-$worker/$index"]) }
+        }
+    }
+
+    @Test
+    fun `is stored under noBackupFilesDir`() {
+        val noBackupDirectory = temporaryFolder.newFolder("no_backup")
+
+        KeyValueStorageService.create(NoBackupContext(noBackupDirectory)).setItem("plugins/insights/queue", "[]")
+
+        assertEquals(
+            mapOf("plugins/insights/queue" to "[]"),
+            readStored(File(noBackupDirectory, "hot-updater/storage.json")),
+        )
+    }
+
+    private fun storageFile(): File = File(temporaryFolder.newFolder(), "hot-updater/storage.json").apply { parentFile?.mkdirs() }
+
+    private fun readStored(file: File): Map<String, String> {
+        val json = JSONObject(file.readText())
+        return json.keys().asSequence().associateWith { json.getString(it) }
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.hotupdater
+
+import android.content.ContextWrapper
+import java.io.File
+
+/** A context whose `noBackupFilesDir` is a test directory. */
+internal class NoBackupContext(
+    private val noBackupDirectory: File,
+) : ContextWrapper(null) {
+    override fun getNoBackupFilesDir(): File = noBackupDirectory
+}