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

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

@@ -1,220 +0,0 @@
-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

@@ -1,264 +0,0 @@
-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 =
-            createImpl(
-                storageBundleId = "staged-bundle",
-                storageManifest = mapOf("bundleId" to "staged-bundle"),
-                storageBaseURL = "file:///bundle-store/staged-bundle",
-            )
-
-        assertNull(impl.getBundleId())
-        assertTrue(impl.getManifest().isEmpty())
-        assertNull(impl.getBaseURL())
-    }
-
-    @Test
-    fun `getBundleId returns current launched bundle over staged metadata`() {
-        val impl = createImpl(storageBundleId = "staged-bundle")
-
-        setCurrentLaunchSelection(
-            impl,
-            LaunchSelection(
-                bundleUrl = "file:///bundle-store/launched-bundle/index.android.bundle",
-                launchedBundleId = "launched-bundle",
-                shouldRollbackOnCrash = false,
-            ),
-        )
-
-        assertEquals("launched-bundle", impl.getBundleId())
-    }
-
-    @Test
-    fun `getBundleId returns null for built in launch even when staged metadata exists`() {
-        val impl = createImpl(storageBundleId = "staged-bundle")
-
-        setCurrentLaunchSelection(
-            impl,
-            LaunchSelection(
-                bundleUrl = "assets://index.android.bundle",
-                launchedBundleId = null,
-                shouldRollbackOnCrash = false,
-            ),
-        )
-
-        assertNull(impl.getBundleId())
-    }
-
-    @Test
-    fun `getManifest and getBaseURL return current launched bundle over staged metadata`() {
-        val impl =
-            createImpl(
-                storageBundleId = "staged-bundle",
-                storageManifest = mapOf("bundleId" to "staged-bundle"),
-                storageBaseURL = "file:///bundle-store/staged-bundle",
-                launchedBundleManifests =
-                    mapOf(
-                        "launched-bundle" to mapOf("bundleId" to "launched-bundle"),
-                    ),
-                launchedBundleBaseURLs =
-                    mapOf(
-                        "launched-bundle" to "file:///bundle-store/launched-bundle",
-                    ),
-            )
-
-        setCurrentLaunchSelection(
-            impl,
-            LaunchSelection(
-                bundleUrl = "file:///bundle-store/launched-bundle/index.android.bundle",
-                launchedBundleId = "launched-bundle",
-                shouldRollbackOnCrash = false,
-            ),
-        )
-
-        assertEquals(
-            mapOf("bundleId" to "launched-bundle"),
-            impl.getManifest(),
-        )
-        assertEquals("file:///bundle-store/launched-bundle", impl.getBaseURL())
-    }
-
-    @Test
-    fun `getManifest and getBaseURL return built in values for built in launch`() {
-        val impl =
-            createImpl(
-                storageBundleId = "staged-bundle",
-                storageManifest = mapOf("bundleId" to "staged-bundle"),
-                storageBaseURL = "file:///bundle-store/staged-bundle",
-            )
-
-        setCurrentLaunchSelection(
-            impl,
-            LaunchSelection(
-                bundleUrl = "assets://index.android.bundle",
-                launchedBundleId = null,
-                shouldRollbackOnCrash = false,
-            ),
-        )
-
-        assertTrue(impl.getManifest().isEmpty())
-        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 `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, "installIdentity", InstallIdentityService(identityFile))
-        setField(impl, "keyValueStorage", KeyValueStorageService(storageFile))
-
-        val installId = impl.getInstallId()
-        assertEquals(installId, InstallationIdentity.loadFromFile(identityFile)?.installId)
-
-        impl.setStorageItem("plugins/insights/queue", "[]")
-        assertEquals("[]", impl.getStorageItem("plugins/insights/queue"))
-        assertEquals("[]", KeyValueStorageService(storageFile).getItem("plugins/insights/queue"))
-
-        impl.setStorageItem("plugins/insights/queue", null)
-        assertNull(impl.getStorageItem("plugins/insights/queue"))
-    }
-
-    private fun createImpl(
-        storageBundleId: String?,
-        storageManifest: Map<String, Any?> = emptyMap(),
-        storageBaseURL: String = "",
-        launchedBundleManifests: Map<String, Map<String, Any?>> = emptyMap(),
-        launchedBundleBaseURLs: Map<String, String> = emptyMap(),
-    ): HotUpdaterImpl =
-        allocateWithoutConstructor<HotUpdaterImpl>().also { impl ->
-            setField(
-                impl,
-                "bundleStorage",
-                FakeBundleStorageService(
-                    bundleId = storageBundleId,
-                    manifest = storageManifest,
-                    baseURL = storageBaseURL,
-                    launchedBundleManifests = launchedBundleManifests,
-                    launchedBundleBaseURLs = launchedBundleBaseURLs,
-                ),
-            )
-        }
-
-    private fun setCurrentLaunchSelection(
-        impl: HotUpdaterImpl,
-        selection: LaunchSelection,
-    ) {
-        setField(impl, "currentLaunchSelection", selection)
-    }
-
-    private fun setField(
-        target: Any,
-        fieldName: String,
-        value: Any?,
-    ) {
-        val field = HotUpdaterImpl::class.java.getDeclaredField(fieldName)
-        field.isAccessible = true
-        field.set(target, value)
-    }
-
-    private inline fun <reified T> allocateWithoutConstructor(): T {
-        val field = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe")
-        field.isAccessible = true
-        val unsafe = field.get(null)
-        val allocateInstance = unsafe.javaClass.getMethod("allocateInstance", Class::class.java)
-        @Suppress("UNCHECKED_CAST")
-        return allocateInstance.invoke(unsafe, T::class.java) as T
-    }
-
-    private class FakeBundleStorageService(
-        private val bundleId: String?,
-        private val manifest: Map<String, Any?> = emptyMap(),
-        private val baseURL: String = "",
-        private val launchedBundleManifests: Map<String, Map<String, Any?>> =
-            emptyMap(),
-        private val launchedBundleBaseURLs: Map<String, String> = emptyMap(),
-    ) : BundleStorageService {
-        var lastCompletedBundleId: String? = null
-
-        override fun setBundleURL(localPath: String?): Boolean = true
-
-        override fun getCachedBundleURL(): String? = null
-
-        override fun getFallbackBundleURL(): String = "assets://index.android.bundle"
-
-        override fun prepareLaunch(pendingRecovery: PendingCrashRecovery?): LaunchSelection =
-            LaunchSelection(
-                bundleUrl = "assets://index.android.bundle",
-                launchedBundleId = null,
-                shouldRollbackOnCrash = false,
-            )
-
-        override suspend fun updateBundle(
-            bundleId: String,
-            manifestUrl: String,
-            manifestFileHash: String,
-            assets: Map<String, ChangedAssetDescriptor>,
-            archiveUrl: String?,
-            progressCallback: (UpdateProgressPayload) -> Unit,
-        ) = UpdateBundleResult(BundleDelivery.MANIFEST, patchFallback = false)
-
-        override fun markLaunchCompleted(currentBundleId: String?) {
-            lastCompletedBundleId = currentBundleId
-        }
-
-        override fun notifyAppReady(): Map<String, Any?> = mapOf("status" to "UNCHANGED")
-
-        override fun getCrashHistory(): CrashedHistory = CrashedHistory()
-
-        override fun clearCrashHistory(): Boolean = true
-
-        override fun getBaseURL(): String = baseURL
-
-        override fun getBaseURLForBundle(bundleId: String?): String =
-            if (bundleId == null) {
-                ""
-            } else {
-                launchedBundleBaseURLs[bundleId] ?: ""
-            }
-
-        override fun getBundleId(): String? = bundleId
-
-        override fun getManifest(): Map<String, Any?> = manifest
-
-        override fun getManifestForBundle(bundleId: String?): Map<String, Any?> =
-            if (bundleId == null) {
-                emptyMap()
-            } else {
-                launchedBundleManifests[bundleId] ?: emptyMap()
-            }
-
-        override suspend fun resetChannel(): Boolean = true
-    }
-}

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

@@ -1,97 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicInteger
-
-class HotUpdaterRecoveryStateTest {
-    @Test
-    fun `content queued after a fatal error cannot verify the failed bundle`() {
-        val state = HotUpdaterRecoveryState()
-        state.start("crashed-bundle", true)
-
-        val request = requireNotNull(state.requestRecovery())
-        assertNull(state.completeLaunch())
-        state.finishRecoveryRequest(request, true)
-
-        assertNull(state.completeLaunch())
-        assertEquals(HotUpdaterRecoveryState.Launch("crashed-bundle", true), state.snapshot())
-    }
-
-    @Test
-    fun `a fatal error after first content preserves the verified bundle`() {
-        val state = HotUpdaterRecoveryState()
-        state.start("verified-bundle", true)
-
-        assertNotNull(state.completeLaunch())
-
-        assertNull(state.requestRecovery())
-        assertNull(state.completeLaunch())
-        assertEquals(HotUpdaterRecoveryState.Launch("verified-bundle", false), state.snapshot())
-    }
-
-    @Test
-    fun `concurrent fatal errors schedule only one restart while the request is in flight`() {
-        val state = HotUpdaterRecoveryState()
-        state.start("crashed-bundle", true)
-        val begin = CountDownLatch(1)
-        val finished = CountDownLatch(2)
-        val restartRequests = AtomicInteger()
-        val handledErrors = AtomicInteger()
-        val workers =
-            List(2) {
-                Thread {
-                    begin.await()
-                    val request = state.requestRecovery()
-                    if (request != null) {
-                        handledErrors.incrementAndGet()
-                        if (request.shouldRestart) restartRequests.incrementAndGet()
-                    }
-                    finished.countDown()
-                }.apply { start() }
-            }
-        begin.countDown()
-        assertTrue(finished.await(5, TimeUnit.SECONDS))
-        workers.forEach { it.join() }
-
-        assertEquals(2, handledErrors.get())
-        assertEquals(1, restartRequests.get())
-        assertNull(state.completeLaunch())
-    }
-
-    @Test
-    fun `a failed restart keeps the crash unverified and permits another restart request`() {
-        val state = HotUpdaterRecoveryState()
-        state.start("crashed-bundle", true)
-        val request = requireNotNull(state.requestRecovery())
-
-        state.finishRecoveryRequest(request, false)
-
-        assertNull(state.completeLaunch())
-        val retry = requireNotNull(state.requestRecovery())
-        assertTrue(retry.shouldRestart)
-        state.finishRecoveryRequest(retry, true)
-        assertFalse(requireNotNull(state.requestRecovery()).shouldRestart)
-    }
-
-    @Test
-    fun `a previous launch restart completion cannot change the next launch`() {
-        val state = HotUpdaterRecoveryState()
-        state.start("crashed-bundle", true)
-        val request = requireNotNull(state.requestRecovery())
-        state.start("safe-bundle", false)
-
-        state.finishRecoveryRequest(request, true)
-
-        assertEquals("safe-bundle", state.completeLaunch()?.bundleId)
-        state.stop()
-        assertNull(state.snapshot())
-        assertNull(state.requestRecovery())
-    }
-}

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

@@ -1,71 +0,0 @@
-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())
-    }
-}