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

package/lib/commonjs/plugins/insights/insights.spec.js

@@ -0,0 +1,640 @@
+"use strict";
+
+var _core = require("@hot-updater/core");
+var _vitest = require("vitest");
+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 native = _vitest.vi.hoisted(() => {
+  Reflect.set(globalThis, "HotUpdater", {
+    SDK_VERSION: "test-sdk-version"
+  });
+  const storage = new Map();
+  return {
+    storage,
+    getAppVersion: _vitest.vi.fn(() => "1.0.0"),
+    getBundleId: _vitest.vi.fn(() => "bundle-a"),
+    getChannel: _vitest.vi.fn(() => "production"),
+    getCohort: _vitest.vi.fn(() => "123"),
+    getFingerprintHash: _vitest.vi.fn(() => "fingerprint-hash"),
+    getInstallId: _vitest.vi.fn(() => "install-id"),
+    getStorageItem: _vitest.vi.fn(key => storage.get(key) ?? null),
+    setStorageItem: _vitest.vi.fn((key, value) => {
+      if (value === null) storage.delete(key);else storage.set(key, value);
+    })
+  };
+});
+_vitest.vi.mock("../../native", () => native);
+const DAY_MS = 86_400_000;
+const MORNING = Date.UTC(2026, 8, 30, 9);
+let responses = [];
+const fetchMock = _vitest.vi.fn(async (_url, _init) => {
+  const next = responses.shift() ?? 204;
+  return typeof next === "number" ? new Response(null, {
+    status: next
+  }) : next();
+});
+const sentEvents = () => fetchMock.mock.calls.map(([, init]) => JSON.parse(String(init?.body)));
+const sentTypes = () => sentEvents().map(({
+  type
+}) => type);
+
+/** A server without Insights mounts no `/events`. */
+const disabledResponse = () => new Response(null, {
+  status: 404
+});
+
+/** Starts a JavaScript runtime with the plugin; native storage persists across launches. */
+const launch = async (options = {}, beforeInit) => {
+  _vitest.vi.resetModules();
+  const [{
+    configurePlugins,
+    emitPluginHook
+  }, {
+    insights
+  }] = await Promise.all([Promise.resolve().then(() => _interopRequireWildcard(require("../../pluginHost"))), Promise.resolve().then(() => _interopRequireWildcard(require("./index")))]);
+  const plugin = insights(options);
+  beforeInit?.(plugin);
+  configurePlugins([plugin], {
+    baseURL: "https://updates.example.com/hot-updater",
+    requestHeaders: {
+      "x-api-key": "client-key"
+    }
+  });
+  const emit = (name, payload) => {
+    emitPluginHook(name, () => payload);
+  };
+  return {
+    plugin,
+    appReady: result => emit("onAppReady", result),
+    updateCheck: result => emit("onUpdateCheck", result),
+    downloaded: info => emit("onBundleDownloaded", info),
+    updateError: error => emit("onUpdateError", error)
+  };
+};
+const unchangedLaunch = (overrides = {}) => ({
+  status: "UNCHANGED",
+  channel: "production",
+  bundleId: "bundle-a",
+  releaseId: "release-a",
+  previousProcessExit: null,
+  ...overrides
+});
+const appliedLaunch = {
+  status: "UPDATE_APPLIED",
+  channel: "production",
+  fromBundleId: "bundle-a",
+  fromReleaseId: "release-a",
+  toBundleId: "bundle-b",
+  toReleaseId: "release-b",
+  updateStrategy: "appVersion",
+  previousProcessExit: null
+};
+const download = {
+  channel: "production",
+  fromBundleId: "bundle-a",
+  fromReleaseId: "release-a",
+  toBundleId: "bundle-b",
+  toReleaseId: "release-b",
+  updateStrategy: "appVersion",
+  delivery: "manifest",
+  patchFallback: false
+};
+const downloadFailure = (overrides = {}) => ({
+  stage: "download",
+  reason: "hash_mismatch",
+  targetBundleId: "bundle-b",
+  targetReleaseId: "release-b",
+  channel: "production",
+  bundleId: "bundle-a",
+  releaseId: "release-a",
+  updateStrategy: "fingerprint",
+  cause: new Error("hash mismatch"),
+  ...overrides
+});
+const flush = () => _vitest.vi.runAllTimersAsync();
+(0, _vitest.describe)("insights() client plugin", () => {
+  (0, _vitest.beforeEach)(() => {
+    _vitest.vi.useFakeTimers({
+      now: MORNING
+    });
+    _vitest.vi.spyOn(Math, "random").mockReturnValue(0.5);
+    _vitest.vi.stubGlobal("fetch", fetchMock);
+    _vitest.vi.stubGlobal("__DEV__", false);
+    fetchMock.mockClear();
+    responses = [];
+    native.storage.clear();
+    native.getAppVersion.mockReturnValue("1.0.0");
+  });
+  (0, _vitest.afterEach)(() => {
+    _vitest.vi.useRealTimers();
+    _vitest.vi.unstubAllGlobals();
+    _vitest.vi.restoreAllMocks();
+  });
+  (0, _vitest.it)("posts a launch as UNCHANGED with the app's identity", async () => {
+    const app = await launch();
+    app.appReady(unchangedLaunch());
+    await flush();
+    (0, _vitest.expect)(fetchMock).toHaveBeenCalledOnce();
+    const [url, init] = fetchMock.mock.calls[0];
+    (0, _vitest.expect)(url).toBe("https://updates.example.com/hot-updater/events");
+    (0, _vitest.expect)(new Headers(init?.headers).get("x-api-key")).toBe("client-key");
+    const [event] = sentEvents();
+    (0, _vitest.expect)((0, _core.isUUIDv7)(event?.eventId)).toBe(true);
+    (0, _vitest.expect)(event).toEqual({
+      appVersion: "1.0.0",
+      channel: "production",
+      cohort: "123",
+      eventId: event?.eventId,
+      fingerprintHash: "fingerprint-hash",
+      fromBundleId: null,
+      fromReleaseId: null,
+      installId: "install-id",
+      platform: "ios",
+      sdkVersion: "test-sdk-version",
+      toBundleId: "bundle-a",
+      toReleaseId: "release-a",
+      type: "UNCHANGED",
+      updateStrategy: null
+    });
+  });
+  (0, _vitest.describe)("daily launch reports", () => {
+    (0, _vitest.it)("sends UNCHANGED at most once per UTC day across launches", async () => {
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      _vitest.vi.setSystemTime(Date.UTC(2026, 8, 30, 23, 59));
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      (0, _vitest.expect)(fetchMock).toHaveBeenCalledOnce();
+      _vitest.vi.setSystemTime(Date.UTC(2026, 9, 1, 0, 1));
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED", "UNCHANGED"]);
+    });
+    _vitest.it.each([{
+      label: "channel",
+      change: {
+        channel: "beta"
+      }
+    }, {
+      label: "bundle",
+      change: {
+        bundleId: "bundle-c"
+      }
+    }, {
+      label: "Release",
+      change: {
+        releaseId: "release-c"
+      }
+    }])("reports a launch again the same day when its $label changes", async ({
+      change
+    }) => {
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      (await launch()).appReady(unchangedLaunch(change));
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED", "UNCHANGED"]);
+    });
+    (0, _vitest.it)("reports a launch again the same day when the app version or user changes", async () => {
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      native.getAppVersion.mockReturnValue("1.0.1");
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      const app = await launch();
+      app.plugin.setUser({
+        userId: "user-1"
+      });
+      app.appReady(unchangedLaunch());
+      await flush();
+      (0, _vitest.expect)(sentEvents().map(({
+        appVersion,
+        userId
+      }) => [appVersion, userId])).toEqual([["1.0.0", undefined], ["1.0.1", undefined], ["1.0.1", "user-1"]]);
+    });
+    (0, _vitest.it)("counts a delivered apply as the day's report of its bundle", async () => {
+      (await launch()).appReady(appliedLaunch);
+      await flush();
+      (await launch()).appReady(unchangedLaunch({
+        bundleId: "bundle-b",
+        releaseId: "release-b"
+      }));
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UPDATE_APPLIED"]);
+    });
+    (0, _vitest.it)("reports the next launch after a delivered download or failure", async () => {
+      const first = await launch();
+      first.appReady(unchangedLaunch());
+      await flush();
+      first.downloaded(download);
+      await flush();
+      const second = await launch();
+      second.appReady(unchangedLaunch());
+      await flush();
+      second.updateError(downloadFailure());
+      await flush();
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED", "UPDATE_DOWNLOADED", "UNCHANGED", "UPDATE_FAILED", "UNCHANGED"]);
+    });
+    (0, _vitest.it)("reports the launch again when the server did not store it", async () => {
+      responses = [400];
+      _vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED", "UNCHANGED"]);
+    });
+    (0, _vitest.it)("always sends downloads, applies, and recoveries", async () => {
+      const first = await launch();
+      first.appReady(unchangedLaunch());
+      first.downloaded(download);
+      await flush();
+      (await launch()).appReady(appliedLaunch);
+      (await launch()).appReady({
+        ...appliedLaunch,
+        status: "RECOVERED",
+        fromBundleId: "bundle-b",
+        toBundleId: "bundle-a"
+      });
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED", "UPDATE_DOWNLOADED", "UPDATE_APPLIED", "RECOVERED"]);
+    });
+    (0, _vitest.it)("sends one report when the launch and a no-update check both report", async () => {
+      const app = await launch();
+      app.appReady(unchangedLaunch());
+      app.updateCheck({
+        status: "UNCHANGED",
+        channel: "production",
+        bundleId: "bundle-a",
+        releaseId: "release-a",
+        previousReleaseId: "release-a"
+      });
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED"]);
+    });
+    (0, _vitest.it)("reports a same-bundle Release adoption with the Release it replaced", async () => {
+      const app = await launch();
+      app.appReady(unchangedLaunch());
+      await flush();
+      app.updateCheck({
+        status: "UNCHANGED",
+        channel: "production",
+        bundleId: "bundle-a",
+        releaseId: "release-a2",
+        previousReleaseId: "release-a"
+      });
+      await flush();
+      (0, _vitest.expect)(sentEvents()[1]).toMatchObject({
+        fromReleaseId: "release-a",
+        toBundleId: "bundle-a",
+        toReleaseId: "release-a2",
+        type: "UNCHANGED"
+      });
+    });
+    (0, _vitest.it)("sends no launch report after a download in the same runtime", async () => {
+      const app = await launch();
+      app.downloaded(download);
+      app.downloaded(download);
+      app.updateCheck({
+        status: "UNCHANGED",
+        channel: "production",
+        bundleId: "bundle-b",
+        releaseId: "release-b",
+        previousReleaseId: "release-b"
+      });
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UPDATE_DOWNLOADED"]);
+    });
+  });
+  (0, _vitest.describe)("when the server runs without Insights", () => {
+    (0, _vitest.it)("sends nothing more in this runtime after a 404", async () => {
+      responses = [disabledResponse];
+      const app = await launch();
+      app.appReady(unchangedLaunch());
+      await flush();
+      app.downloaded(download);
+      await flush();
+      _vitest.vi.setSystemTime(MORNING + 2 * DAY_MS);
+      app.updateError(downloadFailure());
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED"]);
+    });
+    (0, _vitest.it)("pauses later launches for 24 hours, then probes again", async () => {
+      responses = [disabledResponse];
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      _vitest.vi.setSystemTime(MORNING + DAY_MS - 1);
+      (await launch()).appReady(appliedLaunch);
+      await flush();
+      (0, _vitest.expect)(fetchMock).toHaveBeenCalledOnce();
+      _vitest.vi.setSystemTime(MORNING + DAY_MS);
+      (await launch()).appReady(appliedLaunch);
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED", "UPDATE_APPLIED"]);
+
+      // The probe was stored, so Insights is on again.
+      (await launch()).appReady({
+        ...appliedLaunch,
+        toBundleId: "bundle-c"
+      });
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED", "UPDATE_APPLIED", "UPDATE_APPLIED"]);
+    });
+    (0, _vitest.it)("ends a pause that starts after now, from a clock that went back", async () => {
+      native.storage.set("plugins/insights/pausedAt", String(MORNING + 60 * 60 * 1000));
+      (await launch()).appReady(unchangedLaunch());
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED"]);
+    });
+  });
+  (0, _vitest.describe)("update failures", () => {
+    (0, _vitest.it)("reports a failure once per UTC day per stage, reason, and target", async () => {
+      const app = await launch();
+      app.updateError(downloadFailure({
+        httpStatus: undefined
+      }));
+      app.updateError(downloadFailure());
+      await flush();
+      (await launch()).updateError(downloadFailure());
+      await flush();
+      (0, _vitest.expect)(fetchMock).toHaveBeenCalledOnce();
+      const [event] = sentEvents();
+      (0, _vitest.expect)(event).toMatchObject({
+        fromBundleId: "bundle-a",
+        fromReleaseId: "release-a",
+        metadata: {
+          failure: {
+            reason: "hash_mismatch",
+            stage: "download"
+          }
+        },
+        toBundleId: "bundle-b",
+        toReleaseId: "release-b",
+        type: "UPDATE_FAILED",
+        updateStrategy: "fingerprint"
+      });
+      (0, _vitest.expect)(Object.keys(event?.metadata?.failure ?? {}).sort()).toEqual(["reason", "stage"]);
+      // A UUIDv7 led by the UTC day, the same on every device for one failure.
+      (0, _vitest.expect)((0, _core.isUUIDv7)(event?.eventId)).toBe(true);
+      (0, _vitest.expect)(parseInt(event.eventId.replace(/-/g, "").slice(0, 12), 16)).toBe(Date.UTC(2026, 8, 30));
+      (await launch()).updateError(downloadFailure({
+        reason: "signature"
+      }));
+      _vitest.vi.setSystemTime(MORNING + DAY_MS);
+      (await launch()).updateError(downloadFailure());
+      await flush();
+      const ids = sentEvents().map(({
+        eventId
+      }) => eventId);
+      (0, _vitest.expect)(sentEvents().map(({
+        metadata
+      }) => metadata?.failure?.reason)).toEqual(["hash_mismatch", "signature", "hash_mismatch"]);
+      (0, _vitest.expect)(new Set(ids).size).toBe(3);
+    });
+    (0, _vitest.it)("gives a failure that was not delivered the same id when it happens again", async () => {
+      responses = [500, 500, 500];
+      _vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+      (await launch()).updateError(downloadFailure());
+      await flush();
+      (await launch()).updateError(downloadFailure());
+      await flush();
+      const ids = sentEvents().map(({
+        eventId
+      }) => eventId);
+      (0, _vitest.expect)(ids).toHaveLength(4);
+      (0, _vitest.expect)(new Set(ids).size).toBe(1);
+    });
+    (0, _vitest.it)("skips check failures while offline and reports the others against the running bundle", async () => {
+      const app = await launch();
+      const checkFailure = {
+        stage: "check",
+        channel: "production",
+        bundleId: "bundle-a",
+        releaseId: "release-a",
+        updateStrategy: "appVersion",
+        cause: new Error("check failed")
+      };
+      app.updateError({
+        ...checkFailure,
+        reason: "network"
+      });
+      app.updateError({
+        ...checkFailure,
+        reason: "http",
+        httpStatus: 503
+      });
+      await flush();
+      (0, _vitest.expect)(sentEvents()).toEqual([_vitest.expect.objectContaining({
+        fromBundleId: "bundle-a",
+        metadata: {
+          failure: {
+            httpStatus: 503,
+            reason: "http",
+            stage: "check"
+          }
+        },
+        toBundleId: "bundle-a",
+        toReleaseId: null,
+        type: "UPDATE_FAILED"
+      })]);
+    });
+    (0, _vitest.it)("drops a failure an older server refuses, without retrying, warning, or pausing", async () => {
+      responses = [400];
+      const warn = _vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+      const app = await launch();
+      app.updateError(downloadFailure());
+      await flush();
+      app.updateError(downloadFailure());
+      app.appReady(unchangedLaunch());
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UPDATE_FAILED", "UNCHANGED"]);
+      (0, _vitest.expect)(warn).not.toHaveBeenCalled();
+    });
+  });
+  (0, _vitest.describe)("event details", () => {
+    (0, _vitest.it)("says how a download arrived, and when a patch fell back", async () => {
+      const app = await launch();
+      app.downloaded({
+        ...download,
+        delivery: "patch",
+        patchFallback: false
+      });
+      app.downloaded({
+        ...download,
+        toBundleId: "bundle-c",
+        delivery: "archive",
+        patchFallback: true
+      });
+      await flush();
+      (0, _vitest.expect)(sentEvents().map(({
+        metadata
+      }) => metadata)).toEqual([{
+        delivery: "patch"
+      }, {
+        delivery: "archive",
+        patchFallback: true
+      }]);
+    });
+    (0, _vitest.it)("says why the previous process exited on a recovery only", async () => {
+      const app = await launch();
+      app.appReady({
+        ...appliedLaunch,
+        status: "RECOVERED",
+        fromBundleId: "bundle-b",
+        toBundleId: "bundle-a",
+        previousProcessExit: "CRASH"
+      });
+      await flush();
+      (await launch()).appReady({
+        ...appliedLaunch,
+        toBundleId: "bundle-c",
+        previousProcessExit: "USER_REQUESTED"
+      });
+      await flush();
+      (0, _vitest.expect)(sentEvents().map(({
+        type,
+        metadata
+      }) => [type, metadata])).toEqual([["RECOVERED", {
+        previousProcessExit: "CRASH"
+      }], ["UPDATE_APPLIED", undefined]]);
+    });
+    (0, _vitest.it)("sends every failure detail it has", async () => {
+      const app = await launch();
+      app.updateError(downloadFailure({
+        reason: "http",
+        resource: "archive",
+        httpStatus: 403,
+        originCode: "ExpiredToken",
+        previousProcessExit: "ANR"
+      }));
+      app.updateError(downloadFailure({
+        reason: "network",
+        resource: "file",
+        transport: "tls"
+      }));
+      await flush();
+      (0, _vitest.expect)(sentEvents().map(({
+        metadata
+      }) => metadata?.failure)).toEqual([{
+        stage: "download",
+        reason: "http",
+        resource: "archive",
+        httpStatus: 403,
+        originCode: "ExpiredToken",
+        previousProcessExit: "ANR"
+      }, {
+        stage: "download",
+        reason: "network",
+        resource: "file",
+        transport: "tls"
+      }]);
+    });
+  });
+  (0, _vitest.describe)("a success for a failed target", () => {
+    (0, _vitest.it)("drops a queued failure for the target a download then staged", async () => {
+      responses = [503];
+      const app = await launch();
+      app.appReady(unchangedLaunch());
+      app.updateError(downloadFailure());
+      app.downloaded(download);
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UNCHANGED", "UNCHANGED", "UPDATE_DOWNLOADED"]);
+    });
+    (0, _vitest.it)("drops a failure waiting out a backoff once its target applies", async () => {
+      responses = [503];
+      const app = await launch();
+      app.updateError(downloadFailure());
+      await Promise.resolve();
+      await _vitest.vi.advanceTimersByTimeAsync(0);
+      app.appReady(appliedLaunch);
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UPDATE_FAILED", "UPDATE_APPLIED"]);
+    });
+    (0, _vitest.it)("keeps a failure for another target", async () => {
+      const app = await launch();
+      app.updateError(downloadFailure({
+        targetBundleId: "bundle-c"
+      }));
+      app.downloaded(download);
+      await flush();
+      (0, _vitest.expect)(sentTypes()).toEqual(["UPDATE_FAILED", "UPDATE_DOWNLOADED"]);
+    });
+  });
+  (0, _vitest.describe)("user", () => {
+    (0, _vitest.it)("attaches a user set before init and keeps it across launches", async () => {
+      (await launch({}, plugin => plugin.setUser({
+        userId: 42
+      }))).appReady(unchangedLaunch());
+      await flush();
+      (await launch()).appReady(appliedLaunch);
+      await flush();
+      const app = await launch();
+      app.plugin.setUser(null);
+      app.appReady(unchangedLaunch({
+        bundleId: "bundle-c"
+      }));
+      await flush();
+      (0, _vitest.expect)(sentEvents().map(({
+        userId
+      }) => userId)).toEqual(["42", "42", undefined]);
+      (0, _vitest.expect)(sentEvents().every(event => !("username" in event))).toBe(true);
+    });
+    (0, _vitest.it)("takes only a user id", () => {
+      const user = {
+        userId: "user-1"
+      };
+      // @ts-expect-error Insights keeps no username.
+      const withName = {
+        userId: "user-1",
+        username: "Alex"
+      };
+      (0, _vitest.expect)([user, withName]).toHaveLength(2);
+    });
+  });
+  _vitest.it.each([{
+    debug: undefined,
+    sends: false
+  }, {
+    debug: true,
+    sends: true
+  }])("sends from a debug build only with debug: true ($debug)", async ({
+    debug,
+    sends
+  }) => {
+    _vitest.vi.stubGlobal("__DEV__", true);
+    const app = await launch(debug === undefined ? {} : {
+      debug
+    });
+    app.appReady(unchangedLaunch());
+    await flush();
+    (0, _vitest.expect)(fetchMock).toHaveBeenCalledTimes(sends ? 1 : 0);
+  });
+  (0, _vitest.it)("reports a failed install id read as a plugin error, not an update failure", async () => {
+    native.getInstallId.mockImplementationOnce(() => {
+      throw new Error("native install id unavailable");
+    });
+    const warn = _vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+    const app = await launch();
+    app.appReady(unchangedLaunch());
+    await flush();
+    (0, _vitest.expect)(fetchMock).not.toHaveBeenCalled();
+    (0, _vitest.expect)(warn).toHaveBeenCalledWith('[HotUpdater] Plugin "insights" failed in onAppReady', _vitest.expect.objectContaining({
+      message: "native install id unavailable"
+    }));
+  });
+  (0, _vitest.it)("skips a report without a native app version", async () => {
+    native.getAppVersion.mockReturnValue(null);
+    const warn = _vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+    const app = await launch();
+    app.appReady(unchangedLaunch());
+    await flush();
+    (0, _vitest.expect)(fetchMock).not.toHaveBeenCalled();
+    (0, _vitest.expect)(warn).toHaveBeenCalledWith("[HotUpdater] Insights needs the native app version; the UNCHANGED event was not sent.");
+  });
+});
+//# sourceMappingURL=insights.spec.js.map