@hot-updater/react-native 1.0.0-rc.4 → 1.0.0-rc.40

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

@@ -1,273 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-class HotUpdaterImplTest {
-    @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 `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(),
-        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
-        var lastUserId: String? = null
-        var lastUsername: 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,
-            fileUrl: String?,
-            fileHash: String?,
-            manifestUrl: String?,
-            manifestFileHash: String?,
-            changedAssets: Map<String, ChangedAssetDescriptor>?,
-            progressCallback: (UpdateProgressPayload) -> Unit,
-        ) = 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 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
-
-        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/NativeConfigUtilsTest.kt

@@ -1,20 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Test
-
-class NativeConfigUtilsTest {
-    @Test
-    fun `coerces typed manifest metadata to strings`() {
-        assertEquals("123", NativeConfigUtils.coerceManifestMetaDataString(123))
-        assertEquals("true", NativeConfigUtils.coerceManifestMetaDataString(true))
-        assertEquals("-16711936", NativeConfigUtils.coerceManifestMetaDataString(-16711936))
-    }
-
-    @Test
-    fun `ignores missing and empty manifest metadata`() {
-        assertNull(NativeConfigUtils.coerceManifestMetaDataString(null))
-        assertNull(NativeConfigUtils.coerceManifestMetaDataString(""))
-    }
-}

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

@@ -1,111 +0,0 @@
-package com.hotupdater
-
-import kotlinx.coroutines.runBlocking
-import org.junit.Assert.assertArrayEquals
-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
-import java.net.InetAddress
-import java.net.ServerSocket
-import java.net.Socket
-import java.net.URL
-import kotlin.concurrent.thread
-
-class OkHttpDownloadServiceTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `downloadFile succeeds when content length is unknown`() =
-        runBlocking {
-            val payload = "bundle-content-without-content-length".repeat(512).toByteArray()
-            val server = ChunkedResponseServer(payload)
-
-            try {
-                val destinationDir = temporaryFolder.newFolder("downloads")
-                val destination = File(destinationDir, "bundle.android.bundle")
-                var reportedSize: Long? = null
-
-                val result =
-                    OkHttpDownloadService().downloadFile(
-                        fileUrl = URL("http://127.0.0.1:${server.port}/bundle"),
-                        destination = destination,
-                        fileSizeCallback = { size -> reportedSize = size },
-                        progressCallback = {},
-                    )
-
-                assertTrue(result is DownloadResult.Success)
-                assertEquals(payload.size.toLong(), destination.length())
-                assertArrayEquals(payload, destination.readBytes())
-                assertNull(reportedSize)
-            } finally {
-                server.close()
-            }
-        }
-
-    private class ChunkedResponseServer(
-        private val payload: ByteArray,
-    ) : AutoCloseable {
-        private val serverSocket = ServerSocket(0, 1, InetAddress.getByName("127.0.0.1"))
-        private val worker =
-            thread(start = true, isDaemon = true) {
-                serverSocket.use { socket ->
-                    socket.accept().use(::respond)
-                }
-            }
-
-        val port: Int = serverSocket.localPort
-
-        private fun respond(client: Socket) {
-            drainRequestHeaders(client)
-
-            client.getOutputStream().use { output ->
-                output.write(
-                    (
-                        "HTTP/1.1 200 OK\r\n" +
-                            "Content-Type: application/octet-stream\r\n" +
-                            "Transfer-Encoding: chunked\r\n" +
-                            "Connection: close\r\n" +
-                            "\r\n"
-                    ).toByteArray(),
-                )
-                output.write(payload.size.toString(16).toByteArray())
-                output.write("\r\n".toByteArray())
-                output.write(payload)
-                output.write("\r\n0\r\n\r\n".toByteArray())
-                output.flush()
-            }
-        }
-
-        private fun drainRequestHeaders(client: Socket) {
-            val input = client.getInputStream()
-            var matched = 0
-            val terminator = byteArrayOf('\r'.code.toByte(), '\n'.code.toByte(), '\r'.code.toByte(), '\n'.code.toByte())
-
-            while (matched < terminator.size) {
-                val next = input.read()
-                if (next == -1) {
-                    break
-                }
-
-                matched =
-                    if (next.toByte() == terminator[matched]) {
-                        matched + 1
-                    } else if (next.toByte() == terminator[0]) {
-                        1
-                    } else {
-                        0
-                    }
-            }
-        }
-
-        override fun close() {
-            serverSocket.close()
-            worker.join(1_000)
-        }
-    }
-}

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

@@ -1,41 +0,0 @@
-package com.hotupdater
-
-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 RelativePathResolverTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `resolves a standard archive directory entry ending in a slash`() {
-        val root = temporaryFolder.root
-
-        val resolved = RelativePathResolver.resolveInside(root, "drawable-mdpi/")
-
-        assertEquals(
-            File(root, "drawable-mdpi").canonicalFile,
-            resolved?.canonicalFile,
-        )
-    }
-
-    @Test
-    fun `rejects unsafe archive directory paths ending in a slash`() {
-        val root = temporaryFolder.root
-        val unsafePaths =
-            listOf(
-                "/",
-                "../",
-                "drawable-mdpi/../",
-                "drawable-mdpi//",
-            )
-
-        unsafePaths.forEach { path ->
-            assertNull(path, RelativePathResolver.resolveInside(root, path))
-        }
-    }
-}

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

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

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

@@ -1,68 +0,0 @@
-package com.hotupdater
-
-import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertThrows
-import org.junit.Test
-import java.io.ByteArrayInputStream
-import java.io.ByteArrayOutputStream
-import org.apache.commons.compress.archivers.tar.TarArchiveEntry as CommonsTarArchiveEntry
-
-class TarArchiveInputStreamTest {
-    @Test
-    fun `reads a long basename from a POSIX PAX header`() {
-        val path = "raw/${"long-name-".repeat(14)}asset.bmp"
-        val contents = "pax asset".toByteArray()
-        val archive = createPaxArchive(path, contents)
-
-        TarArchiveInputStream(ByteArrayInputStream(archive)).use { tar ->
-            val entry = tar.getNextEntry()
-
-            assertEquals(path, entry?.name)
-            assertArrayEquals(contents, tar.readBytes())
-            assertNull(tar.getNextEntry())
-        }
-    }
-
-    @Test
-    fun `rejects path traversal from a POSIX PAX header`() {
-        val path = "../${"long-name-".repeat(14)}asset.bmp"
-        val archive =
-            createPaxArchive(
-                path = path,
-                contents = "malicious".toByteArray(),
-                headerPath = "safe.bmp",
-            )
-
-        val error =
-            assertThrows(SecurityException::class.java) {
-                TarArchiveInputStream(ByteArrayInputStream(archive)).use { tar ->
-                    tar.getNextEntry()
-                }
-            }
-
-        assertEquals("Path traversal detected: $path", error.message)
-    }
-
-    private fun createPaxArchive(
-        path: String,
-        contents: ByteArray,
-        headerPath: String = path,
-    ): ByteArray {
-        val output = ByteArrayOutputStream()
-        TarArchiveOutputStream(output).use { tar ->
-            tar.setLongFileMode(TarArchiveOutputStream.LONGFILE_POSIX)
-            val entry =
-                CommonsTarArchiveEntry(headerPath).apply {
-                    size = contents.size.toLong()
-                    if (path != headerPath) addPaxHeader("path", path)
-                }
-            tar.putArchiveEntry(entry)
-            tar.write(contents)
-            tar.closeArchiveEntry()
-        }
-        return output.toByteArray()
-    }
-}