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

package/src/releaseCatalogCache.spec.ts

@@ -1,304 +0,0 @@
-import {
-  createReleaseCatalogScopeKey,
-  encodeChannelKey,
-  MAX_COMPILED_CATALOG_BYTES,
-  type ReleaseCatalog,
-} from "@hot-updater/core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import {
-  createReleaseCatalogCachePartition,
-  fetchReleaseCatalogWithCache,
-  MAX_RELEASE_CATALOG_CACHE_ENTRY_BYTES,
-  MAX_RELEASE_CATALOG_WIRE_BYTES,
-} from "./releaseCatalogCache";
-
-const cache = vi.hoisted(() => new Map<string, string>());
-const nativeMocks = vi.hoisted(() => ({
-  read: vi.fn(async (partition: string) => cache.get(partition) ?? null),
-  remove: vi.fn(async (partition: string) => {
-    cache.delete(partition);
-  }),
-  write: vi.fn(async (partition: string, payload: string) => {
-    cache.set(partition, payload);
-    return true;
-  }),
-}));
-
-vi.mock("./catalogCacheNative", () => ({
-  readNativeReleaseCatalogCache: nativeMocks.read,
-  removeNativeReleaseCatalogCache: nativeMocks.remove,
-  writeNativeReleaseCatalogCache: nativeMocks.write,
-}));
-
-const CATALOG_ID = "project-a";
-const CHANNEL_KEY = encodeChannelKey("production");
-const SCOPE_KEY = createReleaseCatalogScopeKey({
-  channelKey: CHANNEL_KEY,
-  platform: "ios",
-  strategy: "APP_VERSION",
-});
-const URL = `https://updates.example.com/release-catalogs/app-version/ios/${CHANNEL_KEY}/1.0.0`;
-const EXPECTED_SCOPE = {
-  channelKey: CHANNEL_KEY,
-  platform: "ios",
-  strategy: "APP_VERSION",
-} as const;
-
-const catalog: ReleaseCatalog = {
-  catalogId: CATALOG_ID,
-  catalogHash: `sha256:${"a".repeat(64)}`,
-  fallbackPolicy: "BUILTIN_IF_ACTIVE_INELIGIBLE",
-  generation: 1,
-  releases: [
-    {
-      bundleId: "00000000-0000-7000-8000-000000000002",
-      kind: "BUNDLE",
-      message: null,
-      releaseId: "00000000-0000-7000-8000-000000000001",
-      rolloutCohortCount: 1000,
-      shouldForceUpdate: false,
-      targetCohorts: [],
-    },
-  ],
-  schemaVersion: 1,
-  scopeKey: SCOPE_KEY,
-};
-
-const input = (
-  overrides: Partial<Parameters<typeof fetchReleaseCatalogWithCache>[0]> = {},
-) => ({
-  baseURL: "https://updates.example.com",
-  expectedScope: EXPECTED_SCOPE,
-  requestHeaders: { "X-API-Key": "api-key-a" },
-  url: URL,
-  ...overrides,
-});
-
-const response = (status: number, body?: string, etag?: string) =>
-  new Response(body, {
-    headers: etag === undefined ? undefined : { ETag: etag },
-    status,
-    statusText: status === 200 ? "OK" : "Request failed",
-  });
-
-const requestHeadersAt = (
-  fetchMock: ReturnType<typeof vi.fn>,
-  index: number,
-) => {
-  const request = fetchMock.mock.calls[index]?.[1] as RequestInit | undefined;
-  return new Headers(request?.headers);
-};
-
-describe("Release Catalog persistent cache", () => {
-  beforeEach(() => {
-    cache.clear();
-    vi.clearAllMocks();
-  });
-
-  it("persists a validated 200 and reuses it across resolver instances on 304", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(response(200, JSON.stringify(catalog), '"v1"'))
-      .mockResolvedValueOnce(response(304));
-    vi.stubGlobal("fetch", fetchMock);
-
-    await expect(fetchReleaseCatalogWithCache(input())).resolves.toEqual(
-      catalog,
-    );
-    expect(nativeMocks.write).toHaveBeenCalledOnce();
-
-    const parseSpy = vi.spyOn(JSON, "parse");
-    await expect(fetchReleaseCatalogWithCache(input())).resolves.toEqual(
-      catalog,
-    );
-    expect(requestHeadersAt(fetchMock, 1).get("if-none-match")).toBe('"v1"');
-    expect(parseSpy).not.toHaveBeenCalled();
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("repairs an invalid cache after an unsatisfiable 304 with one unconditional request", async () => {
-    const partition = createReleaseCatalogCachePartition(input());
-    cache.set(partition, "invalid-envelope");
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(response(304))
-      .mockResolvedValueOnce(response(200, JSON.stringify(catalog), '"v2"'));
-    vi.stubGlobal("fetch", fetchMock);
-
-    await expect(fetchReleaseCatalogWithCache(input())).resolves.toEqual(
-      catalog,
-    );
-
-    expect(nativeMocks.remove).toHaveBeenCalledWith(partition);
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    expect(requestHeadersAt(fetchMock, 0).has("if-none-match")).toBe(false);
-    expect(requestHeadersAt(fetchMock, 1).has("if-none-match")).toBe(false);
-    expect(cache.get(partition)).toContain('"v2"');
-  });
-
-  it("isolates base URL, scope, and case-insensitive API-key partitions", async () => {
-    const betaScope = createReleaseCatalogScopeKey({
-      channelKey: encodeChannelKey("beta"),
-      platform: "ios",
-      strategy: "APP_VERSION",
-    });
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(response(200, JSON.stringify(catalog), '"v1"'))
-      .mockResolvedValueOnce(response(304))
-      .mockResolvedValueOnce(response(200, JSON.stringify(catalog), '"key-b"'))
-      .mockResolvedValueOnce(
-        response(
-          200,
-          JSON.stringify({ ...catalog, scopeKey: betaScope }),
-          '"beta"',
-        ),
-      );
-    vi.stubGlobal("fetch", fetchMock);
-
-    await fetchReleaseCatalogWithCache(input());
-    await fetchReleaseCatalogWithCache(
-      input({ requestHeaders: { "x-api-key": "api-key-a" } }),
-    );
-    await fetchReleaseCatalogWithCache(
-      input({ requestHeaders: { "x-api-key": "api-key-b" } }),
-    );
-    await fetchReleaseCatalogWithCache(
-      input({
-        baseURL: "https://other.example.com",
-        expectedScope: {
-          channelKey: encodeChannelKey("beta"),
-          platform: "ios",
-          strategy: "APP_VERSION",
-        },
-        url: "https://other.example.com/release-catalogs/app-version/ios/YmV0YQ/1.0.0",
-      }),
-    );
-
-    expect(requestHeadersAt(fetchMock, 1).get("if-none-match")).toBe('"v1"');
-    expect(requestHeadersAt(fetchMock, 2).has("if-none-match")).toBe(false);
-    expect(requestHeadersAt(fetchMock, 3).has("if-none-match")).toBe(false);
-    expect(cache.size).toBe(3);
-  });
-
-  it.each([401, 403, 500])(
-    "does not use or repair cached data after HTTP %s",
-    async (status) => {
-      const fetchMock = vi
-        .fn()
-        .mockResolvedValueOnce(response(200, JSON.stringify(catalog), '"v1"'))
-        .mockResolvedValueOnce(response(status));
-      vi.stubGlobal("fetch", fetchMock);
-      await fetchReleaseCatalogWithCache(input());
-
-      await expect(fetchReleaseCatalogWithCache(input())).rejects.toThrow(
-        "Request failed",
-      );
-      expect(fetchMock).toHaveBeenCalledTimes(2);
-    },
-  );
-
-  it("reads a 404 the server marks x-hot-updater-catalog: none as no catalog", async () => {
-    const fetchMock = vi.fn().mockResolvedValueOnce(
-      new Response(null, {
-        headers: { "x-hot-updater-catalog": "none" },
-        status: 404,
-      }),
-    );
-    vi.stubGlobal("fetch", fetchMock);
-
-    await expect(fetchReleaseCatalogWithCache(input())).resolves.toBeNull();
-    expect(nativeMocks.write).not.toHaveBeenCalled();
-  });
-
-  it("throws the HTTP status of any other 404", async () => {
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValueOnce(response(404)));
-
-    await expect(fetchReleaseCatalogWithCache(input())).rejects.toMatchObject({
-      name: "UpdateHttpError",
-      status: 404,
-    });
-  });
-
-  it("does not use cached data as a fallback on network failure", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(response(200, JSON.stringify(catalog), '"v1"'))
-      .mockRejectedValueOnce(new Error("offline"));
-    vi.stubGlobal("fetch", fetchMock);
-    await fetchReleaseCatalogWithCache(input());
-
-    await expect(fetchReleaseCatalogWithCache(input())).rejects.toThrow(
-      "offline",
-    );
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("rejects and never persists a catalog with the wrong canonical scope", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(
-        response(
-          200,
-          JSON.stringify({ ...catalog, scopeKey: "wrong-scope" }),
-          '"wrong"',
-        ),
-      );
-    vi.stubGlobal("fetch", fetchMock);
-
-    await expect(fetchReleaseCatalogWithCache(input())).rejects.toThrow(
-      "invalid Release catalog",
-    );
-    expect(nativeMocks.write).not.toHaveBeenCalled();
-  });
-
-  it("rejects a catalog with no persisted identity", async () => {
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(
-        response(
-          200,
-          JSON.stringify({ ...catalog, catalogId: "" }),
-          '"missing-identity"',
-        ),
-      );
-    vi.stubGlobal("fetch", fetchMock);
-
-    await expect(fetchReleaseCatalogWithCache(input())).rejects.toThrow(
-      "invalid Release catalog",
-    );
-    expect(nativeMocks.write).not.toHaveBeenCalled();
-  });
-
-  it("accepts a legal compiled-boundary catalog plus its wire envelope", async () => {
-    const template = {
-      ...catalog,
-      releases: [{ ...catalog.releases[0]!, message: "" }],
-    };
-    const templateBody = JSON.stringify(template);
-    const padding = "x".repeat(
-      MAX_COMPILED_CATALOG_BYTES + 1 - templateBody.length,
-    );
-    const body = JSON.stringify({
-      ...template,
-      releases: [{ ...template.releases[0]!, message: padding }],
-    });
-    expect(body.length).toBe(MAX_COMPILED_CATALOG_BYTES + 1);
-    expect(body.length).toBeLessThanOrEqual(MAX_RELEASE_CATALOG_WIRE_BYTES);
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(response(200, body, '"boundary"'));
-    vi.stubGlobal("fetch", fetchMock);
-
-    await expect(fetchReleaseCatalogWithCache(input())).resolves.toEqual(
-      JSON.parse(body),
-    );
-
-    const persisted = nativeMocks.write.mock.calls[0]?.[1];
-    expect(persisted).toBeDefined();
-    expect(new TextEncoder().encode(persisted).byteLength).toBeLessThanOrEqual(
-      MAX_RELEASE_CATALOG_CACHE_ENTRY_BYTES,
-    );
-  });
-});

package/src/releaseCatalogCacheNativeContract.spec.ts

@@ -1,80 +0,0 @@
-import {
-  createReleaseCatalogScopeKey,
-  encodeChannelKey,
-  type ReleaseCatalog,
-} from "@hot-updater/core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const nativeModule = vi.hoisted(
-  () => ({}) as Record<string, ReturnType<typeof vi.fn>>,
-);
-
-vi.mock("./specs/NativeHotUpdater", () => ({ default: nativeModule }));
-
-import { fetchReleaseCatalogWithCache } from "./releaseCatalogCache";
-
-const catalogId = "project-a";
-const scopeKey = createReleaseCatalogScopeKey({
-  channelKey: encodeChannelKey("production"),
-  platform: "ios",
-  strategy: "APP_VERSION",
-});
-const input = {
-  baseURL: "https://updates.example.com",
-  expectedScope: {
-    channelKey: encodeChannelKey("production"),
-    platform: "ios",
-    strategy: "APP_VERSION",
-  } as const,
-  requestHeaders: { "x-api-key": "key" },
-  url: "https://updates.example.com/catalog",
-};
-const catalog: ReleaseCatalog = {
-  catalogId,
-  catalogHash: `sha256:${"a".repeat(64)}`,
-  fallbackPolicy: "BUILTIN_IF_ACTIVE_INELIGIBLE",
-  generation: 1,
-  releases: [],
-  schemaVersion: 1,
-  scopeKey,
-};
-
-describe("Release Catalog native cache contract", () => {
-  beforeEach(() => {
-    for (const key of Object.keys(nativeModule)) delete nativeModule[key];
-  });
-
-  it("fails before fetching when the v1 native cache API is missing", async () => {
-    const fetchMock = vi.fn();
-    vi.stubGlobal("fetch", fetchMock);
-
-    await expect(fetchReleaseCatalogWithCache(input)).rejects.toThrow(
-      "Native module is missing 'getReleaseCatalogCache()'. Rebuild the native app before using Release catalogs.",
-    );
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("uses the network when native cache I/O fails", async () => {
-    nativeModule.getReleaseCatalogCache = vi
-      .fn()
-      .mockRejectedValue(new Error("read"));
-    nativeModule.setReleaseCatalogCache = vi
-      .fn()
-      .mockRejectedValue(new Error("write"));
-    nativeModule.removeReleaseCatalogCache = vi
-      .fn()
-      .mockRejectedValue(new Error("remove"));
-    const fetchMock = vi.fn().mockResolvedValue(
-      new Response(JSON.stringify(catalog), {
-        headers: { ETag: '"v1"' },
-        status: 200,
-      }),
-    );
-    vi.stubGlobal("fetch", fetchMock);
-
-    await expect(fetchReleaseCatalogWithCache(input)).resolves.toEqual(catalog);
-    expect(fetchMock).toHaveBeenCalledOnce();
-    expect(nativeModule.getReleaseCatalogCache).toHaveBeenCalledOnce();
-    expect(nativeModule.setReleaseCatalogCache).toHaveBeenCalledOnce();
-  });
-});

package/src/store.notification.spec.ts

@@ -1,102 +0,0 @@
-// @vitest-environment jsdom
-
-import { cleanup, render } from "@testing-library/react";
-import { act, createElement, useLayoutEffect, useState } from "react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const listeners = vi.hoisted(
-  () => new Map<string, (event: Record<string, unknown>) => void>(),
-);
-
-vi.mock("./native", () => ({
-  addListener: vi.fn(
-    (eventName: string, listener: (event: Record<string, unknown>) => void) => {
-      listeners.set(eventName, listener);
-      return () => {
-        listeners.delete(eventName);
-      };
-    },
-  ),
-}));
-
-describe("hotUpdaterStore notification scheduling", () => {
-  beforeEach(() => {
-    listeners.clear();
-    vi.resetModules();
-  });
-
-  afterEach(() => {
-    cleanup();
-    vi.unstubAllGlobals();
-  });
-
-  it("keeps progress notifications from exceeding React's maximum update depth", async () => {
-    // Given
-    const frameCallbacks: ((timestamp: number) => void)[] = [];
-    vi.stubGlobal(
-      "requestAnimationFrame",
-      (callback: (timestamp: number) => void) => {
-        frameCallbacks.push(callback);
-        return frameCallbacks.length;
-      },
-    );
-    const { hotUpdaterStore } = await import("./store");
-    const emitProgress = listeners.get("onProgress");
-    const Consumer = () => {
-      const [progress, setProgress] = useState(0);
-
-      useLayoutEffect(() => {
-        const unsubscribe = hotUpdaterStore.subscribe(() => {
-          setProgress(hotUpdaterStore.getSnapshot().progress);
-        });
-        return () => {
-          unsubscribe();
-        };
-      }, []);
-
-      useLayoutEffect(() => {
-        if (progress >= 1) {
-          return;
-        }
-
-        const nextProgress = Math.min(1, progress + 0.01);
-        emitProgress?.({
-          artifactType: "diff",
-          details: {
-            completedFilesCount: nextProgress === 1 ? 1 : 0,
-            files: [
-              {
-                order: 0,
-                path: "index.ios.bundle",
-                progress: nextProgress,
-                status: nextProgress === 1 ? "downloaded" : "downloading",
-              },
-            ],
-            totalFilesCount: 1,
-          },
-          progress: nextProgress,
-        });
-      }, [progress]);
-
-      return null;
-    };
-
-    // When
-    render(createElement(Consumer));
-    for (
-      let frame = 0;
-      frame < 200 && hotUpdaterStore.getSnapshot().progress < 1;
-      frame++
-    ) {
-      const frameCallback = frameCallbacks.shift();
-      expect(frameCallback).toBeTypeOf("function");
-      await new Promise<void>((resolve) => setImmediate(resolve));
-      await act(async () => {
-        frameCallback?.(0);
-      });
-    }
-
-    // Then
-    expect(hotUpdaterStore.getSnapshot().progress).toBe(1);
-  });
-});

package/src/store.spec.ts

@@ -1,215 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const listeners = vi.hoisted(
-  () => new Map<string, (event: Record<string, unknown>) => void>(),
-);
-
-vi.mock("./native", () => ({
-  addListener: vi.fn(
-    (eventName: string, listener: (event: Record<string, unknown>) => void) => {
-      listeners.set(eventName, listener);
-      return () => {
-        listeners.delete(eventName);
-      };
-    },
-  ),
-}));
-
-const importStore = async () => {
-  const { hotUpdaterStore } = await import("./store");
-  return hotUpdaterStore;
-};
-
-describe("hotUpdaterStore", () => {
-  beforeEach(() => {
-    listeners.clear();
-    vi.resetModules();
-  });
-
-  it("does not notify subscribers when state values are unchanged", async () => {
-    const store = await importStore();
-    const listener = vi.fn();
-
-    const unsubscribe = store.subscribe(listener);
-
-    store.setState({});
-    store.setState({ progress: 0 });
-    store.setState({ isUpdateDownloaded: false });
-
-    expect(listener).not.toHaveBeenCalled();
-
-    unsubscribe();
-  });
-
-  it("stores manifest progress metadata while keeping overall progress", async () => {
-    const store = await importStore();
-    const emitProgress = listeners.get("onProgress");
-
-    expect(emitProgress).toBeTypeOf("function");
-
-    emitProgress?.({
-      artifactType: "diff",
-      details: {
-        completedFilesCount: 1,
-        files: [
-          {
-            downloadPath: "index.ios.bundle",
-            order: 0,
-            path: "index.ios.bundle",
-            progress: 1,
-            status: "downloaded",
-          },
-          {
-            downloadPath: "assets/logo.png",
-            order: 1,
-            path: "assets/logo.png",
-            progress: 0.5,
-            status: "downloading",
-          },
-        ],
-        totalFilesCount: 2,
-      },
-      progress: 0.42,
-    });
-
-    expect(store.getSnapshot()).toEqual({
-      artifactType: "diff",
-      details: {
-        completedFilesCount: 1,
-        files: [
-          {
-            downloadPath: "index.ios.bundle",
-            order: 0,
-            path: "index.ios.bundle",
-            progress: 1,
-            status: "downloaded",
-          },
-          {
-            downloadPath: "assets/logo.png",
-            order: 1,
-            path: "assets/logo.png",
-            progress: 0.5,
-            status: "downloading",
-          },
-        ],
-        totalFilesCount: 2,
-      },
-      isUpdateDownloaded: false,
-      progress: 0.42,
-    });
-  });
-
-  it("preserves patch download metadata for manifest diff files", async () => {
-    const store = await importStore();
-    const emitProgress = listeners.get("onProgress");
-
-    emitProgress?.({
-      artifactType: "diff",
-      details: {
-        completedFilesCount: 0,
-        files: [
-          {
-            downloadPath: "index.ios.bundle.bsdiff",
-            order: 0,
-            path: "index.ios.bundle",
-            progress: 0.4,
-            status: "downloading",
-          },
-        ],
-        totalFilesCount: 1,
-      },
-      progress: 0.32,
-    });
-
-    expect(store.getSnapshot().details?.files).toEqual([
-      {
-        downloadPath: "index.ios.bundle.bsdiff",
-        downloadedBytes: undefined,
-        order: 0,
-        path: "index.ios.bundle",
-        progress: 0.4,
-        status: "downloading",
-        totalBytes: undefined,
-      },
-    ]);
-  });
-
-  it("stores diff snapshot transitions from downloading to downloaded", async () => {
-    const store = await importStore();
-    const emitProgress = listeners.get("onProgress");
-
-    emitProgress?.({
-      artifactType: "diff",
-      details: {
-        completedFilesCount: 0,
-        files: [
-          {
-            order: 0,
-            path: "index.ios.bundle",
-            progress: 0.6,
-            status: "downloading",
-          },
-          {
-            order: 1,
-            path: "assets/logo.png",
-            progress: 0,
-            status: "pending",
-          },
-        ],
-        totalFilesCount: 2,
-      },
-      progress: 0.4,
-    });
-
-    emitProgress?.({
-      artifactType: "diff",
-      details: {
-        completedFilesCount: 1,
-        files: [
-          {
-            downloadPath: "index.ios.bundle",
-            order: 0,
-            path: "index.ios.bundle",
-            progress: 1,
-            status: "downloaded",
-          },
-          {
-            downloadPath: "assets/logo.png",
-            order: 1,
-            path: "assets/logo.png",
-            progress: 0,
-            status: "pending",
-          },
-        ],
-        totalFilesCount: 2,
-      },
-      progress: 0.6,
-    });
-
-    expect(store.getSnapshot()).toEqual({
-      artifactType: "diff",
-      details: {
-        completedFilesCount: 1,
-        files: [
-          {
-            downloadPath: "index.ios.bundle",
-            order: 0,
-            path: "index.ios.bundle",
-            progress: 1,
-            status: "downloaded",
-          },
-          {
-            downloadPath: "assets/logo.png",
-            order: 1,
-            path: "assets/logo.png",
-            progress: 0,
-            status: "pending",
-          },
-        ],
-        totalFilesCount: 2,
-      },
-      isUpdateDownloaded: false,
-      progress: 0.6,
-    });
-  });
-});