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

package/src/index.spec.ts

@@ -1,6 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import type { HotUpdater as HotUpdaterValue } from "./index";
 import type { HotUpdaterInitOptions, HotUpdaterOptions } from "./wrap";
 
 const mocks = vi.hoisted(() => {
@@ -12,9 +11,15 @@ const mocks = vi.hoisted(() => {
 
   return {
     addListener: vi.fn(() => () => {}),
-    checkForUpdate: vi.fn(),
+    checkForUpdate: vi.fn(async () => null),
     clearCrashHistory: vi.fn(() => true),
-    createDefaultResolver: vi.fn(),
+    createHttpClient: vi.fn((baseURL: unknown) => ({ baseURL })),
+    getActiveUpdateState: vi.fn(() => ({
+      activeSelection: null,
+      highestSeenCatalogs: {},
+      stableSelection: null,
+      verificationPending: false,
+    })),
     getAppVersion: vi.fn(() => "1.0.0"),
     getBaseURL: vi.fn(() => null),
     getBundleId: vi.fn(() => "bundle-id"),
@@ -23,21 +28,25 @@ const mocks = vi.hoisted(() => {
     getCrashHistory: vi.fn(() => []),
     getDefaultChannel: vi.fn(() => "production"),
     getFingerprintHash: vi.fn(() => null),
+    getInstallId: vi.fn(() => "install-id"),
     getManifest: vi.fn(() => null),
-    getMinBundleId: vi.fn(() => "min-bundle-id"),
+    getMinimumReleaseId: vi.fn(() => "min-bundle-id"),
+    getReleaseId: vi.fn(async () => null),
     init: vi.fn(),
     isChannelSwitched: vi.fn(() => false),
+    notifyAppReady: vi.fn(() => ({ status: "UNCHANGED" as const })),
     reload: vi.fn(),
     resetChannel: vi.fn(),
     setCohort: vi.fn(),
     setReloadBehavior: vi.fn(),
+    setUser: vi.fn(),
     updateBundle: vi.fn(),
-    wrap: vi.fn(),
+    wrap: vi.fn((Component: unknown) => Component),
   };
 });
 
-vi.mock("./DefaultResolver", () => ({
-  createDefaultResolver: mocks.createDefaultResolver,
+vi.mock("./httpClient", () => ({
+  createHttpClient: mocks.createHttpClient,
 }));
 
 vi.mock("./checkForUpdate", () => ({
@@ -47,6 +56,7 @@ vi.mock("./checkForUpdate", () => ({
 vi.mock("./native", () => ({
   addListener: mocks.addListener,
   clearCrashHistory: mocks.clearCrashHistory,
+  getPublicActiveUpdateState: mocks.getActiveUpdateState,
   getAppVersion: mocks.getAppVersion,
   getBaseURL: mocks.getBaseURL,
   getBundleId: mocks.getBundleId,
@@ -55,13 +65,17 @@ vi.mock("./native", () => ({
   getCrashHistory: mocks.getCrashHistory,
   getDefaultChannel: mocks.getDefaultChannel,
   getFingerprintHash: mocks.getFingerprintHash,
+  getInstallId: mocks.getInstallId,
   getManifest: mocks.getManifest,
-  getMinBundleId: mocks.getMinBundleId,
+  getMinimumReleaseId: mocks.getMinimumReleaseId,
+  getReleaseId: mocks.getReleaseId,
   isChannelSwitched: mocks.isChannelSwitched,
+  notifyAppReady: mocks.notifyAppReady,
   reload: mocks.reload,
   resetChannel: mocks.resetChannel,
   setCohort: mocks.setCohort,
   setReloadBehavior: mocks.setReloadBehavior,
+  setUser: mocks.setUser,
   updateBundle: mocks.updateBundle,
 }));
 
@@ -70,184 +84,138 @@ vi.mock("./wrap", () => ({
   wrap: mocks.wrap,
 }));
 
-const importHotUpdater = async () => {
-  const { HotUpdater } = await import("./index");
-  return HotUpdater;
-};
+const importHotUpdater = async () => (await import("./index")).HotUpdater;
 
 describe("HotUpdater client initialization", () => {
   beforeEach(() => {
     vi.resetModules();
-
-    for (const mock of Object.values(mocks)) {
-      mock.mockReset();
-    }
-
-    mocks.addListener.mockReturnValue(() => {});
-    mocks.checkForUpdate.mockResolvedValue(null);
-    mocks.createDefaultResolver.mockImplementation((baseURL: unknown) => ({
+    vi.clearAllMocks();
+    mocks.createHttpClient.mockImplementation((baseURL: unknown) => ({
       baseURL,
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
     }));
-    mocks.getBaseURL.mockReturnValue(null);
-    mocks.init.mockReturnValue(undefined);
-    mocks.wrap.mockReturnValue((Component: unknown) => Component);
+    mocks.checkForUpdate.mockResolvedValue(null);
+    mocks.wrap.mockImplementation((Component: unknown) => Component);
   });
 
-  it("initializes manual update flows without wrapping a component", async () => {
-    const resolver = {
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
-    };
-    mocks.createDefaultResolver.mockReturnValue(resolver);
-
+  it("initializes a private HTTP client from the required baseURL", async () => {
+    const client = { createSession: vi.fn() };
+    mocks.createHttpClient.mockReturnValue(client as never);
     const HotUpdater = await importHotUpdater();
 
-    const result = HotUpdater.init({
+    HotUpdater.init({
+      analytics: true,
       baseURL: "https://updates.example.com",
-      requestHeaders: {
-        Authorization: "Bearer token",
-      },
+      requestHeaders: { Authorization: "Bearer token" },
       requestTimeout: 1000,
     });
 
-    expect(result).toBeUndefined();
-    expect(mocks.createDefaultResolver).toHaveBeenCalledWith(
+    expect(mocks.createHttpClient).toHaveBeenCalledWith(
       "https://updates.example.com",
     );
     expect(mocks.init).toHaveBeenCalledWith({
-      requestHeaders: {
-        Authorization: "Bearer token",
-      },
+      analytics: true,
+      client,
+      requestHeaders: { Authorization: "Bearer token" },
       requestTimeout: 1000,
-      resolver,
     });
   });
 
-  it("accepts dynamic baseURL resolvers for manual update flows", async () => {
-    const resolver = {
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
-    };
+  it("accepts a functional baseURL without resolving it during init", async () => {
     const resolveBaseURL = vi.fn(() => "https://updates.example.com");
-    mocks.createDefaultResolver.mockReturnValue(resolver);
-
     const HotUpdater = await importHotUpdater();
 
-    HotUpdater.init({
-      baseURL: resolveBaseURL,
-    });
+    HotUpdater.init({ baseURL: resolveBaseURL });
 
-    expect(mocks.createDefaultResolver).toHaveBeenCalledWith(resolveBaseURL);
-    expect(mocks.init).toHaveBeenCalledWith({
-      resolver,
-    });
+    expect(mocks.createHttpClient).toHaveBeenCalledWith(resolveBaseURL);
+    expect(resolveBaseURL).not.toHaveBeenCalled();
   });
 
-  it("accepts custom resolvers for manual update flows", async () => {
-    const resolver = {
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
-    };
-
+  it("requires baseURL and rejects the removed resolver shape", async () => {
     const HotUpdater = await importHotUpdater();
 
-    HotUpdater.init({
-      resolver,
-      requestHeaders: {
-        Authorization: "Bearer token",
-      },
-    });
-
-    expect(mocks.createDefaultResolver).not.toHaveBeenCalled();
-    expect(mocks.init).toHaveBeenCalledWith({
-      resolver,
-      requestHeaders: {
-        Authorization: "Bearer token",
-      },
-    });
+    expect(() => HotUpdater.init({} as never)).toThrow(
+      "baseURL must be provided",
+    );
+    expect(() => HotUpdater.init({ resolver: {} } as never)).toThrow(
+      "baseURL must be provided",
+    );
+    expect(mocks.init).not.toHaveBeenCalled();
   });
 
-  it("accepts onError during init and uses it for later manual update checks", async () => {
-    const resolver = {
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
-    };
-    const onError = vi.fn();
-    mocks.createDefaultResolver.mockReturnValue(resolver);
-
-    const HotUpdater = await importHotUpdater();
-
-    HotUpdater.init({
+  it("types init and wrap with baseURL but no resolver or catalogId", () => {
+    const initOptions = {
       baseURL: "https://updates.example.com",
-      onError,
-    });
-
-    await HotUpdater.checkForUpdate({
+    } satisfies HotUpdaterInitOptions;
+    const wrapOptions = {
+      baseURL: async () => "https://updates.example.com",
       updateStrategy: "appVersion",
-    });
+    } satisfies HotUpdaterOptions;
+
+    const assertRemovedInputsStayRejected = () => {
+      // @ts-expect-error baseURL is required
+      const missingBaseURL: HotUpdaterInitOptions = {};
+      // @ts-expect-error resolver is no longer a public input
+      const customResolver: HotUpdaterInitOptions = { resolver: {} };
+      const clientCatalog: HotUpdaterInitOptions = {
+        // @ts-expect-error catalogId is internal protocol metadata
+        catalogId: "project-a",
+        baseURL: "https://updates.example.com",
+      };
+      void missingBaseURL;
+      void customResolver;
+      void clientCatalog;
+    };
 
-    expect(mocks.init).toHaveBeenCalledWith({
-      onError,
-      resolver,
-    });
-    expect(mocks.checkForUpdate).toHaveBeenCalledWith({
-      onError,
-      requestHeaders: {},
-      requestTimeout: undefined,
-      resolver,
-      updateStrategy: "appVersion",
-    });
+    expect(assertRemovedInputsStayRejected).toBeTypeOf("function");
+    expect(initOptions.baseURL).toBe("https://updates.example.com");
+    expect(wrapOptions.updateStrategy).toBe("appVersion");
   });
 
-  it("lets checkForUpdate override the init onError handler", async () => {
-    const resolver = {
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
-    };
-    const initOnError = vi.fn();
+  it("merges settings and carries the analytics gate to checks", async () => {
+    const client = { createSession: vi.fn() };
+    mocks.createHttpClient.mockReturnValue(client as never);
     const checkOnError = vi.fn();
-    mocks.createDefaultResolver.mockReturnValue(resolver);
-
     const HotUpdater = await importHotUpdater();
-
     HotUpdater.init({
+      analytics: true,
       baseURL: "https://updates.example.com",
-      onError: initOnError,
+      requestHeaders: { Authorization: "Bearer token" },
+      requestTimeout: 1000,
     });
 
     await HotUpdater.checkForUpdate({
       onError: checkOnError,
+      requestHeaders: { "X-Runtime": "secondary" },
       updateStrategy: "appVersion",
     });
 
     expect(mocks.checkForUpdate).toHaveBeenCalledWith({
+      analytics: true,
+      client,
       onError: checkOnError,
-      requestHeaders: {},
-      requestTimeout: undefined,
-      resolver,
+      requestHeaders: {
+        Authorization: "Bearer token",
+        "X-Runtime": "secondary",
+      },
+      requestTimeout: 1000,
       updateStrategy: "appVersion",
     });
   });
 
-  it("defaults wrap to automatic update mode", async () => {
-    const resolver = {
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
-    };
-    mocks.createDefaultResolver.mockReturnValue(resolver);
-
+  it("normalizes wrap with the same private client contract", async () => {
+    const client = { createSession: vi.fn() };
+    mocks.createHttpClient.mockReturnValue(client as never);
     const HotUpdater = await importHotUpdater();
 
     HotUpdater.wrap({
+      analytics: true,
       baseURL: "https://updates.example.com",
       updateStrategy: "appVersion",
     });
 
     expect(mocks.wrap).toHaveBeenCalledWith({
-      resolver,
-      updateMode: "auto",
+      analytics: true,
+      client,
       updateStrategy: "appVersion",
     });
   });
@@ -292,95 +260,34 @@ describe("HotUpdater client initialization", () => {
     },
   );
 
-  it("keeps deprecated manual wrap calls working", async () => {
-    const resolver = {
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
-    };
-    mocks.createDefaultResolver.mockReturnValue(resolver);
-
-    const HotUpdater = await importHotUpdater();
-
-    HotUpdater.wrap({
-      baseURL: "https://updates.example.com",
-      updateMode: "manual",
-    });
-
-    expect(mocks.wrap).toHaveBeenCalledWith({
-      resolver,
-      updateMode: "manual",
-    });
-  });
-
-  it("types public wrap to accept pre-typed option unions", () => {
-    const compileOnly = (
-      wrap: typeof HotUpdaterValue.wrap,
-      options: HotUpdaterOptions,
-    ) => wrap(options);
-
-    expect(compileOnly).toBeTypeOf("function");
-  });
-
-  it("types public init options with onError", () => {
-    const options = {
-      baseURL: "https://updates.example.com",
-      onError: vi.fn(),
-    } satisfies HotUpdaterInitOptions;
-
-    expect(options.baseURL).toBe("https://updates.example.com");
-  });
-
-  it("uses init configuration for later manual update checks", async () => {
-    const resolver = {
-      checkUpdate: vi.fn(),
-      notifyAppReady: vi.fn(),
-    };
-    mocks.createDefaultResolver.mockReturnValue(resolver);
-
+  it("rejects removed manual wrap options", async () => {
     const HotUpdater = await importHotUpdater();
 
-    HotUpdater.init({
-      baseURL: "https://updates.example.com",
-      requestHeaders: {
-        Authorization: "Bearer token",
-      },
-      requestTimeout: 1000,
-    });
-
-    await HotUpdater.checkForUpdate({
-      requestHeaders: {
-        "X-Runtime": "secondary",
-      },
-      updateStrategy: "appVersion",
-    });
-
-    expect(mocks.checkForUpdate).toHaveBeenCalledWith({
-      requestHeaders: {
-        Authorization: "Bearer token",
-        "X-Runtime": "secondary",
-      },
-      requestTimeout: 1000,
-      resolver,
-      updateStrategy: "appVersion",
-    });
+    expect(() =>
+      HotUpdater.wrap({
+        baseURL: "https://updates.example.com",
+        updateMode: "manual",
+      } as never),
+    ).toThrow('HotUpdater.wrap({ updateMode: "manual" }) was removed');
   });
 
-  it("points users to wrap or init when methods are called too early", async () => {
+  it("requires initialization before manual update APIs", async () => {
     const HotUpdater = await importHotUpdater();
 
     expect(() =>
-      HotUpdater.checkForUpdate({
-        updateStrategy: "appVersion",
-      }),
+      HotUpdater.checkForUpdate({ updateStrategy: "appVersion" }),
     ).toThrow("requires HotUpdater.wrap() or HotUpdater.init() to be used");
   });
 
-  it("requires baseURL for init", async () => {
+  it("preserves native identity and user APIs", async () => {
     const HotUpdater = await importHotUpdater();
 
-    expect(() => HotUpdater.init({} as never)).toThrow(
-      "Either baseURL or resolver must be provided",
-    );
-    expect(mocks.init).not.toHaveBeenCalled();
+    expect(HotUpdater.getInstallId()).toBe("install-id");
+    expect(HotUpdater.getMinimumReleaseId()).toBe("min-bundle-id");
+    HotUpdater.setUser({ userId: "user-123", username: "alice" });
+    expect(mocks.setUser).toHaveBeenCalledWith({
+      userId: "user-123",
+      username: "alice",
+    });
   });
 });