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

package/src/updateError.spec.ts

@@ -1,144 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { StaleReleaseCatalogError } from "./error";
-import { FetchJSONResponseError } from "./fetchJSON";
-import {
-  classifyUpdateError,
-  InvalidUpdateResponseError,
-  UpdateHttpError,
-} from "./updateError";
-
-const nativeRejection = (userInfo?: Record<string, unknown>) =>
-  Object.assign(new Error("native failure"), {
-    code: "DOWNLOAD_FAILED",
-    ...(userInfo === undefined ? {} : { userInfo }),
-  });
-
-describe("classifyUpdateError", () => {
-  it.each([
-    {
-      label: "an HTTP status",
-      error: new UpdateHttpError(503, "Service Unavailable"),
-      expected: { reason: "http", httpStatus: 503 },
-    },
-    {
-      label: "a JSON request's HTTP status",
-      error: new FetchJSONResponseError(404, "Not Found"),
-      expected: { reason: "http", httpStatus: 404 },
-    },
-    {
-      label: "fetch without a response",
-      error: new TypeError("Network request failed"),
-      expected: { reason: "network" },
-    },
-    {
-      label: "a timeout",
-      error: new Error("Request timed out"),
-      expected: { reason: "network", transport: "timeout" },
-    },
-    {
-      label: "a cancelled request",
-      error: Object.assign(new Error("aborted"), { name: "AbortError" }),
-      expected: { reason: "network", transport: "cancelled" },
-    },
-    {
-      label: "an invalid response",
-      error: new InvalidUpdateResponseError(
-        "Received an invalid Release catalog",
-      ),
-      expected: { reason: "invalid_response" },
-    },
-    {
-      label: "unparsable JSON",
-      error: new SyntaxError("Unexpected token"),
-      expected: { reason: "invalid_response" },
-    },
-    {
-      label: "anything else",
-      error: new Error("Fingerprint hash is required"),
-      expected: { reason: "unknown" },
-    },
-  ])("classifies $label in the stage it happened", ({ error, expected }) => {
-    expect(classifyUpdateError(error, "check", "catalog")).toEqual({
-      stage: "check",
-      resource: "catalog",
-      ...expected,
-    });
-  });
-
-  it("leaves out the resource when the caller names none", () => {
-    expect(classifyUpdateError(new Error("unexpected"), "download")).toEqual({
-      stage: "download",
-      reason: "unknown",
-    });
-  });
-
-  it("takes a native rejection's own classification", () => {
-    expect(
-      classifyUpdateError(
-        nativeRejection({
-          reason: "patch",
-          resource: "patch",
-          stage: "install",
-        }),
-        "download",
-        "artifact",
-      ),
-    ).toEqual({ stage: "install", reason: "patch", resource: "patch" });
-    expect(
-      classifyUpdateError(
-        nativeRejection({
-          httpStatus: 403,
-          originCode: "AccessDenied",
-          reason: "http",
-          resource: "file",
-          stage: "download",
-        }),
-        "download",
-      ),
-    ).toEqual({
-      stage: "download",
-      reason: "http",
-      resource: "file",
-      httpStatus: 403,
-      originCode: "AccessDenied",
-    });
-    expect(
-      classifyUpdateError(
-        nativeRejection({
-          reason: "network",
-          stage: "download",
-          transport: "dns",
-        }),
-        "download",
-      ),
-    ).toEqual({ stage: "download", reason: "network", transport: "dns" });
-  });
-
-  it("drops native details that do not fit their field", () => {
-    expect(
-      classifyUpdateError(
-        nativeRejection({
-          httpStatus: 403,
-          originCode: "Access Denied <Key>secret</Key>",
-          reason: "http",
-          resource: "bucket",
-          stage: "download",
-          transport: "timeout",
-        }),
-        "download",
-      ),
-    ).toEqual({ stage: "download", reason: "http", httpStatus: 403 });
-  });
-
-  it.each([
-    { label: "a stale selection", error: new StaleReleaseCatalogError() },
-    { label: "an unclassified native rejection", error: nativeRejection() },
-    {
-      label: "a native rejection with an unknown class",
-      error: nativeRejection({ reason: "cosmic", stage: "download" }),
-    },
-  ])("reports $label as no update failure", ({ error }) => {
-    expect(classifyUpdateError(error, "download")).toBeNull();
-  });
-});

package/src/wrap.progress.spec.ts

@@ -1,232 +0,0 @@
-// @vitest-environment jsdom
-
-import { act, cleanup, render, screen } from "@testing-library/react";
-import { createElement } from "react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { HotUpdaterProgressEvent } from "./native";
-import type {
-  HotUpdaterFallbackComponentProps,
-  InternalWrapOptions,
-} from "./wrap";
-
-const mocks = vi.hoisted(() => ({
-  listeners: new Map<string, (event: HotUpdaterProgressEvent) => void>(),
-  checkForUpdate: vi.fn(),
-  reload: vi.fn(),
-}));
-
-vi.mock("./checkForUpdate", () => ({
-  checkForUpdate: mocks.checkForUpdate,
-}));
-
-vi.mock("./appReady", () => ({
-  handleNotifyAppReady: vi.fn().mockResolvedValue({ status: "UNCHANGED" }),
-}));
-
-vi.mock("./native", () => ({
-  addListener: vi.fn(
-    (eventName: string, listener: (event: HotUpdaterProgressEvent) => void) => {
-      mocks.listeners.set(eventName, listener);
-      return () => {
-        mocks.listeners.delete(eventName);
-      };
-    },
-  ),
-  getUpdateId: vi.fn(() => "release-id"),
-  reload: mocks.reload,
-}));
-
-describe("HotUpdater wrap progress subscription", () => {
-  let frameCallbacks: ((timestamp: number) => void)[];
-
-  const flushFrames = async () => {
-    await act(async () => {
-      await new Promise<void>((resolve) => setImmediate(resolve));
-      while (frameCallbacks.length > 0) {
-        frameCallbacks.shift()?.(0);
-      }
-    });
-  };
-
-  const emitProgress = async (progress: number) => {
-    const event: HotUpdaterProgressEvent = {
-      artifactType: "diff",
-      progress,
-      details: {
-        totalFilesCount: 1,
-        completedFilesCount: progress === 1 ? 1 : 0,
-        files: [
-          {
-            order: 0,
-            path: "index.bundle",
-            downloadPath: "index.bundle",
-            downloadedBytes: progress * 1_000,
-            totalBytes: 1_000,
-            progress,
-            status: progress === 1 ? "downloaded" : "downloading",
-          },
-        ],
-      },
-    };
-    await act(async () => {
-      mocks.listeners.get("onProgress")?.(event);
-    });
-    await flushFrames();
-    return event;
-  };
-
-  const renderWrapped = async (
-    options: Pick<
-      InternalWrapOptions,
-      "fallbackComponent" | "onProgress" | "onUpdateProcessCompleted"
-    >,
-    onRender: () => void,
-  ) => {
-    const { wrap } = await import("./wrap");
-    const App = () => {
-      onRender();
-      return createElement("div", null, "app");
-    };
-    const Wrapped = wrap({
-      client: { createSession: vi.fn() },
-      updateStrategy: "appVersion",
-      ...options,
-    })(App);
-
-    render(createElement(Wrapped));
-    await flushFrames();
-  };
-
-  beforeEach(() => {
-    vi.resetModules();
-    mocks.listeners.clear();
-    mocks.checkForUpdate.mockReset();
-    mocks.checkForUpdate.mockResolvedValue(null);
-    mocks.reload.mockReset();
-    frameCallbacks = [];
-    vi.stubGlobal(
-      "requestAnimationFrame",
-      (callback: (timestamp: number) => void) => {
-        frameCallbacks.push(callback);
-        return frameCallbacks.length;
-      },
-    );
-  });
-
-  afterEach(() => {
-    cleanup();
-    vi.unstubAllGlobals();
-  });
-
-  it("does not re-render the wrapped app on progress updates without fallbackComponent or onProgress", async () => {
-    const onRender = vi.fn();
-    await renderWrapped({}, onRender);
-    const rendersBeforeDownload = onRender.mock.calls.length;
-
-    for (const progress of [0.1, 0.2, 0.3, 0.4, 0.5]) {
-      await emitProgress(progress);
-    }
-
-    expect(onRender).toHaveBeenCalledTimes(rendersBeforeDownload);
-  });
-
-  it("keeps reporting progress to onProgress without re-rendering the wrapped app", async () => {
-    const onRender = vi.fn();
-    const onProgress = vi.fn();
-    await renderWrapped({ onProgress }, onRender);
-    const rendersBeforeDownload = onRender.mock.calls.length;
-
-    await emitProgress(0.25);
-    await emitProgress(0.75);
-
-    expect(onProgress.mock.calls).toEqual([[0], [0.25], [0.75]]);
-    expect(onRender).toHaveBeenCalledTimes(rendersBeforeDownload);
-  });
-
-  it("keeps passing progress details to fallbackComponent during an update check", async () => {
-    mocks.checkForUpdate.mockReturnValue(new Promise(() => {}));
-    const fallbackProps = vi.fn();
-    const Fallback = (props: HotUpdaterFallbackComponentProps) => {
-      fallbackProps(props);
-      return createElement("div", null, `progress:${props.progress}`);
-    };
-    await renderWrapped({ fallbackComponent: Fallback }, vi.fn());
-
-    const event = await emitProgress(0.5);
-
-    expect(screen.getByText("progress:0.5")).toBeTruthy();
-    expect(fallbackProps).toHaveBeenLastCalledWith({
-      ...event,
-      status: "CHECK_FOR_UPDATE",
-      message: null,
-    });
-  });
-
-  it.each([false, true])(
-    "preserves progress reporting across the fallback transition with shouldForceUpdate=%s",
-    async (shouldForceUpdate) => {
-      let resolveCheck!: (update: unknown) => void;
-      mocks.checkForUpdate.mockReturnValue(
-        new Promise((resolve) => {
-          resolveCheck = resolve;
-        }),
-      );
-      let finishDownload!: (success: boolean) => void;
-      const download = new Promise<boolean>((resolve) => {
-        finishDownload = resolve;
-      });
-      const updateBundle = vi.fn(() => download);
-      const onProgress = vi.fn();
-      const onRender = vi.fn();
-      const onUpdateProcessCompleted = vi.fn();
-      const Fallback = ({
-        status,
-        progress,
-      }: HotUpdaterFallbackComponentProps) =>
-        createElement("div", null, `${status}:${progress}`);
-      await renderWrapped(
-        { fallbackComponent: Fallback, onProgress, onUpdateProcessCompleted },
-        onRender,
-      );
-      expect(screen.getByText("CHECK_FOR_UPDATE:0")).toBeTruthy();
-      expect(onRender).not.toHaveBeenCalled();
-
-      const update = {
-        id: "new-release",
-        status: "UPDATE",
-        shouldForceUpdate,
-        message: "New release",
-      };
-      await act(async () => {
-        resolveCheck({ ...update, updateBundle });
-      });
-      expect(updateBundle).toHaveBeenCalledOnce();
-      expect(onUpdateProcessCompleted).toHaveBeenCalledTimes(
-        shouldForceUpdate ? 0 : 1,
-      );
-      expect(
-        screen.getByText(shouldForceUpdate ? "UPDATING:0" : "app"),
-      ).toBeTruthy();
-      const rendersDuringDownload = onRender.mock.calls.length;
-
-      for (const progress of [0.25, 0.75, 1]) {
-        await emitProgress(progress);
-      }
-      expect(onRender).toHaveBeenCalledTimes(rendersDuringDownload);
-      if (shouldForceUpdate) {
-        expect(screen.getByText("UPDATING:1")).toBeTruthy();
-      }
-
-      await act(async () => {
-        finishDownload(true);
-      });
-      expect(screen.getByText("app")).toBeTruthy();
-      expect(onRender).toHaveBeenCalledOnce();
-      expect(onUpdateProcessCompleted).toHaveBeenCalledOnce();
-      expect(onUpdateProcessCompleted).toHaveBeenCalledWith(update);
-      expect(mocks.reload).toHaveBeenCalledTimes(shouldForceUpdate ? 1 : 0);
-      expect(onProgress.mock.calls).toEqual([[0], [0.25], [0.75], [1]]);
-    },
-  );
-});

package/src/wrap.spec.ts

@@ -1,262 +0,0 @@
-// @vitest-environment jsdom
-
-import { cleanup, render, waitFor } from "@testing-library/react";
-import { createElement, type ComponentType } from "react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { createNotifyReadResult } from "./appReady.test-utils";
-import type { HotUpdaterClientPlugin } from "./clientPlugin";
-import type {
-  ActiveUpdateState,
-  LaunchTransition,
-  NotifyAppReadyResult,
-} from "./native";
-import type { HotUpdaterOptions } from "./wrap";
-
-vi.mock("react-native", () => ({
-  Platform: {
-    OS: "ios",
-  },
-}));
-
-const mocks = vi.hoisted(() => {
-  Reflect.set(globalThis, "HotUpdater", { SDK_VERSION: "test-sdk-version" });
-  return {
-    addListener: vi.fn(() => () => {}),
-    checkForUpdate: vi.fn(),
-    getAppVersion: vi.fn(() => "1.0.0"),
-    getBundleId: vi.fn(() => "bundle-id"),
-    getUpdateId: vi.fn(() => "release-id"),
-    getChannel: vi.fn(() => "production"),
-    getActiveUpdateState: vi.fn<() => ActiveUpdateState>(),
-    getCohort: vi.fn(() => "123"),
-    getFingerprintHash: vi.fn(() => "fingerprint-hash"),
-    getInstallId: vi.fn(() => "install-id"),
-    readNotifyAppReady: vi.fn<
-      () => {
-        transition: LaunchTransition | null;
-        previousProcessExit: string | 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,
-  getUpdateId: mocks.getUpdateId,
-  getChannel: mocks.getChannel,
-  getActiveUpdateState: mocks.getActiveUpdateState,
-  getCohort: mocks.getCohort,
-  getFingerprintHash: mocks.getFingerprintHash,
-  getInstallId: mocks.getInstallId,
-  readNotifyAppReady: mocks.readNotifyAppReady,
-  reload: mocks.reload,
-}));
-
-const createClient = () => ({
-  client: {
-    createSession: vi.fn(async () => ({
-      fetchReleaseCatalog: vi.fn(),
-      resolveArtifact: vi.fn(),
-    })),
-  },
-});
-
-const configureRecorder = async () => {
-  const { configurePlugins } = await import("./pluginHost");
-  const onAppReady = vi.fn();
-  const plugin: HotUpdaterClientPlugin = {
-    id: "recorder",
-    setup: () => ({ onAppReady }),
-  };
-  configurePlugins([plugin], { baseURL: "https://updates.example.com" });
-  return onAppReady;
-};
-
-describe("HotUpdater wrap initialization", () => {
-  beforeEach(() => {
-    vi.resetModules();
-    vi.unstubAllGlobals();
-    vi.useRealTimers();
-
-    for (const mock of Object.values(mocks)) {
-      mock.mockReset();
-    }
-
-    mocks.checkForUpdate.mockResolvedValue(null);
-    mocks.addListener.mockReturnValue(() => {});
-    mocks.getAppVersion.mockReturnValue("1.0.0");
-    mocks.getBundleId.mockReturnValue("bundle-id");
-    mocks.getUpdateId.mockReturnValue("release-id");
-    mocks.getChannel.mockReturnValue("production");
-    mocks.getActiveUpdateState.mockReturnValue({
-      activeSelection: null,
-      stableSelection: null,
-      verificationPending: false,
-    });
-    mocks.getCohort.mockReturnValue("123");
-    mocks.getFingerprintHash.mockReturnValue("fingerprint-hash");
-    mocks.getInstallId.mockReturnValue("install-id");
-    mocks.readNotifyAppReady.mockReturnValue(createNotifyReadResult());
-  });
-
-  afterEach(cleanup);
-
-  it("reports the console ID when up to date and the launch to plugins", async () => {
-    const onAppReady = await configureRecorder();
-    const onUpdateProcessCompleted = vi.fn();
-    const { client } = createClient();
-    const { wrap } = await import("./wrap");
-    const WrappedComponent = wrap({
-      client,
-      onUpdateProcessCompleted,
-      updateStrategy: "appVersion",
-    })(() => null);
-
-    render(createElement(WrappedComponent));
-
-    await waitFor(() =>
-      expect(onUpdateProcessCompleted).toHaveBeenCalledWith({
-        id: "release-id",
-        message: null,
-        shouldForceUpdate: false,
-        status: "UP_TO_DATE",
-      }),
-    );
-    expect(onAppReady).toHaveBeenCalledExactlyOnceWith({
-      status: "UNCHANGED",
-      channel: "production",
-      bundleId: "bundle-id",
-      releaseId: null,
-      previousProcessExit: null,
-    });
-    expect(mocks.checkForUpdate).toHaveBeenCalledWith({
-      client,
-      onError: undefined,
-      requestHeaders: undefined,
-      requestTimeout: undefined,
-      updateStrategy: "appVersion",
-    });
-  });
-
-  it("completes an optional update while its download continues", async () => {
-    let complete!: (success: boolean) => void;
-    const download = vi.fn(
-      () =>
-        new Promise<boolean>((resolve) => {
-          complete = resolve;
-        }),
-    );
-    mocks.checkForUpdate.mockResolvedValue({
-      id: "next",
-      status: "UPDATE",
-      shouldForceUpdate: false,
-      message: null,
-      updateBundle: download,
-    });
-    const { wrap } = await import("./wrap");
-    const onUpdateProcessCompleted = vi.fn();
-    const Wrapped = wrap({
-      client: createClient().client,
-      updateStrategy: "appVersion",
-      onUpdateProcessCompleted,
-    })(() => null);
-
-    render(createElement(Wrapped));
-
-    await waitFor(() => expect(download).toHaveBeenCalledOnce());
-    expect(onUpdateProcessCompleted).toHaveBeenCalledExactlyOnceWith({
-      id: "next",
-      message: null,
-      shouldForceUpdate: false,
-      status: "UPDATE",
-    });
-    complete(true);
-  });
-
-  it("returns void from init and defers notifyAppReady to the next frame", async () => {
-    vi.useFakeTimers();
-
-    const requestAnimationFrame = vi.fn(
-      (callback: (timestamp: number) => void) => {
-        setTimeout(() => callback(0), 0);
-        return 1;
-      },
-    );
-    vi.stubGlobal("requestAnimationFrame", requestAnimationFrame);
-    const onAppReady = await configureRecorder();
-
-    const { client } = createClient();
-    const { init } = await import("./wrap");
-
-    const result = init({
-      client,
-      requestHeaders: {
-        Authorization: "Bearer token",
-      },
-      requestTimeout: 1000,
-    });
-
-    expect(result).toBeUndefined();
-    expect(mocks.readNotifyAppReady).not.toHaveBeenCalled();
-    expect(onAppReady).not.toHaveBeenCalled();
-    expect(requestAnimationFrame).toHaveBeenCalled();
-
-    await vi.runOnlyPendingTimersAsync();
-
-    expect(mocks.readNotifyAppReady).toHaveBeenCalledWith();
-    expect(onAppReady).toHaveBeenCalledOnce();
-  });
-
-  it("does not accept a manual wrap HOC", async () => {
-    const { wrap } = await import("./wrap");
-
-    wrap({
-      client: createClient().client,
-      updateStrategy: "appVersion",
-    });
-  });
-
-  it("preserves wrapped component prop inference", async () => {
-    const { wrap } = await import("./wrap");
-    const Component: ComponentType<{ title: string }> = () => null;
-
-    const WrappedComponent = wrap({
-      client: createClient().client,
-      updateStrategy: "appVersion",
-    })(Component);
-
-    const acceptsTitleProps: ComponentType<{ title: string }> =
-      WrappedComponent;
-    expect(acceptsTitleProps).toBe(WrappedComponent);
-  });
-
-  it("types public wrap options as automatic mode by default", () => {
-    const autoOptions = {
-      baseURL: "https://updates.example.com",
-      updateStrategy: "appVersion",
-    } satisfies HotUpdaterOptions;
-
-    const assertRemovedOptionStaysRejected = () => {
-      const withInsights: HotUpdaterOptions = {
-        baseURL: "https://updates.example.com",
-        updateStrategy: "appVersion",
-        // @ts-expect-error Insights is the insights() plugin, not an option.
-        insights: true,
-      };
-      void withInsights;
-    };
-
-    expect(assertRemovedOptionStaysRejected).toBeTypeOf("function");
-    expect(autoOptions.updateStrategy).toBe("appVersion");
-  });
-});