@hot-updater/react-native 1.0.0-rc.4 → 1.0.0-rc.40

package/src/httpClient.spec.ts

@@ -1,132 +0,0 @@
-import type { ArtifactInfo, ReleaseCatalog } from "@hot-updater/core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import { createHttpClient } from "./httpClient";
-
-const mocks = vi.hoisted(() => {
-  Reflect.set(globalThis, "HotUpdater", {
-    SDK_VERSION: "test-sdk-version",
-  });
-  return {
-    fetchCatalog: vi.fn(),
-    fetchJSON: vi.fn(),
-  };
-});
-
-vi.mock("./releaseCatalogCache", () => ({
-  fetchReleaseCatalogWithCache: mocks.fetchCatalog,
-}));
-
-vi.mock("./fetchJSON", () => ({
-  fetchJSON: mocks.fetchJSON,
-}));
-
-const artifact: ArtifactInfo = {
-  fileHash: "bundle-hash",
-  fileUrl: "/storage/bundle.zip",
-};
-
-const catalog: ReleaseCatalog = {
-  catalogId: "server-owned-project",
-  catalogHash: `sha256:${"a".repeat(64)}`,
-  fallbackPolicy: "BUILTIN_IF_ACTIVE_INELIGIBLE",
-  generation: 1,
-  releases: [],
-  schemaVersion: 1,
-  scopeKey: "v1:app-version:server-owned-project:ios:cHJvZHVjdGlvbg",
-};
-
-describe("private HotUpdater HTTP client", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mocks.fetchCatalog.mockResolvedValue(catalog);
-    mocks.fetchJSON.mockResolvedValue(artifact);
-  });
-
-  it("fetches a catalog without putting its internal identity in the route", async () => {
-    const session = await createHttpClient(
-      "https://updates.example.com/hot-updater/",
-    ).createSession();
-
-    await expect(
-      session.fetchReleaseCatalog({
-        appVersion: "1.2.0",
-        channel: "production",
-        fingerprintHash: null,
-        platform: "ios",
-        updateStrategy: "appVersion",
-      }),
-    ).resolves.toBe(catalog);
-
-    expect(mocks.fetchCatalog).toHaveBeenCalledWith({
-      baseURL: "https://updates.example.com/hot-updater",
-      expectedScope: {
-        channelKey: "cHJvZHVjdGlvbg",
-        platform: "ios",
-        strategy: "APP_VERSION",
-      },
-      requestHeaders: undefined,
-      requestTimeout: undefined,
-      url: "https://updates.example.com/hot-updater/release-catalogs/app-version/ios/cHJvZHVjdGlvbg/1.2.0",
-    });
-  });
-
-  it("resolves a functional baseURL once per session and captures it for a deferred artifact", async () => {
-    const resolveBaseURL = vi
-      .fn()
-      .mockResolvedValueOnce("https://first.example.com/hot-updater")
-      .mockResolvedValueOnce("https://second.example.com/hot-updater");
-    const client = createHttpClient(resolveBaseURL);
-    const firstSession = await client.createSession();
-
-    await firstSession.fetchReleaseCatalog({
-      appVersion: "1.2.0",
-      channel: "production",
-      fingerprintHash: null,
-      platform: "ios",
-      updateStrategy: "appVersion",
-    });
-    await expect(
-      firstSession.resolveArtifact({
-        currentBundleId: "current",
-        targetBundleId: "target",
-      }),
-    ).resolves.toEqual({
-      ...artifact,
-      fileUrl: "https://first.example.com/hot-updater/storage/bundle.zip",
-    });
-
-    expect(resolveBaseURL).toHaveBeenCalledOnce();
-    expect(mocks.fetchJSON).toHaveBeenCalledWith({
-      requestHeaders: undefined,
-      requestTimeout: undefined,
-      url: "https://first.example.com/hot-updater/artifacts/target/from/current",
-    });
-
-    await client.createSession();
-    expect(resolveBaseURL).toHaveBeenCalledTimes(2);
-  });
-
-  it("rejects non-storage relative artifact URLs", async () => {
-    mocks.fetchJSON.mockResolvedValue({
-      ...artifact,
-      fileUrl: "/private/bundle.zip",
-    });
-    const session = await createHttpClient(
-      "https://updates.example.com",
-    ).createSession();
-
-    await expect(
-      session.resolveArtifact({
-        currentBundleId: "current",
-        targetBundleId: "target",
-      }),
-    ).rejects.toThrow("client-relative storage paths");
-  });
-
-  it("requires a functional baseURL to resolve to a non-empty string", async () => {
-    await expect(createHttpClient(() => "").createSession()).rejects.toThrow(
-      "baseURL function must return a non-empty string",
-    );
-  });
-});

package/src/index.spec.ts

@@ -1,337 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { HotUpdaterInitOptions, HotUpdaterOptions } from "./wrap";
-
-const mocks = vi.hoisted(() => {
-  (
-    globalThis as typeof globalThis & {
-      HotUpdater: { SDK_VERSION: string };
-    }
-  ).HotUpdater = { SDK_VERSION: "test-sdk-version" };
-
-  return {
-    addListener: vi.fn(() => () => {}),
-    checkForUpdate: vi.fn(async () => null),
-    clearCrashHistory: vi.fn(() => true),
-    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),
-    getUpdateId: vi.fn(() => "release-id"),
-    getChannel: vi.fn(() => "production"),
-    getCohort: vi.fn(() => "123"),
-    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"),
-    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((Component: unknown) => Component),
-  };
-});
-
-vi.mock("./httpClient", () => ({
-  createHttpClient: mocks.createHttpClient,
-}));
-
-vi.mock("./checkForUpdate", () => ({
-  checkForUpdate: mocks.checkForUpdate,
-}));
-
-vi.mock("./native", () => ({
-  addListener: mocks.addListener,
-  clearCrashHistory: mocks.clearCrashHistory,
-  getPublicActiveUpdateState: mocks.getActiveUpdateState,
-  getAppVersion: mocks.getAppVersion,
-  getBaseURL: mocks.getBaseURL,
-  getUpdateId: mocks.getUpdateId,
-  getChannel: mocks.getChannel,
-  getCohort: mocks.getCohort,
-  getCrashHistory: mocks.getCrashHistory,
-  getDefaultChannel: mocks.getDefaultChannel,
-  getFingerprintHash: mocks.getFingerprintHash,
-  getInstallId: mocks.getInstallId,
-  getManifest: mocks.getManifest,
-  getMinBundleId: mocks.getMinBundleId,
-  isChannelSwitched: mocks.isChannelSwitched,
-  notifyAppReady: mocks.notifyAppReady,
-  reload: mocks.reload,
-  resetChannel: mocks.resetChannel,
-  setCohort: mocks.setCohort,
-  setReloadBehavior: mocks.setReloadBehavior,
-  setUser: mocks.setUser,
-  updateBundle: mocks.updateBundle,
-}));
-
-vi.mock("./wrap", () => ({
-  init: mocks.init,
-  wrap: mocks.wrap,
-}));
-
-const importHotUpdater = async () => (await import("./index")).HotUpdater;
-
-describe("HotUpdater client initialization", () => {
-  beforeEach(() => {
-    vi.resetModules();
-    vi.clearAllMocks();
-    mocks.createHttpClient.mockImplementation((baseURL: unknown) => ({
-      baseURL,
-    }));
-    mocks.checkForUpdate.mockResolvedValue(null);
-    mocks.wrap.mockImplementation((Component: unknown) => Component);
-  });
-
-  it("exposes the console ID through the existing getter only", async () => {
-    const HotUpdater = await importHotUpdater();
-
-    expect(HotUpdater.getBundleId()).toBe("release-id");
-    expect(HotUpdater).not.toHaveProperty("getReleaseId");
-    expect(HotUpdater).not.toHaveProperty("getUpdateId");
-  });
-
-  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();
-
-    HotUpdater.init({
-      insights: true,
-      baseURL: "https://updates.example.com",
-      requestHeaders: { Authorization: "Bearer token" },
-      requestTimeout: 1000,
-    });
-
-    expect(mocks.createHttpClient).toHaveBeenCalledWith(
-      "https://updates.example.com",
-    );
-    expect(mocks.init).toHaveBeenCalledWith({
-      insights: true,
-      client,
-      requestHeaders: { Authorization: "Bearer token" },
-      requestTimeout: 1000,
-    });
-  });
-
-  it("accepts a functional baseURL without resolving it during init", async () => {
-    const resolveBaseURL = vi.fn(() => "https://updates.example.com");
-    const HotUpdater = await importHotUpdater();
-
-    HotUpdater.init({ baseURL: resolveBaseURL });
-
-    expect(mocks.createHttpClient).toHaveBeenCalledWith(resolveBaseURL);
-    expect(resolveBaseURL).not.toHaveBeenCalled();
-  });
-
-  it("enables insights by default for init and wrap", async () => {
-    const HotUpdater = await importHotUpdater();
-
-    HotUpdater.init({ baseURL: "https://updates.example.com" });
-    HotUpdater.wrap({
-      baseURL: "https://updates.example.com",
-      updateStrategy: "appVersion",
-    });
-
-    expect(mocks.init).toHaveBeenCalledWith(
-      expect.objectContaining({ insights: true }),
-    );
-    expect(mocks.wrap).toHaveBeenCalledWith(
-      expect.objectContaining({ insights: true }),
-    );
-  });
-
-  it("preserves an explicit insights opt-out", async () => {
-    const HotUpdater = await importHotUpdater();
-
-    HotUpdater.init({
-      baseURL: "https://updates.example.com",
-      insights: false,
-    });
-    HotUpdater.wrap({
-      baseURL: "https://updates.example.com",
-      insights: false,
-      updateStrategy: "appVersion",
-    });
-
-    expect(mocks.init).toHaveBeenCalledWith(
-      expect.objectContaining({ insights: false }),
-    );
-    expect(mocks.wrap).toHaveBeenCalledWith(
-      expect.objectContaining({ insights: false }),
-    );
-  });
-
-  it("requires baseURL and rejects the removed resolver shape", async () => {
-    const HotUpdater = await importHotUpdater();
-
-    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("types init and wrap with baseURL but no resolver or catalogId", () => {
-    const initOptions = {
-      baseURL: "https://updates.example.com",
-    } 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(assertRemovedInputsStayRejected).toBeTypeOf("function");
-    expect(initOptions.baseURL).toBe("https://updates.example.com");
-    expect(wrapOptions.updateStrategy).toBe("appVersion");
-  });
-
-  it("merges settings and carries the insights gate to checks", async () => {
-    const client = { createSession: vi.fn() };
-    mocks.createHttpClient.mockReturnValue(client as never);
-    const checkOnError = vi.fn();
-    const HotUpdater = await importHotUpdater();
-    HotUpdater.init({
-      insights: true,
-      baseURL: "https://updates.example.com",
-      requestHeaders: { Authorization: "Bearer token" },
-      requestTimeout: 1000,
-    });
-
-    await HotUpdater.checkForUpdate({
-      onError: checkOnError,
-      requestHeaders: { "X-Runtime": "secondary" },
-      updateStrategy: "appVersion",
-    });
-
-    expect(mocks.checkForUpdate).toHaveBeenCalledWith({
-      insights: true,
-      client,
-      onError: checkOnError,
-      requestHeaders: {
-        Authorization: "Bearer token",
-        "X-Runtime": "secondary",
-      },
-      requestTimeout: 1000,
-      updateStrategy: "appVersion",
-    });
-  });
-
-  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({
-      insights: true,
-      baseURL: "https://updates.example.com",
-      updateStrategy: "appVersion",
-    });
-
-    expect(mocks.wrap).toHaveBeenCalledWith({
-      insights: true,
-      client,
-      updateStrategy: "appVersion",
-    });
-  });
-
-  it.each([
-    ["init", "wrap"],
-    ["wrap", "init"],
-  ] as const)(
-    "reports %s and %s mixed usage exactly once",
-    async (first, second) => {
-      const consoleError = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => undefined);
-      const HotUpdater = await importHotUpdater();
-      const configure = (api: "init" | "wrap") => {
-        if (api === "init") {
-          HotUpdater.init({ baseURL: "https://updates.example.com" });
-          return;
-        }
-        HotUpdater.wrap({
-          baseURL: "https://updates.example.com",
-          updateStrategy: "appVersion",
-        });
-      };
-
-      configure(first);
-      configure(second);
-      configure(second);
-
-      expect(consoleError).toHaveBeenCalledOnce();
-      expect(consoleError).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "HotUpdater.init() and HotUpdater.wrap() must not be used together",
-        ),
-      );
-      expect(consoleError).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "use HotUpdater.init() with HotUpdater.checkForUpdate()",
-        ),
-      );
-      consoleError.mockRestore();
-    },
-  );
-
-  it("rejects removed manual wrap options", async () => {
-    const HotUpdater = await importHotUpdater();
-
-    expect(() =>
-      HotUpdater.wrap({
-        baseURL: "https://updates.example.com",
-        updateMode: "manual",
-      } as never),
-    ).toThrow('HotUpdater.wrap({ updateMode: "manual" }) was removed');
-  });
-
-  it("requires initialization before manual update APIs", async () => {
-    const HotUpdater = await importHotUpdater();
-
-    expect(() =>
-      HotUpdater.checkForUpdate({ updateStrategy: "appVersion" }),
-    ).toThrow("requires HotUpdater.wrap() or HotUpdater.init() to be used");
-  });
-
-  it("preserves native identity and user APIs", async () => {
-    const HotUpdater = await importHotUpdater();
-
-    expect(HotUpdater.getInstallId()).toBe("install-id");
-    expect(HotUpdater.getMinBundleId()).toBe("min-bundle-id");
-    HotUpdater.setUser({ userId: "user-123", username: "alice" });
-    expect(mocks.setUser).toHaveBeenCalledWith({
-      userId: "user-123",
-      username: "alice",
-    });
-  });
-});

package/src/iosInterop.spec.ts

@@ -1,30 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-
-import { describe, expect, it } from "vitest";
-
-const iosInternalDirectory = resolve(
-  import.meta.dirname,
-  "../ios/HotUpdater/Internal",
-);
-
-const readIOSSource = (filename: string) =>
-  readFileSync(resolve(iosInternalDirectory, filename), "utf8");
-
-describe("iOS Objective-C interoperability", () => {
-  it("does not call an autoreleased NSString through raw Swift ABI", () => {
-    const implementation = readIOSSource("HotUpdaterImpl.swift");
-    const objectiveCImplementation = readIOSSource("HotUpdater.mm");
-
-    expect(implementation).not.toContain(
-      '@_silgen_name("HotUpdaterGetMinBundleId")',
-    );
-    expect(implementation).toContain(
-      '@_silgen_name("HotUpdaterCopyMinBundleId")',
-    );
-    expect(implementation).toContain(".takeRetainedValue() as String");
-    expect(objectiveCImplementation).toContain(
-      "return (__bridge_retained void *)HotUpdaterGetMinBundleId();",
-    );
-  });
-});