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

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/TarBrArchiveExtractorTest.kt

@@ -1,206 +0,0 @@
-package com.hotupdater
-
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertThrows
-import org.junit.Rule
-import org.junit.Test
-import org.junit.rules.TemporaryFolder
-import java.io.ByteArrayInputStream
-import java.io.ByteArrayOutputStream
-import java.io.File
-import java.io.IOException
-import java.util.Base64
-
-class TarBrArchiveExtractorTest {
-    @get:Rule
-    val temporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `extracts exact regular file set`() {
-        val destination = extract(VALID, 3072, mapOf("assets/image.png" to 5, "index.android.bundle" to 6))
-
-        assertArrayEquals("image".toByteArray(), File(destination, "assets/image.png").readBytes())
-        assertArrayEquals("bundle".toByteArray(), File(destination, "index.android.bundle").readBytes())
-    }
-
-    @Test
-    fun `supports a POSIX PAX long path`() {
-        val path = "assets/${"x".repeat(120)}.bin"
-        val destination = extract(PAX_LONG_PATH, 3072, mapOf(path to 4))
-
-        assertArrayEquals("long".toByteArray(), File(destination, path).readBytes())
-    }
-
-    @Test
-    fun `rejects duplicate unsafe linked and malformed archives`() {
-        val cases =
-            listOf(
-                Triple(DUPLICATE, 3072L, mapOf("index.android.bundle" to 6L)),
-                Triple(TRAVERSAL, 2048L, mapOf("../escape" to 3L)),
-                Triple(SYMLINK, 1536L, mapOf("index.android.bundle" to 0L)),
-                Triple(SINGLE_END_BLOCK, 1536L, mapOf("index.android.bundle" to 6L)),
-                Triple(TRAILING_NON_ZERO, 2560L, mapOf("index.android.bundle" to 6L)),
-            )
-
-        cases.forEachIndexed { index, (fixture, tarSize, files) ->
-            val archive = temporaryFolder.newFile("invalid-$index.tar.br").apply { writeBytes(decode(fixture)) }
-            val destination = File(temporaryFolder.root, "invalid-$index")
-
-            assertThrows(Exception::class.java) {
-                TarBrArchiveExtractor.extract(archive, destination, tarSize, files)
-            }
-            check(!destination.exists())
-        }
-    }
-
-    @Test
-    fun `rejects dangling consecutive duplicate and unsupported extension metadata`() {
-        val pathRecord = paxRecord("path", "index.android.bundle")
-        val malformedShortRecord = "3 \n".toByteArray()
-        val cases =
-            listOf(
-                tarArchive(tarEntry("PaxHeader", 'x', pathRecord)),
-                tarArchive(
-                    tarEntry("PaxHeader", 'x', pathRecord),
-                    tarEntry("PaxHeader", 'x', pathRecord),
-                ),
-                tarArchive(
-                    tarEntry("PaxHeader", 'x', pathRecord + paxRecord("path", "other")),
-                    regularEntry("ignored", "bundle"),
-                ),
-                tarArchive(
-                    tarEntry("PaxHeader", 'x', malformedShortRecord),
-                    regularEntry("ignored", "bundle"),
-                ),
-                tarArchive(
-                    tarEntry("PaxHeader", 'x', paxRecord("linkpath", "target")),
-                    regularEntry("index.android.bundle", "bundle"),
-                ),
-                tarArchive(tarEntry("LongLink", 'L', "name\u0000".toByteArray())),
-            )
-
-        cases.forEach { bytes ->
-            assertThrows(IOException::class.java) { consumeTar(bytes) }
-        }
-    }
-
-    @Test
-    fun `preserves exact header paths and applies PAX size`() {
-        val spacedPathArchive = tarArchive(regularEntry("index.android.bundle ", "bundle"))
-        TarArchiveInputStream(ByteArrayInputStream(spacedPathArchive)).use { input ->
-            assertEquals("index.android.bundle ", input.getNextEntry()?.name)
-        }
-
-        val payload = "data".toByteArray()
-        val paxSizeArchive =
-            tarArchive(
-                tarEntry("PaxHeader", 'x', paxRecord("size", payload.size.toString())),
-                tarEntry("index.android.bundle", '0', payload, declaredSize = 1),
-            )
-        TarArchiveInputStream(ByteArrayInputStream(paxSizeArchive)).use { input ->
-            val entry = input.getNextEntry()
-            assertEquals(payload.size.toLong(), entry?.size)
-            assertArrayEquals(payload, input.readBytes())
-            assertEquals(null, input.getNextEntry())
-        }
-    }
-
-    private fun extract(
-        fixture: String,
-        tarSize: Long,
-        files: Map<String, Long>,
-    ): File {
-        val archive = temporaryFolder.newFile("fixture-${System.nanoTime()}.tar.br").apply { writeBytes(decode(fixture)) }
-        val destination = File(temporaryFolder.root, "extracted-${System.nanoTime()}")
-        TarBrArchiveExtractor.extract(archive, destination, tarSize, files)
-        return destination
-    }
-
-    private fun decode(value: String): ByteArray = Base64.getDecoder().decode(value)
-
-    private fun consumeTar(bytes: ByteArray) {
-        TarArchiveInputStream(ByteArrayInputStream(bytes)).use { input ->
-            while (input.getNextEntry() != null) input.readBytes()
-        }
-    }
-
-    private fun paxRecord(
-        key: String,
-        value: String,
-    ): ByteArray {
-        var length = key.toByteArray().size + value.toByteArray().size + 3
-        while (true) {
-            val record = "$length $key=$value\n".toByteArray()
-            if (record.size == length) return record
-            length = record.size
-        }
-    }
-
-    private fun regularEntry(
-        name: String,
-        content: String,
-    ): ByteArray = tarEntry(name, '0', content.toByteArray())
-
-    private fun tarEntry(
-        name: String,
-        type: Char,
-        payload: ByteArray,
-        declaredSize: Int = payload.size,
-    ): ByteArray {
-        val header = ByteArray(512)
-        name.toByteArray().copyInto(header, endIndex = name.toByteArray().size.coerceAtMost(100))
-        writeOctal(header, 100, 8, 420)
-        writeOctal(header, 108, 8, 0)
-        writeOctal(header, 116, 8, 0)
-        writeOctal(header, 124, 12, declaredSize)
-        writeOctal(header, 136, 12, 0)
-        for (index in 148 until 156) header[index] = ' '.code.toByte()
-        header[156] = type.code.toByte()
-        "ustar".toByteArray().copyInto(header, 257)
-        writeOctal(header, 148, 8, header.sumOf { it.toInt() and 0xff })
-
-        return ByteArrayOutputStream()
-            .apply {
-                write(header)
-                write(payload)
-                write(ByteArray((512 - payload.size % 512) % 512))
-            }.toByteArray()
-    }
-
-    private fun tarArchive(vararg entries: ByteArray): ByteArray =
-        ByteArrayOutputStream()
-            .apply {
-                entries.forEach(::write)
-                write(ByteArray(1024))
-            }.toByteArray()
-
-    private fun writeOctal(
-        target: ByteArray,
-        offset: Int,
-        length: Int,
-        value: Int,
-    ) {
-        val digits = value.toString(8).padStart(length - 2, '0')
-        digits.toByteArray().copyInto(target, offset)
-        target[offset + length - 2] = 0
-        target[offset + length - 1] = ' '.code.toByte()
-    }
-
-    companion object {
-        const val VALID =
-            "G/8LYI7UVnlCO6lhAMTqIo5tMQLiY7NptuP57iYyogHNeF9BlHNiXHeDMLCAJL3h9im3UyYnSs3aLbJIIBsjml0YwV1+Hd11htDfIA8GgPKHFrFNtD7SOfZo/h9mbgDYuSAJIPmy9Z2b"
-        private const val DUPLICATE =
-            "G/8L4I/UVnlCO6lh6sQAIm5ssV7ksdnUyXHelkgImbdLFCl08DwgyVOGdSmhfs8LgniesZ82/bHw7qIYoXwdSTsMVSkOBkDMM0vqHj11Ew=="
-        private const val TRAVERSAL =
-            "G/8H+AfKbRfTdvBDW1YMVZ0c3w7fLhJCyAFHCIm3xTUACIRyzK7qNZRgrBkUGlOQ+PtOBlH/uDAUZ9s9Dw=="
-        private const val SYMLINK =
-            "G/8FoI7UYs0ZrwQiHgYxvWizaUNMJ8cnP4h9lyiDwKKELcCA8pSZdZEoyN91S9BvNObx0n8IcrtxYn2sUe6QrffCuHk8LCgA"
-        private const val SINGLE_END_BLOCK =
-            "G/8F4I/UVnlCO6lh6sQAIm5ssV7ksdnUyfH9WyIhZN4uUaQSeB6Q5DGGvrXYkguCOs/YT5v+GLy7ECOUryNph6EqxcEAinlmEw=="
-        private const val TRAILING_NON_ZERO =
-            "G/8J4Adqc2ds55CPYbC2qk6O87ZEQsi0tUsUKUXN80TyGEPfWmyJBUGcZ6y72vQfJjUzyChogu7Xu5ODMLcUB0MBYu7ZOLkF"
-        private const val PAX_LONG_PATH =
-            "G/8LYAbCtn2mBfjh0GTohqrNYvNuZjueb2Ij3vmAJjz8C6jLIEtYgqi7gAMNAII62ZkiZILxgnbd1QSM8usRpO6ZyCgYZiz8dTRcx0YB/gG5MBRqZPyVyrk8J47iYenP+zXoZcGa8QLgayISZoflgdi14Q=="
-    }
-}

package/lib/commonjs/appReady.spec.js

@@ -1,360 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _appReadyTestUtils = require("./appReady.test-utils.js");
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-_vitest.vi.mock("react-native", () => ({
-  Platform: {
-    OS: "ios"
-  }
-}));
-const mocks = _vitest.vi.hoisted(() => {
-  Reflect.set(globalThis, "HotUpdater", {
-    SDK_VERSION: "test-sdk-version"
-  });
-  return {
-    getAppVersion: _vitest.vi.fn(() => "1.0.0"),
-    getBundleId: _vitest.vi.fn(() => "bundle-id"),
-    getChannel: _vitest.vi.fn(() => "production"),
-    getActiveUpdateState: _vitest.vi.fn(),
-    getCohort: _vitest.vi.fn(() => "123"),
-    getFingerprintHash: _vitest.vi.fn(() => "fingerprint-hash"),
-    getInstallId: _vitest.vi.fn(() => "install-id"),
-    getStorageItem: _vitest.vi.fn(() => null),
-    setStorageItem: _vitest.vi.fn(),
-    readNotifyAppReady: _vitest.vi.fn(() => (0, _appReadyTestUtils.createNotifyReadResult)())
-  };
-});
-_vitest.vi.mock("./native", () => mocks);
-const recordingPlugin = (hooks = events => ({
-  onAppReady: result => {
-    events.push(["onAppReady", result]);
-  },
-  onBundleDownloaded: info => {
-    events.push(["onBundleDownloaded", info]);
-  }
-})) => {
-  const events = [];
-  const plugin = {
-    id: "recorder",
-    setup: () => hooks(events)
-  };
-  return {
-    events,
-    plugin
-  };
-};
-const configure = async (plugins, onError) => {
-  const {
-    configurePlugins
-  } = await Promise.resolve().then(() => _interopRequireWildcard(require("./pluginHost")));
-  configurePlugins(plugins, {
-    baseURL: "https://updates.example.com",
-    ...(onError ? {
-      onError
-    } : {})
-  });
-};
-(0, _vitest.describe)("app-ready reporting to plugins", () => {
-  (0, _vitest.beforeEach)(() => {
-    _vitest.vi.resetModules();
-    _vitest.vi.unstubAllGlobals();
-    _vitest.vi.useRealTimers();
-    for (const mock of Object.values(mocks)) mock.mockReset();
-    mocks.getAppVersion.mockReturnValue("1.0.0");
-    mocks.getBundleId.mockReturnValue("bundle-id");
-    mocks.getChannel.mockReturnValue("production");
-    mocks.getActiveUpdateState.mockReturnValue({
-      activeSelection: null,
-      stableSelection: null,
-      verificationPending: false
-    });
-    mocks.getCohort.mockReturnValue("123");
-    mocks.getFingerprintHash.mockReturnValue("fingerprint-hash");
-    mocks.getInstallId.mockReturnValue("install-id");
-    mocks.getStorageItem.mockReturnValue(null);
-    mocks.readNotifyAppReady.mockReturnValue((0, _appReadyTestUtils.createNotifyReadResult)());
-  });
-  _vitest.it.each([{
-    label: "running selection",
-    pending: false,
-    channel: "production",
-    expected: "release-running"
-  }, {
-    label: "staged selection",
-    pending: true,
-    channel: "production",
-    expected: "release-running"
-  }, {
-    label: "another channel",
-    pending: false,
-    channel: "preview",
-    expected: null
-  }])("attributes an unchanged launch with $label", async ({
-    pending,
-    channel,
-    expected
-  }) => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    const running = {
-      kind: "BUNDLE",
-      releaseId: "release-running",
-      bundleId: "bundle-id",
-      channel
-    };
-    mocks.getActiveUpdateState.mockReturnValue({
-      activeSelection: pending ? {
-        ...running,
-        releaseId: "release-pending",
-        bundleId: "bundle-pending"
-      } : running,
-      stableSelection: pending ? running : null,
-      verificationPending: pending
-    });
-    const {
-      events,
-      plugin
-    } = recordingPlugin();
-    await configure([plugin]);
-    const {
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    const readiness = handleNotifyAppReady({});
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    await readiness;
-    (0, _vitest.expect)(events).toEqual([["onAppReady", {
-      status: "UNCHANGED",
-      channel: "production",
-      bundleId: "bundle-id",
-      releaseId: expected,
-      previousProcessExit: null
-    }]]);
-  });
-  _vitest.it.each(["UPDATE_APPLIED", "RECOVERED"])("reports %s with the persisted transition and calls onNotifyAppReady", async status => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    mocks.readNotifyAppReady.mockReturnValue((0, _appReadyTestUtils.createNotifyReadResult)({
-      status,
-      fromBundleId: "bundle-a",
-      toBundleId: "bundle-b"
-    }, {
-      type: status,
-      fromBundleId: "bundle-a",
-      fromReleaseId: "release-a",
-      toBundleId: "bundle-b",
-      toReleaseId: "release-b",
-      updateStrategy: "fingerprint"
-    }));
-    const {
-      events,
-      plugin
-    } = recordingPlugin();
-    await configure([plugin]);
-    const onNotifyAppReady = _vitest.vi.fn();
-    const {
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    const readiness = handleNotifyAppReady({
-      onNotifyAppReady
-    });
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    await readiness;
-    (0, _vitest.expect)(events).toEqual([["onAppReady", {
-      status,
-      channel: "production",
-      fromBundleId: "bundle-a",
-      fromReleaseId: "release-a",
-      toBundleId: "bundle-b",
-      toReleaseId: "release-b",
-      updateStrategy: "fingerprint",
-      previousProcessExit: null
-    }]]);
-    (0, _vitest.expect)(onNotifyAppReady).toHaveBeenCalledWith({
-      status,
-      fromBundleId: "bundle-a",
-      toBundleId: "bundle-b"
-    });
-  });
-  (0, _vitest.it)("waits for native launch verification before reporting", async () => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    mocks.readNotifyAppReady.mockReturnValueOnce((0, _appReadyTestUtils.createNotifyReadResult)(undefined, null, true)).mockReturnValueOnce((0, _appReadyTestUtils.createNotifyReadResult)(undefined, null, true)).mockReturnValue((0, _appReadyTestUtils.createNotifyReadResult)());
-    const {
-      events,
-      plugin
-    } = recordingPlugin();
-    await configure([plugin]);
-    const {
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    const readiness = handleNotifyAppReady({});
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    (0, _vitest.expect)(events).toEqual([]);
-    await _vitest.vi.runAllTimersAsync();
-    await readiness;
-    (0, _vitest.expect)(mocks.readNotifyAppReady).toHaveBeenCalledTimes(3);
-    (0, _vitest.expect)(events).toHaveLength(1);
-  });
-  (0, _vitest.it)("reports the launch once per runtime while every init call gets readiness", async () => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    const {
-      events,
-      plugin
-    } = recordingPlugin();
-    await configure([plugin]);
-    const onNotifyAppReady = _vitest.vi.fn();
-    const {
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    const first = handleNotifyAppReady({
-      onNotifyAppReady
-    });
-    const second = handleNotifyAppReady({
-      onNotifyAppReady
-    });
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    await Promise.all([first, second]);
-    (0, _vitest.expect)(events).toHaveLength(1);
-    (0, _vitest.expect)(onNotifyAppReady).toHaveBeenCalledTimes(2);
-  });
-  (0, _vitest.it)("skips onAppReady for an applied launch without its persisted transition", async () => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    mocks.readNotifyAppReady.mockReturnValue((0, _appReadyTestUtils.createNotifyReadResult)({
-      status: "UPDATE_APPLIED",
-      fromBundleId: "bundle-a",
-      toBundleId: "bundle-b"
-    }, null));
-    const {
-      events,
-      plugin
-    } = recordingPlugin();
-    await configure([plugin]);
-    const onNotifyAppReady = _vitest.vi.fn();
-    const {
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    const readiness = handleNotifyAppReady({
-      onNotifyAppReady
-    });
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    await readiness;
-    (0, _vitest.expect)(events).toEqual([]);
-    (0, _vitest.expect)(onNotifyAppReady).toHaveBeenCalledOnce();
-  });
-  (0, _vitest.it)("reports a throwing or rejecting hook through onError and keeps readiness", async () => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    const onError = _vitest.vi.fn();
-    const throwing = {
-      id: "throwing",
-      setup: () => ({
-        onAppReady: () => {
-          throw new Error("hook failed");
-        }
-      })
-    };
-    const rejecting = {
-      id: "rejecting",
-      setup: () => ({
-        onAppReady: async () => {
-          throw new Error("hook rejected");
-        }
-      })
-    };
-    await configure([throwing, rejecting], onError);
-    const onNotifyAppReady = _vitest.vi.fn();
-    const {
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    const readiness = handleNotifyAppReady({
-      onNotifyAppReady
-    });
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    await readiness;
-    await _vitest.vi.runAllTimersAsync();
-    (0, _vitest.expect)(onNotifyAppReady).toHaveBeenCalledWith({
-      status: "UNCHANGED"
-    });
-    (0, _vitest.expect)(onError).toHaveBeenCalledTimes(2);
-    (0, _vitest.expect)(onError).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      message: '[HotUpdater] Plugin "throwing" failed in onAppReady',
-      cause: _vitest.expect.objectContaining({
-        message: "hook failed"
-      })
-    }));
-    (0, _vitest.expect)(onError).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      message: '[HotUpdater] Plugin "rejecting" failed in onAppReady'
-    }));
-  });
-  (0, _vitest.it)("delivers events after the launch, even when they happen first", async () => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    const {
-      events,
-      plugin
-    } = recordingPlugin();
-    await configure([plugin]);
-    const {
-      emitAfterAppReady,
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    const readiness = handleNotifyAppReady({});
-    emitAfterAppReady("onBundleDownloaded", () => ({
-      channel: "production",
-      fromBundleId: "bundle-id",
-      fromReleaseId: null,
-      toBundleId: "next-bundle",
-      toReleaseId: "next-release",
-      updateStrategy: "appVersion",
-      delivery: "manifest",
-      patchFallback: false
-    }));
-    (0, _vitest.expect)(events).toEqual([]);
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    await readiness;
-    await Promise.resolve();
-    (0, _vitest.expect)(events.map(event => event[0])).toEqual(["onAppReady", "onBundleDownloaded"]);
-  });
-  (0, _vitest.it)("passes on why the previous process exited, and keeps it for later events", async () => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    mocks.readNotifyAppReady.mockReturnValue((0, _appReadyTestUtils.createNotifyReadResult)({
-      status: "RECOVERED",
-      fromBundleId: "bundle-b",
-      toBundleId: "bundle-a"
-    }, {
-      type: "RECOVERED",
-      fromBundleId: "bundle-b",
-      fromReleaseId: null,
-      toBundleId: "bundle-a",
-      toReleaseId: null,
-      updateStrategy: "appVersion"
-    }, false, "CRASH_NATIVE"));
-    const {
-      events,
-      plugin
-    } = recordingPlugin();
-    await configure([plugin]);
-    const {
-      getPreviousProcessExit,
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    (0, _vitest.expect)(getPreviousProcessExit()).toBeNull();
-    const readiness = handleNotifyAppReady({});
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    await readiness;
-    (0, _vitest.expect)(events).toEqual([["onAppReady", _vitest.expect.objectContaining({
-      status: "RECOVERED",
-      previousProcessExit: "CRASH_NATIVE"
-    })]]);
-    (0, _vitest.expect)(getPreviousProcessExit()).toBe("CRASH_NATIVE");
-  });
-  (0, _vitest.it)("builds no event when no plugin listens", async () => {
-    (0, _appReadyTestUtils.stubNotifyFrame)();
-    await configure([]);
-    const {
-      handleNotifyAppReady
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./appReady")));
-    const readiness = handleNotifyAppReady({});
-    await _vitest.vi.runOnlyPendingTimersAsync();
-    await readiness;
-    (0, _vitest.expect)(mocks.getActiveUpdateState).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.getBundleId).not.toHaveBeenCalled();
-  });
-});
-//# sourceMappingURL=appReady.spec.js.map