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

package/src/native.spec.ts

@@ -6,10 +6,14 @@ const nativeModuleMock = vi.hoisted(() => {
   const getCrashHistory = vi.fn<() => string[] | string>(() => []);
 
   return {
+    getActiveUpdateState: vi.fn<() => unknown>(),
     clearCrashHistory: vi.fn(() => true),
     getBaseURL: vi.fn<() => string | null>(() => null),
     getBundleId: vi.fn<() => string | null>(() => "bundle-id"),
     getCohort: vi.fn<() => string>(() => "123"),
+    getInstallId: vi.fn<() => string>(() => "install-id"),
+    getUserId: vi.fn<() => string | null>(() => null),
+    getUsername: vi.fn<() => string | null>(() => null),
     getManifest,
     getCrashHistory,
     getConstants: vi.fn(() => ({
@@ -23,6 +27,7 @@ const nativeModuleMock = vi.hoisted(() => {
     reload: vi.fn(),
     resetChannel: vi.fn(),
     setCohort: vi.fn(),
+    setUser: vi.fn(),
     setBundleURL: vi.fn(),
     switchChannel: vi.fn(),
     updateBundle: vi.fn(),
@@ -63,6 +68,8 @@ describe("notifyAppReady", () => {
     nativeModuleMock.getCrashHistory.mockReturnValue([]);
     nativeModuleMock.getCohort.mockReset();
     nativeModuleMock.getCohort.mockReturnValue("123");
+    nativeModuleMock.getInstallId.mockReset();
+    nativeModuleMock.getInstallId.mockReturnValue("install-id");
     nativeModuleMock.getManifest.mockReset();
     nativeModuleMock.getManifest.mockReturnValue({
       assets: {
@@ -74,40 +81,154 @@ describe("notifyAppReady", () => {
     });
     nativeModuleMock.resetChannel.mockReset();
     nativeModuleMock.setCohort.mockReset();
+    nativeModuleMock.setUser.mockReset();
     nativeModuleMock.updateBundle.mockReset();
   });
 
-  it("normalizes legacy PROMOTED launch reports to STABLE", async () => {
+  it("exposes active Release state without internal Catalog identity or history", async () => {
+    const receipt = {
+      bundleId: "bundle-123",
+      releaseId: "release-123",
+      kind: "BUNDLE",
+      channel: "production",
+      catalogId: "private-catalog",
+      scopeKey: "private-scope",
+      generation: 10,
+      catalogHash: "private-hash",
+      selectionContextHash: "private-context",
+    };
+    nativeModuleMock.getActiveUpdateState.mockReturnValue({
+      activeSelection: receipt,
+      stableSelection: receipt,
+      verificationPending: true,
+      highestSeenCatalogs: {
+        "private-catalog|private-scope": {
+          generation: 10,
+          catalogHash: "private-hash",
+        },
+      },
+    });
+    const { getPublicActiveUpdateState } = await import("./native");
+    const selection = {
+      bundleId: "bundle-123",
+      releaseId: "release-123",
+      kind: "BUNDLE",
+      channel: "production",
+    };
+    expect(getPublicActiveUpdateState()).toEqual({
+      activeSelection: selection,
+      stableSelection: selection,
+      verificationPending: true,
+    });
+  });
+
+  it("normalizes legacy PROMOTED launch reports to UPDATE_APPLIED", async () => {
     nativeModuleMock.notifyAppReady.mockReturnValue(
-      JSON.stringify({ status: "PROMOTED" }),
+      JSON.stringify({
+        fromBundleId: "bundle-123",
+        status: "PROMOTED",
+        toBundleId: "bundle-456",
+      }),
     );
 
     const { notifyAppReady } = await import("./native");
 
-    expect(notifyAppReady()).toEqual({ status: "STABLE" });
+    expect(notifyAppReady()).toEqual({
+      fromBundleId: "bundle-123",
+      status: "UPDATE_APPLIED",
+      toBundleId: "bundle-456",
+    });
     expect(nativeModuleMock.notifyAppReady).toHaveBeenCalledWith();
   });
 
-  it("returns RECOVERED launch reports unchanged", async () => {
+  it("returns RECOVERED launch reports with directional ids", async () => {
     nativeModuleMock.notifyAppReady.mockReturnValue({
-      crashedBundleId: "bundle-123",
+      fromBundleId: "bundle-123",
       status: "RECOVERED",
+      toBundleId: "bundle-122",
+      updateStrategy: "appVersion",
     });
 
-    const { notifyAppReady } = await import("./native");
+    const { notifyAppReady, readNotifyAppReady } = await import("./native");
 
     expect(notifyAppReady()).toEqual({
-      crashedBundleId: "bundle-123",
+      fromBundleId: "bundle-123",
+      status: "RECOVERED",
+      toBundleId: "bundle-122",
+    });
+    expect(readNotifyAppReady()).toEqual({
+      analyticsEvent: {
+        fromBundleId: "bundle-123",
+        toBundleId: "bundle-122",
+        type: "RECOVERED",
+        updateStrategy: "appVersion",
+      },
+      pending: false,
+      result: {
+        fromBundleId: "bundle-123",
+        status: "RECOVERED",
+        toBundleId: "bundle-122",
+      },
+    });
+  });
+
+  it("returns UNCHANGED for incomplete recovery payloads", async () => {
+    nativeModuleMock.notifyAppReady.mockReturnValue({
+      fromBundleId: "bundle-123",
       status: "RECOVERED",
+      toBundleId: null,
+      updateStrategy: "appVersion",
+    });
+
+    const { notifyAppReady, readNotifyAppReady } = await import("./native");
+
+    expect(notifyAppReady()).toEqual({ status: "UNCHANGED" });
+    expect(readNotifyAppReady()).toEqual({
+      analyticsEvent: null,
+      pending: false,
+      result: { status: "UNCHANGED" },
     });
   });
 
-  it("falls back to STABLE for malformed old-arch payloads", async () => {
+  it("returns UNCHANGED when automatic analytics metadata is incomplete", async () => {
+    nativeModuleMock.notifyAppReady.mockReturnValue({
+      status: "UPDATE_APPLIED",
+    });
+
+    const { notifyAppReady, readNotifyAppReady } = await import("./native");
+
+    expect(notifyAppReady()).toEqual({ status: "UNCHANGED" });
+    expect(readNotifyAppReady()).toEqual({
+      analyticsEvent: null,
+      pending: false,
+      result: { status: "UNCHANGED" },
+    });
+  });
+
+  it("normalizes malformed old-arch notifyAppReady payloads to UNCHANGED", async () => {
     nativeModuleMock.notifyAppReady.mockReturnValue("{");
 
-    const { notifyAppReady } = await import("./native");
+    const { notifyAppReady, readNotifyAppReady } = await import("./native");
+
+    expect(notifyAppReady()).toEqual({ status: "UNCHANGED" });
+    expect(readNotifyAppReady()).toEqual({
+      analyticsEvent: null,
+      pending: false,
+      result: { status: "UNCHANGED" },
+    });
+  });
 
-    expect(notifyAppReady()).toEqual({ status: "STABLE" });
+  it("keeps the internal pending state out of the public result", async () => {
+    nativeModuleMock.notifyAppReady.mockReturnValue({ status: "PENDING" });
+
+    const { notifyAppReady, readNotifyAppReady } = await import("./native");
+
+    expect(notifyAppReady()).toEqual({ status: "UNCHANGED" });
+    expect(readNotifyAppReady()).toEqual({
+      analyticsEvent: null,
+      pending: true,
+      result: { status: "UNCHANGED" },
+    });
   });
 
   it("returns the native bundle id when available", async () => {
@@ -599,6 +720,101 @@ describe("notifyAppReady", () => {
     expect(nativeModuleMock.setCohort).not.toHaveBeenCalled();
   });
 
+  it("returns the install id reported by native", async () => {
+    nativeModuleMock.getInstallId.mockReturnValue("install-123");
+
+    const { getInstallId } = await import("./native");
+
+    expect(getInstallId()).toBe("install-123");
+  });
+
+  it("throws when native SDK does not expose getInstallId", async () => {
+    const nativeModule = nativeModuleMock as typeof nativeModuleMock & {
+      getInstallId?: typeof nativeModuleMock.getInstallId;
+    };
+    const originalGetInstallId = nativeModule.getInstallId;
+    nativeModule.getInstallId = null as unknown as Mock<() => string>;
+
+    try {
+      const { getInstallId } = await import("./native");
+
+      expect(() => getInstallId()).toThrow(
+        "Native module is missing 'getInstallId()'",
+      );
+    } finally {
+      nativeModule.getInstallId = originalGetInstallId;
+    }
+  });
+
+  it("passes nullable user identity through to native", async () => {
+    const { setUser } = await import("./native");
+
+    setUser({ userId: "user-123", username: "alice" });
+    setUser({ userId: 42, username: "bob" });
+    setUser({});
+    setUser(null);
+
+    expect(nativeModuleMock.setUser).toHaveBeenNthCalledWith(
+      1,
+      "user-123",
+      "alice",
+    );
+    expect(nativeModuleMock.setUser).toHaveBeenNthCalledWith(2, "42", "bob");
+    expect(nativeModuleMock.setUser).toHaveBeenNthCalledWith(3, null, null);
+    expect(nativeModuleMock.setUser).toHaveBeenNthCalledWith(4, null, null);
+  });
+
+  it("reads persisted user identity from native when available", async () => {
+    nativeModuleMock.getUserId.mockReturnValue("user-123");
+    nativeModuleMock.getUsername.mockReturnValue("alice");
+
+    const { getPersistedUserIdentity } = await import("./native");
+
+    expect(getPersistedUserIdentity()).toEqual({
+      userId: "user-123",
+      username: "alice",
+    });
+  });
+
+  it("throws when native SDK does not expose persisted user identity getters", async () => {
+    const nativeModule = nativeModuleMock as typeof nativeModuleMock & {
+      getUserId?: typeof nativeModuleMock.getUserId;
+      getUsername?: typeof nativeModuleMock.getUsername;
+    };
+    const originalGetUserId = nativeModule.getUserId;
+    nativeModule.getUserId = null as unknown as Mock<() => string | null>;
+
+    try {
+      const { getPersistedUserIdentity } = await import("./native");
+
+      expect(() => getPersistedUserIdentity()).toThrow(
+        "Native module is missing 'getUserId()' or 'getUsername()'",
+      );
+    } finally {
+      nativeModule.getUserId = originalGetUserId;
+    }
+  });
+
+  it("throws when native SDK does not expose setUser", async () => {
+    const nativeModule = nativeModuleMock as typeof nativeModuleMock & {
+      setUser?: typeof nativeModuleMock.setUser;
+    };
+    const originalSetUser = nativeModule.setUser;
+    nativeModule.setUser = null as unknown as Mock<
+      (userId: string | null, username: string | null) => void
+    >;
+
+    try {
+      const { setUser } = await import("./native");
+
+      expect(() => setUser({ userId: "user-123" })).toThrow(
+        "Native module is missing 'setUser()'",
+      );
+    } finally {
+      nativeModule.setUser = originalSetUser;
+    }
+  });
+
   it("returns the cohort reported by native", async () => {
     nativeModuleMock.getCohort.mockReturnValue("qa-group");