@hot-updater/react-native 0.29.6 → 0.29.8

package/android/src/main/java/com/hotupdater/OkHttpDownloadService.kt

@@ -235,7 +235,7 @@ class OkHttpDownloadService : DownloadService {
 
                 // Verify file size
                 val finalSize = destination.length()
-                if (finalSize != totalSize) {
+                if (totalSize > 0 && finalSize != totalSize) {
                     Log.d(TAG, "Download incomplete: $finalSize / $totalSize bytes")
 
                     // Delete incomplete file

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

@@ -0,0 +1,111 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.29.6",
+  "version": "0.29.8",
   "description": "React Native OTA solution for self-hosted",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -120,14 +120,14 @@
     "react-native": "0.79.1",
     "react-native-builder-bob": "^0.40.10",
     "typescript": "^6.0.2",
-    "hot-updater": "0.29.6"
+    "hot-updater": "0.29.8"
   },
   "dependencies": {
     "use-sync-external-store": "1.5.0",
-    "@hot-updater/cli-tools": "0.29.6",
-    "@hot-updater/plugin-core": "0.29.6",
-    "@hot-updater/js": "0.29.6",
-    "@hot-updater/core": "0.29.6"
+    "@hot-updater/core": "0.29.8",
+    "@hot-updater/cli-tools": "0.29.8",
+    "@hot-updater/js": "0.29.8",
+    "@hot-updater/plugin-core": "0.29.8"
   },
   "scripts": {
     "build": "bob build && tsc -p plugin/tsconfig.build.json",