@hot-updater/react-native 0.36.7 → 1.0.0-rc.1

package/src/notifyAppReadyAnalytics.boundary.spec.ts

@@ -0,0 +1,234 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type {
+  NotifyAppReadyAnalyticsEvent,
+  NotifyAppReadyResult,
+} from "./native";
+import {
+  createNotifyReadResult,
+  stubNotifyFrame,
+} from "./notifyAppReadyAnalytics.test-utils";
+
+const platformState = vi.hoisted((): { OS: "ios" | "android" } => ({
+  OS: "ios",
+}));
+
+vi.mock("react-native", () => ({
+  NativeEventEmitter: class {},
+  Platform: platformState,
+}));
+
+const nativePersistence = vi.hoisted(() => {
+  let persistedInstallId = "install-persisted";
+
+  return {
+    getConstants: vi.fn(() => ({
+      APP_VERSION: "1.0.0",
+      CHANNEL: "production",
+      DEFAULT_CHANNEL: "production",
+      FINGERPRINT_HASH: null,
+      MIN_BUNDLE_ID: "min-bundle-id",
+    })),
+    getInstallId: vi.fn(() => persistedInstallId),
+    setPersistedInstallId: (installId: string) => {
+      persistedInstallId = installId;
+    },
+  };
+});
+
+const mocks = vi.hoisted(() => ({
+  addListener: vi.fn(() => () => {}),
+  checkForUpdate: vi.fn(),
+  getAppVersion: vi.fn<() => string | undefined>(() => "1.0.0"),
+  getBundleId: vi.fn<() => string | undefined>(() => "bundle-id"),
+  getChannel: vi.fn(() => "production"),
+  getCohort: vi.fn(() => "123"),
+  getFingerprintHash: vi.fn(() => "fingerprint-hash"),
+  getInstallId: vi.fn<() => string | undefined>(() => "install-id"),
+  getPersistedUserIdentity: vi.fn(() => ({})),
+  readNotifyAppReady: vi.fn<
+    () => {
+      analyticsEvent: NotifyAppReadyAnalyticsEvent | null;
+      pending: boolean;
+      result: NotifyAppReadyResult;
+    }
+  >(() => createNotifyReadResult()),
+  reload: vi.fn(),
+}));
+
+vi.mock("./checkForUpdate", () => ({
+  checkForUpdate: mocks.checkForUpdate,
+}));
+
+vi.mock("./native", () => ({
+  addListener: mocks.addListener,
+  getAppVersion: mocks.getAppVersion,
+  getBundleId: mocks.getBundleId,
+  getChannel: mocks.getChannel,
+  getCohort: mocks.getCohort,
+  getFingerprintHash: mocks.getFingerprintHash,
+  getInstallId: mocks.getInstallId,
+  getPersistedUserIdentity: mocks.getPersistedUserIdentity,
+  readNotifyAppReady: mocks.readNotifyAppReady,
+  reload: mocks.reload,
+}));
+
+vi.mock("./specs/NativeHotUpdater", () => ({
+  default: nativePersistence,
+}));
+
+const createClient = () => {
+  const sendAnalyticsEvent = vi.fn().mockResolvedValue(undefined);
+  return {
+    client: {
+      createSession: vi.fn(async () => ({
+        fetchReleaseCatalog: vi.fn(),
+        resolveArtifact: vi.fn(),
+        sendAnalyticsEvent,
+      })),
+    },
+    sendAnalyticsEvent,
+  };
+};
+
+describe("automatic notifyAppReady analytics boundaries", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+    platformState.OS = "ios";
+
+    for (const mock of Object.values(mocks)) {
+      mock.mockReset();
+    }
+
+    mocks.addListener.mockReturnValue(() => {});
+    mocks.getAppVersion.mockReturnValue("1.0.0");
+    mocks.getBundleId.mockReturnValue("bundle-id");
+    mocks.getChannel.mockReturnValue("production");
+    mocks.getCohort.mockReturnValue("123");
+    mocks.getFingerprintHash.mockReturnValue("fingerprint-hash");
+    mocks.getInstallId.mockReturnValue("install-id");
+    mocks.getPersistedUserIdentity.mockReturnValue({});
+    mocks.readNotifyAppReady.mockReturnValue(createNotifyReadResult());
+    nativePersistence.getConstants.mockClear();
+    nativePersistence.getInstallId.mockClear();
+    nativePersistence.setPersistedInstallId("install-persisted");
+  });
+
+  it("warns when the private HTTP session fails and preserves readiness", async () => {
+    stubNotifyFrame();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const onError = vi.fn();
+    const onNotifyAppReady = vi.fn();
+    const { init } = await import("./wrap");
+
+    init({
+      analytics: true,
+      client: {
+        createSession: vi.fn(async () => {
+          throw new Error("baseURL unavailable");
+        }),
+      },
+      onError,
+      onNotifyAppReady,
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(onError).not.toHaveBeenCalled();
+    expect(onNotifyAppReady).toHaveBeenCalledWith({ status: "UNCHANGED" });
+    expect(warn).toHaveBeenCalledWith(
+      "[HotUpdater] Automatic notifyAppReady analytics failed:",
+      expect.objectContaining({
+        message: "baseURL unavailable",
+      }),
+    );
+    warn.mockRestore();
+  });
+
+  it.each([
+    { label: "throws", value: new Error("native install id unavailable") },
+    { label: "returns no identity", value: undefined },
+  ])(
+    "warns for a missing native install identity when it $label",
+    async ({ value }) => {
+      stubNotifyFrame();
+      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const onError = vi.fn();
+      const onNotifyAppReady = vi.fn();
+      if (value instanceof Error) {
+        mocks.getInstallId.mockImplementation(() => {
+          throw value;
+        });
+      } else {
+        mocks.getInstallId.mockReturnValue(value);
+      }
+      const { client, sendAnalyticsEvent } = createClient();
+      const { init } = await import("./wrap");
+
+      init({ analytics: true, client, onError, onNotifyAppReady });
+      await vi.runOnlyPendingTimersAsync();
+
+      expect(sendAnalyticsEvent).not.toHaveBeenCalled();
+      expect(onError).not.toHaveBeenCalled();
+      expect(onNotifyAppReady).toHaveBeenCalledWith({ status: "UNCHANGED" });
+      expect(warn).toHaveBeenCalledWith(
+        "[HotUpdater] Automatic notifyAppReady analytics failed:",
+        expect.any(Error),
+      );
+      warn.mockRestore();
+    },
+  );
+
+  it.each([
+    { label: "throws", value: new Error("native bundle id unavailable") },
+    { label: "returns no bundle", value: undefined },
+  ])(
+    "warns for a missing current bundle when getBundleId $label",
+    async ({ value }) => {
+      stubNotifyFrame();
+      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const onError = vi.fn();
+      const onNotifyAppReady = vi.fn();
+      if (value instanceof Error) {
+        mocks.getBundleId.mockImplementation(() => {
+          throw value;
+        });
+      } else {
+        mocks.getBundleId.mockReturnValue(value);
+      }
+      const { client, sendAnalyticsEvent } = createClient();
+      const { init } = await import("./wrap");
+
+      init({ analytics: true, client, onError, onNotifyAppReady });
+      await vi.runOnlyPendingTimersAsync();
+
+      expect(sendAnalyticsEvent).not.toHaveBeenCalled();
+      expect(onError).not.toHaveBeenCalled();
+      expect(onNotifyAppReady).toHaveBeenCalledWith({ status: "UNCHANGED" });
+      expect(warn).toHaveBeenCalledWith(
+        "[HotUpdater] Automatic notifyAppReady analytics failed:",
+        expect.any(Error),
+      );
+      warn.mockRestore();
+    },
+  );
+
+  it.each(["ios", "android"] as const)(
+    "reads persisted install id through native.ts across JS module resets on %s",
+    async (platform) => {
+      platformState.OS = platform;
+      nativePersistence.setPersistedInstallId("install-persisted");
+      const native =
+        await vi.importActual<typeof import("./native")>("./native");
+
+      expect(native.getInstallId()).toBe("install-persisted");
+      vi.resetModules();
+      const nativeAfterReset =
+        await vi.importActual<typeof import("./native")>("./native");
+
+      expect(nativeAfterReset.getInstallId()).toBe("install-persisted");
+      expect(nativePersistence.getInstallId).toHaveBeenCalledTimes(2);
+    },
+  );
+});

package/src/notifyAppReadyAnalytics.spec.ts

@@ -0,0 +1,243 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type {
+  NotifyAppReadyAnalyticsEvent,
+  NotifyAppReadyResult,
+} from "./native";
+import {
+  createNotifyReadResult,
+  stubNotifyFrame,
+} from "./notifyAppReadyAnalytics.test-utils";
+
+vi.mock("react-native", () => ({
+  Platform: { OS: "ios" },
+}));
+
+const mocks = vi.hoisted(() => ({
+  addListener: vi.fn(() => () => {}),
+  checkForUpdate: vi.fn(),
+  getAppVersion: vi.fn(() => "1.0.0"),
+  getBundleId: vi.fn(() => "bundle-id"),
+  getChannel: vi.fn(() => "production"),
+  getCohort: vi.fn(() => "123"),
+  getFingerprintHash: vi.fn(() => "fingerprint-hash"),
+  getInstallId: vi.fn(() => "install-id"),
+  getPersistedUserIdentity: vi.fn(() => ({})),
+  readNotifyAppReady: vi.fn<
+    () => {
+      analyticsEvent: NotifyAppReadyAnalyticsEvent | null;
+      pending: boolean;
+      result: NotifyAppReadyResult;
+    }
+  >(() => createNotifyReadResult()),
+  reload: vi.fn(),
+}));
+
+vi.mock("./checkForUpdate", () => ({
+  checkForUpdate: mocks.checkForUpdate,
+}));
+
+vi.mock("./native", () => ({
+  addListener: mocks.addListener,
+  getAppVersion: mocks.getAppVersion,
+  getBundleId: mocks.getBundleId,
+  getChannel: mocks.getChannel,
+  getCohort: mocks.getCohort,
+  getFingerprintHash: mocks.getFingerprintHash,
+  getInstallId: mocks.getInstallId,
+  getPersistedUserIdentity: mocks.getPersistedUserIdentity,
+  readNotifyAppReady: mocks.readNotifyAppReady,
+  reload: mocks.reload,
+}));
+
+const createClient = () => {
+  const sendAnalyticsEvent = vi.fn().mockResolvedValue(undefined);
+  return {
+    client: {
+      createSession: vi.fn(async () => ({
+        fetchReleaseCatalog: vi.fn(),
+        resolveArtifact: vi.fn(),
+        sendAnalyticsEvent,
+      })),
+    },
+    sendAnalyticsEvent,
+  };
+};
+
+describe("automatic notifyAppReady analytics", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+
+    for (const mock of Object.values(mocks)) {
+      mock.mockReset();
+    }
+
+    mocks.getAppVersion.mockReturnValue("1.0.0");
+    mocks.addListener.mockReturnValue(() => {});
+    mocks.getBundleId.mockReturnValue("bundle-id");
+    mocks.getChannel.mockReturnValue("production");
+    mocks.getCohort.mockReturnValue("123");
+    mocks.getFingerprintHash.mockReturnValue("fingerprint-hash");
+    mocks.getInstallId.mockReturnValue("install-id");
+    mocks.getPersistedUserIdentity.mockReturnValue({});
+    mocks.readNotifyAppReady.mockReturnValue(createNotifyReadResult());
+  });
+
+  it("sends UPDATE_APPLIED with transition metadata and invokes readiness", async () => {
+    stubNotifyFrame();
+    mocks.getPersistedUserIdentity.mockReturnValue({
+      userId: "user-123",
+      username: "alice",
+    });
+    mocks.readNotifyAppReady.mockReturnValue(
+      createNotifyReadResult(
+        {
+          fromBundleId: "bundle-a",
+          status: "UPDATE_APPLIED",
+          toBundleId: "bundle-b",
+        },
+        {
+          fromBundleId: "bundle-a",
+          toBundleId: "bundle-b",
+          type: "UPDATE_APPLIED",
+          updateStrategy: "fingerprint",
+        },
+      ),
+    );
+
+    const { client, sendAnalyticsEvent } = createClient();
+    const onNotifyAppReady = vi.fn();
+    const { init } = await import("./wrap");
+
+    init({
+      analytics: true,
+      onNotifyAppReady,
+      requestHeaders: { Authorization: "Bearer token" },
+      requestTimeout: 1000,
+      client,
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(sendAnalyticsEvent).toHaveBeenCalledWith({
+      appVersion: "1.0.0",
+      channel: "production",
+      cohort: "123",
+      fingerprintHash: "fingerprint-hash",
+      fromBundleId: "bundle-a",
+      fromReleaseId: null,
+      installId: "install-id",
+      platform: "ios",
+      requestHeaders: { Authorization: "Bearer token" },
+      requestTimeout: 1000,
+      toBundleId: "bundle-b",
+      toReleaseId: null,
+      type: "UPDATE_APPLIED",
+      updateStrategy: "fingerprint",
+      userId: "user-123",
+      username: "alice",
+    });
+    expect(onNotifyAppReady).toHaveBeenCalledWith({
+      fromBundleId: "bundle-a",
+      status: "UPDATE_APPLIED",
+      toBundleId: "bundle-b",
+    });
+  });
+
+  it("sends RECOVERED with directional ids and invokes readiness", async () => {
+    stubNotifyFrame();
+    mocks.readNotifyAppReady.mockReturnValue(
+      createNotifyReadResult(
+        {
+          fromBundleId: "bundle-b",
+          status: "RECOVERED",
+          toBundleId: "bundle-a",
+        },
+        {
+          fromBundleId: "bundle-b",
+          toBundleId: "bundle-a",
+          type: "RECOVERED",
+          updateStrategy: "appVersion",
+        },
+      ),
+    );
+    const { client, sendAnalyticsEvent } = createClient();
+    const onNotifyAppReady = vi.fn();
+    const { init } = await import("./wrap");
+
+    init({ analytics: true, client, onNotifyAppReady });
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(sendAnalyticsEvent).toHaveBeenCalledWith({
+      appVersion: "1.0.0",
+      channel: "production",
+      cohort: "123",
+      fingerprintHash: "fingerprint-hash",
+      fromBundleId: "bundle-b",
+      fromReleaseId: null,
+      installId: "install-id",
+      platform: "ios",
+      requestHeaders: undefined,
+      requestTimeout: undefined,
+      toBundleId: "bundle-a",
+      toReleaseId: null,
+      type: "RECOVERED",
+      updateStrategy: "appVersion",
+    });
+    expect(onNotifyAppReady).toHaveBeenCalledWith({
+      fromBundleId: "bundle-b",
+      status: "RECOVERED",
+      toBundleId: "bundle-a",
+    });
+  });
+
+  it("sends one UNCHANGED event for repeated init calls", async () => {
+    stubNotifyFrame();
+    const { client, sendAnalyticsEvent } = createClient();
+    const onNotifyAppReady = vi.fn();
+    const { init } = await import("./wrap");
+
+    init({ analytics: true, client, onNotifyAppReady });
+    init({ analytics: true, client, onNotifyAppReady });
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(sendAnalyticsEvent).toHaveBeenCalledTimes(1);
+    expect(sendAnalyticsEvent).toHaveBeenCalledWith({
+      appVersion: "1.0.0",
+      channel: "production",
+      cohort: "123",
+      fingerprintHash: "fingerprint-hash",
+      fromBundleId: null,
+      fromReleaseId: null,
+      installId: "install-id",
+      platform: "ios",
+      requestHeaders: undefined,
+      requestTimeout: undefined,
+      toBundleId: "bundle-id",
+      toReleaseId: null,
+      type: "UNCHANGED",
+      updateStrategy: null,
+    });
+    expect(onNotifyAppReady).toHaveBeenCalledTimes(2);
+    expect(onNotifyAppReady).toHaveBeenNthCalledWith(1, {
+      status: "UNCHANGED",
+    });
+    expect(onNotifyAppReady).toHaveBeenNthCalledWith(2, {
+      status: "UNCHANGED",
+    });
+  });
+
+  it("skips automatic analytics when disabled while preserving readiness", async () => {
+    stubNotifyFrame();
+    const { client, sendAnalyticsEvent } = createClient();
+    const onNotifyAppReady = vi.fn();
+    const { init } = await import("./wrap");
+
+    init({ analytics: false, client, onNotifyAppReady });
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(sendAnalyticsEvent).not.toHaveBeenCalled();
+    expect(onNotifyAppReady).toHaveBeenCalledWith({ status: "UNCHANGED" });
+  });
+});

package/src/notifyAppReadyAnalytics.test-utils.ts

@@ -0,0 +1,31 @@
+import { vi } from "vitest";
+
+import type {
+  NotifyAppReadyAnalyticsEvent,
+  NotifyAppReadyResult,
+} from "./native";
+
+export const createNotifyReadResult = (
+  result: NotifyAppReadyResult = { status: "UNCHANGED" },
+  analyticsEvent: NotifyAppReadyAnalyticsEvent | null = null,
+  pending = false,
+): {
+  analyticsEvent: NotifyAppReadyAnalyticsEvent | null;
+  pending: boolean;
+  result: NotifyAppReadyResult;
+} => ({
+  analyticsEvent,
+  pending,
+  result,
+});
+
+export const stubNotifyFrame = () => {
+  vi.useFakeTimers();
+  vi.stubGlobal(
+    "requestAnimationFrame",
+    vi.fn((callback: (timestamp: number) => void) => {
+      setTimeout(() => callback(0), 0);
+      return 1;
+    }),
+  );
+};

package/src/notifyAppReadyAnalytics.transport.spec.ts

@@ -0,0 +1,130 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type {
+  NotifyAppReadyAnalyticsEvent,
+  NotifyAppReadyResult,
+} from "./native";
+import {
+  createNotifyReadResult,
+  stubNotifyFrame,
+} from "./notifyAppReadyAnalytics.test-utils";
+
+vi.mock("react-native", () => ({
+  Platform: { OS: "ios" },
+}));
+
+const failureCases = [
+  { label: "400", responseStatus: 400 },
+  { label: "404", responseStatus: 404 },
+  { label: "500", responseStatus: 500 },
+  {
+    error: Object.assign(new Error("request aborted"), { name: "AbortError" }),
+    label: "timeout",
+  },
+  { error: new Error("network unavailable"), label: "network" },
+] as const;
+
+const mocks = vi.hoisted(() => ({
+  addListener: vi.fn(() => () => {}),
+  checkForUpdate: vi.fn(),
+  getAppVersion: vi.fn(() => "1.0.0"),
+  getBundleId: vi.fn(() => "bundle-id"),
+  getChannel: vi.fn(() => "production"),
+  getCohort: vi.fn(() => "123"),
+  getFingerprintHash: vi.fn(() => "fingerprint-hash"),
+  getInstallId: vi.fn(() => "install-id"),
+  getPersistedUserIdentity: vi.fn(() => ({})),
+  readNotifyAppReady: vi.fn<
+    () => {
+      analyticsEvent: NotifyAppReadyAnalyticsEvent | null;
+      pending: boolean;
+      result: NotifyAppReadyResult;
+    }
+  >(() => createNotifyReadResult()),
+  reload: vi.fn(),
+}));
+
+vi.mock("./checkForUpdate", () => ({
+  checkForUpdate: mocks.checkForUpdate,
+}));
+
+vi.mock("./native", () => ({
+  addListener: mocks.addListener,
+  getAppVersion: mocks.getAppVersion,
+  getBundleId: mocks.getBundleId,
+  getChannel: mocks.getChannel,
+  getCohort: mocks.getCohort,
+  getFingerprintHash: mocks.getFingerprintHash,
+  getInstallId: mocks.getInstallId,
+  getPersistedUserIdentity: mocks.getPersistedUserIdentity,
+  readNotifyAppReady: mocks.readNotifyAppReady,
+  reload: mocks.reload,
+}));
+
+describe("automatic notifyAppReady transport failures", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+
+    for (const mock of Object.values(mocks)) {
+      mock.mockReset();
+    }
+
+    mocks.addListener.mockReturnValue(() => {});
+    mocks.getAppVersion.mockReturnValue("1.0.0");
+    mocks.getBundleId.mockReturnValue("bundle-id");
+    mocks.getChannel.mockReturnValue("production");
+    mocks.getCohort.mockReturnValue("123");
+    mocks.getFingerprintHash.mockReturnValue("fingerprint-hash");
+    mocks.getInstallId.mockReturnValue("install-id");
+    mocks.getPersistedUserIdentity.mockReturnValue({});
+    mocks.readNotifyAppReady.mockReturnValue(createNotifyReadResult());
+  });
+
+  it.each(failureCases)(
+    "warns and preserves UNCHANGED readiness for a real HTTP client $label failure",
+    async (failureCase) => {
+      stubNotifyFrame();
+      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const onError = vi.fn();
+      const onNotifyAppReady = vi.fn();
+      const fetchMock = vi.fn(async () => {
+        if ("error" in failureCase) {
+          throw failureCase.error;
+        }
+
+        return new Response(null, { status: failureCase.responseStatus });
+      });
+      vi.stubGlobal("fetch", fetchMock);
+      Reflect.set(globalThis, "HotUpdater", {
+        SDK_VERSION: "test-sdk-version",
+      });
+
+      try {
+        const [{ createHttpClient }, { init }] = await Promise.all([
+          import("./httpClient"),
+          import("./wrap"),
+        ]);
+        const client = createHttpClient(
+          "https://updates.example.test/hot-updater",
+        );
+
+        init({ analytics: true, client, onError, onNotifyAppReady });
+        await vi.runOnlyPendingTimersAsync();
+
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(onError).not.toHaveBeenCalled();
+        expect(onNotifyAppReady).toHaveBeenCalledWith({
+          status: "UNCHANGED",
+        });
+        expect(warn).toHaveBeenCalledWith(
+          "[HotUpdater] Automatic notifyAppReady analytics failed:",
+          expect.any(Error),
+        );
+      } finally {
+        warn.mockRestore();
+      }
+    },
+  );
+});