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

package/lib/commonjs/checkForUpdate.releaseCatalog.spec.js

@@ -1,936 +0,0 @@
-"use strict";
-
-var _core = require("@hot-updater/core");
-var _vitest = require("vitest");
-var _updateError = require("./updateError.js");
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-const MINIMUM_RELEASE_ID = "00000000-0000-7000-8000-000000000001";
-const RELEASE_ID = "00000000-0000-7000-8000-000000000002";
-const ACTIVE_RELEASE_ID = "00000000-0000-7000-8000-000000000003";
-const CURRENT_BUNDLE_ID = "00000000-0000-7001-8000-000000000001";
-const TARGET_BUNDLE_ID = "00000000-0000-7001-8000-000000000002";
-const CATALOG_ID = "project-a";
-const CHANNEL = "production";
-const CATALOG_HASH = `sha256:${"a".repeat(64)}`;
-const SCOPE_KEY = (0, _core.createReleaseCatalogScopeKey)({
-  channelKey: (0, _core.encodeChannelKey)(CHANNEL),
-  platform: "ios",
-  strategy: "APP_VERSION"
-});
-const mocks = _vitest.vi.hoisted(() => {
-  Reflect.set(globalThis, "HotUpdater", {
-    SDK_VERSION: "test-sdk-version"
-  });
-  return {
-    addListener: _vitest.vi.fn(() => () => {}),
-    acceptReleaseCatalog: _vitest.vi.fn(() => true),
-    commitReleaseSelection: _vitest.vi.fn(async () => true),
-    getActiveUpdateState: _vitest.vi.fn(() => ({
-      activeSelection: null,
-      highestSeenCatalogs: {},
-      stableSelection: null,
-      verificationPending: false
-    })),
-    getAppVersion: _vitest.vi.fn(() => "1.2"),
-    getBundleId: _vitest.vi.fn(() => CURRENT_BUNDLE_ID),
-    getChannel: _vitest.vi.fn(() => CHANNEL),
-    getCohort: _vitest.vi.fn(() => "123"),
-    getCrashHistory: _vitest.vi.fn(() => []),
-    getDefaultChannel: _vitest.vi.fn(() => CHANNEL),
-    getFingerprintHash: _vitest.vi.fn(() => null),
-    getInstallId: _vitest.vi.fn(() => "install-id"),
-    getMinBundleId: _vitest.vi.fn(() => MINIMUM_RELEASE_ID),
-    isChannelSwitched: _vitest.vi.fn(() => false),
-    isReleaseSelectionCurrent: _vitest.vi.fn(() => true),
-    resetChannel: _vitest.vi.fn(),
-    stageBundle: _vitest.vi.fn(async () => ({
-      delivery: "manifest",
-      patchFallback: false
-    }))
-  };
-});
-_vitest.vi.mock("react-native", () => ({
-  Platform: {
-    OS: "ios"
-  }
-}));
-_vitest.vi.mock("./native", () => mocks);
-const createCatalog = (overrides = {}) => ({
-  catalogId: CATALOG_ID,
-  catalogHash: CATALOG_HASH,
-  fallbackPolicy: "BUILTIN_IF_ACTIVE_INELIGIBLE",
-  generation: 2,
-  releases: [{
-    bundleId: TARGET_BUNDLE_ID,
-    kind: "BUNDLE",
-    message: "Release two",
-    releaseId: RELEASE_ID,
-    rolloutCohortCount: 1000,
-    shouldForceUpdate: false,
-    targetCohorts: []
-  }],
-  schemaVersion: 1,
-  scopeKey: SCOPE_KEY,
-  ...overrides
-});
-const createClient = (catalog = createCatalog()) => {
-  const fetchReleaseCatalog = _vitest.vi.fn(async () => catalog);
-  const artifact = {
-    artifactProtocolVersion: 1,
-    assets: {},
-    manifestFileHash: "manifest-hash",
-    manifestUrl: "https://updates.example.com/manifest.json",
-    archiveUrl: "https://updates.example.com/bundle.tar.br"
-  };
-  const resolveArtifact = _vitest.vi.fn(async () => artifact);
-  const session = {
-    fetchReleaseCatalog,
-    resolveArtifact
-  };
-  const client = {
-    createSession: _vitest.vi.fn(async () => session)
-  };
-  return {
-    client,
-    fetchReleaseCatalog,
-    resolveArtifact
-  };
-};
-/** Records what checks report to plugins, in order. */
-const recordPluginEvents = async () => {
-  const {
-    configurePlugins
-  } = await Promise.resolve().then(() => _interopRequireWildcard(require("./pluginHost")));
-  const events = [];
-  configurePlugins([{
-    id: "recorder",
-    setup: () => ({
-      onUpdateCheck: result => {
-        events.push(["onUpdateCheck", result]);
-      },
-      onBundleDownloaded: info => {
-        events.push(["onBundleDownloaded", info]);
-      },
-      onUpdateError: error => {
-        events.push(["onUpdateError", error]);
-      }
-    })
-  }], {
-    baseURL: "https://updates.example.com"
-  });
-  return events;
-};
-(0, _vitest.describe)("checkForUpdate Release catalog protocol", () => {
-  (0, _vitest.beforeEach)(() => {
-    _vitest.vi.resetModules();
-    _vitest.vi.clearAllMocks();
-    _vitest.vi.stubGlobal("__DEV__", false);
-    mocks.acceptReleaseCatalog.mockReturnValue(true);
-    mocks.getActiveUpdateState.mockReturnValue({
-      activeSelection: null,
-      highestSeenCatalogs: {},
-      stableSelection: null,
-      verificationPending: false
-    });
-    mocks.isReleaseSelectionCurrent.mockReturnValue(true);
-    mocks.commitReleaseSelection.mockResolvedValue(true);
-    mocks.stageBundle.mockResolvedValue({
-      delivery: "manifest",
-      patchFallback: false
-    });
-  });
-  (0, _vitest.it)("reports the check, then the download only after staging", async () => {
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const events = await recordPluginEvents();
-    const {
-      client
-    } = createClient();
-    let complete;
-    mocks.stageBundle.mockImplementationOnce(() => new Promise(resolve => {
-      complete = resolve;
-    }));
-    const update = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(update?.shouldForceUpdate).toBe(false);
-    (0, _vitest.expect)(events).toEqual([["onUpdateCheck", {
-      status: "UPDATE_AVAILABLE",
-      channel: CHANNEL,
-      fromBundleId: CURRENT_BUNDLE_ID,
-      fromReleaseId: null,
-      toBundleId: TARGET_BUNDLE_ID,
-      toReleaseId: RELEASE_ID,
-      transitionKind: "INSTALL",
-      updateStatus: "UPDATE",
-      shouldForceUpdate: false,
-      updateStrategy: "appVersion"
-    }]]);
-    const pending = update.updateBundle();
-    await _vitest.vi.waitFor(() => (0, _vitest.expect)(mocks.stageBundle).toHaveBeenCalledOnce());
-    (0, _vitest.expect)(events).toHaveLength(1);
-    complete({
-      delivery: "patch",
-      patchFallback: true
-    });
-    await (0, _vitest.expect)(pending).resolves.toBe(true);
-    (0, _vitest.expect)(events[1]).toEqual(["onBundleDownloaded", {
-      channel: CHANNEL,
-      fromBundleId: CURRENT_BUNDLE_ID,
-      fromReleaseId: null,
-      toBundleId: TARGET_BUNDLE_ID,
-      toReleaseId: RELEASE_ID,
-      updateStrategy: "appVersion",
-      delivery: "patch",
-      patchFallback: true
-    }]);
-  });
-  _vitest.it.each(["nothing new", "failure"])("does not report a download when staging brings %s", async result => {
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const events = await recordPluginEvents();
-    const {
-      client
-    } = createClient();
-    if (result === "nothing new") mocks.stageBundle.mockResolvedValueOnce(null);else mocks.stageBundle.mockRejectedValueOnce(new Error("download failed"));
-    const update = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    await update.updateBundle().catch(() => false);
-    (0, _vitest.expect)(events.map(([name]) => name)).not.toContain("onBundleDownloaded");
-  });
-  (0, _vitest.it)("selects locally and defers Bundle artifact resolution until install", async () => {
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client,
-      fetchReleaseCatalog,
-      resolveArtifact
-    } = createClient();
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(result).toMatchObject({
-      id: RELEASE_ID,
-      releaseId: RELEASE_ID,
-      transitionKind: "INSTALL"
-    });
-    (0, _vitest.expect)(fetchReleaseCatalog).toHaveBeenCalledWith({
-      appVersion: "1.2.0",
-      channel: CHANNEL,
-      fingerprintHash: null,
-      platform: "ios",
-      requestHeaders: undefined,
-      requestTimeout: undefined,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(resolveArtifact).not.toHaveBeenCalled();
-    await (0, _vitest.expect)(result?.updateBundle()).resolves.toBe(true);
-    (0, _vitest.expect)(resolveArtifact).toHaveBeenCalledWith({
-      currentBundleId: CURRENT_BUNDLE_ID,
-      requestHeaders: undefined,
-      requestTimeout: undefined,
-      targetBundleId: TARGET_BUNDLE_ID
-    });
-    (0, _vitest.expect)(mocks.stageBundle).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      bundleId: TARGET_BUNDLE_ID,
-      archiveUrl: "https://updates.example.com/bundle.tar.br",
-      selection: _vitest.expect.objectContaining({
-        catalogId: CATALOG_ID,
-        releaseId: RELEASE_ID,
-        scopeKey: SCOPE_KEY
-      })
-    }));
-  });
-  (0, _vitest.it)("adopts a newer Release for the same Bundle without resolving bytes", async () => {
-    const active = {
-      catalogId: CATALOG_ID,
-      bundleId: TARGET_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: MINIMUM_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context"
-    };
-    mocks.getBundleId.mockReturnValueOnce(TARGET_BUNDLE_ID);
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false
-    });
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const forceCatalog = createCatalog({
-      releases: [{
-        ...createCatalog().releases[0],
-        shouldForceUpdate: true
-      }]
-    });
-    const events = await recordPluginEvents();
-    const {
-      client,
-      resolveArtifact
-    } = createClient(forceCatalog);
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(result).toMatchObject({
-      id: RELEASE_ID,
-      shouldForceUpdate: false,
-      transitionKind: "ADOPT_RELEASE"
-    });
-    await (0, _vitest.expect)(result?.updateBundle()).resolves.toBe(true);
-    (0, _vitest.expect)(resolveArtifact).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.stageBundle).not.toHaveBeenCalled();
-    (0, _vitest.expect)(events.map(([name]) => name)).not.toContain("onBundleDownloaded");
-    (0, _vitest.expect)(mocks.commitReleaseSelection).toHaveBeenCalledWith({
-      guard: _vitest.expect.objectContaining({
-        generation: 2,
-        scopeKey: SCOPE_KEY
-      }),
-      selection: _vitest.expect.objectContaining({
-        bundleId: TARGET_BUNDLE_ID,
-        releaseId: RELEASE_ID
-      })
-    });
-  });
-  (0, _vitest.it)("reports a same-file adoption as UNCHANGED with the adopted Release", async () => {
-    const active = {
-      catalogId: CATALOG_ID,
-      bundleId: TARGET_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: MINIMUM_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context"
-    };
-    mocks.getBundleId.mockReturnValueOnce(TARGET_BUNDLE_ID);
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false
-    });
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const events = await recordPluginEvents();
-    const {
-      client
-    } = createClient();
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    await result?.updateBundle();
-    (0, _vitest.expect)(events.at(-1)).toEqual(["onUpdateCheck", {
-      status: "UNCHANGED",
-      channel: CHANNEL,
-      bundleId: TARGET_BUNDLE_ID,
-      releaseId: RELEASE_ID,
-      previousReleaseId: MINIMUM_RELEASE_ID
-    }]);
-  });
-  (0, _vitest.it)("selects a lower-id Release when explicitly switching scopes", async () => {
-    const betaChannel = "beta";
-    const betaScopeKey = (0, _core.createReleaseCatalogScopeKey)({
-      channelKey: (0, _core.encodeChannelKey)(betaChannel),
-      platform: "ios",
-      strategy: "APP_VERSION"
-    });
-    const active = {
-      catalogId: CATALOG_ID,
-      bundleId: CURRENT_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: ACTIVE_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context"
-    };
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false
-    });
-    const betaCatalog = createCatalog({
-      scopeKey: betaScopeKey
-    });
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client
-    } = createClient(betaCatalog);
-    const result = await checkForUpdate({
-      channel: betaChannel,
-      client,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(result).toMatchObject({
-      id: RELEASE_ID,
-      releaseId: RELEASE_ID,
-      status: "UPDATE",
-      transitionKind: "INSTALL"
-    });
-  });
-  (0, _vitest.it)("refreshes the same Release receipt when catalog provenance changes", async () => {
-    const active = {
-      catalogId: CATALOG_ID,
-      bundleId: TARGET_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context"
-    };
-    mocks.getBundleId.mockReturnValueOnce(TARGET_BUNDLE_ID);
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false
-    });
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client,
-      resolveArtifact
-    } = createClient();
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(result).toMatchObject({
-      id: RELEASE_ID,
-      releaseId: RELEASE_ID,
-      transitionKind: "ADOPT_RELEASE"
-    });
-    await (0, _vitest.expect)(result?.updateBundle()).resolves.toBe(true);
-    (0, _vitest.expect)(resolveArtifact).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.stageBundle).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.commitReleaseSelection).toHaveBeenCalledWith({
-      guard: _vitest.expect.objectContaining({
-        catalogHash: CATALOG_HASH,
-        generation: 2,
-        scopeKey: SCOPE_KEY
-      }),
-      selection: _vitest.expect.objectContaining({
-        bundleId: TARGET_BUNDLE_ID,
-        catalogHash: CATALOG_HASH,
-        generation: 2,
-        releaseId: RELEASE_ID
-      })
-    });
-  });
-  (0, _vitest.it)("rejects a slow artifact completion after a newer catalog wins", async () => {
-    mocks.isReleaseSelectionCurrent.mockReturnValueOnce(true).mockReturnValueOnce(false);
-    const {
-      StaleReleaseCatalogError
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./error")));
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client
-    } = createClient();
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    await (0, _vitest.expect)(result?.updateBundle()).rejects.toBeInstanceOf(StaleReleaseCatalogError);
-    (0, _vitest.expect)(mocks.stageBundle).not.toHaveBeenCalled();
-  });
-  (0, _vitest.it)("installs an older enabled Release as a forced rollback", async () => {
-    const active = {
-      catalogId: CATALOG_ID,
-      bundleId: CURRENT_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: ACTIVE_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context"
-    };
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false
-    });
-    const catalog = createCatalog({
-      rollbackReleases: [{
-        bundleId: TARGET_BUNDLE_ID,
-        kind: "BUNDLE",
-        message: "Previous Release",
-        releaseId: RELEASE_ID,
-        rolloutCohortCount: 0,
-        shouldForceUpdate: false,
-        targetCohorts: []
-      }]
-    });
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client
-    } = createClient(catalog);
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(result).toMatchObject({
-      id: RELEASE_ID,
-      releaseId: RELEASE_ID,
-      shouldForceUpdate: true,
-      status: "ROLLBACK",
-      transitionKind: "INSTALL"
-    });
-    await (0, _vitest.expect)(result?.updateBundle()).resolves.toBe(true);
-    (0, _vitest.expect)(mocks.stageBundle).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      bundleId: TARGET_BUNDLE_ID,
-      status: "ROLLBACK"
-    }));
-  });
-  (0, _vitest.it)("uses current Bundle identity when migrating an unauthenticated receipt", async () => {
-    const migratedCurrentBundleId = "00000000-0000-7001-8000-000000000003";
-    const active = {
-      catalogId: null,
-      bundleId: migratedCurrentBundleId,
-      catalogHash: null,
-      channel: CHANNEL,
-      generation: null,
-      kind: "BUNDLE",
-      releaseId: null,
-      scopeKey: null,
-      selectionContextHash: null
-    };
-    mocks.getBundleId.mockReturnValueOnce(migratedCurrentBundleId);
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false
-    });
-    const catalog = createCatalog({
-      releases: [],
-      rollbackReleases: [{
-        ...createCatalog().releases[0],
-        rolloutCohortCount: 0
-      }]
-    });
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client
-    } = createClient(catalog);
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(result).toMatchObject({
-      id: RELEASE_ID,
-      shouldForceUpdate: true,
-      status: "ROLLBACK",
-      transitionKind: "INSTALL"
-    });
-  });
-  _vitest.it.each(["EMBEDDED", "BUILTIN"])("returns a forced %s rollback with its console ID or built-in fallback", async kind => {
-    const active = {
-      catalogId: CATALOG_ID,
-      bundleId: CURRENT_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: MINIMUM_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context"
-    };
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false
-    });
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client,
-      resolveArtifact
-    } = createClient(createCatalog({
-      releases: kind === "EMBEDDED" ? [{
-        ...createCatalog().releases[0],
-        kind,
-        bundleId: null
-      }] : [],
-      rollbackReleases: []
-    }));
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    (0, _vitest.expect)(result).toMatchObject({
-      id: kind === "EMBEDDED" ? RELEASE_ID : MINIMUM_RELEASE_ID,
-      releaseId: kind === "EMBEDDED" ? RELEASE_ID : null,
-      shouldForceUpdate: true,
-      status: "ROLLBACK",
-      transitionKind: kind === "EMBEDDED" ? "USE_EMBEDDED" : "USE_BUILTIN"
-    });
-    await (0, _vitest.expect)(result?.updateBundle()).resolves.toBe(true);
-    (0, _vitest.expect)(mocks.commitReleaseSelection).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      selection: _vitest.expect.objectContaining({
-        bundleId: MINIMUM_RELEASE_ID,
-        kind,
-        releaseId: kind === "EMBEDDED" ? RELEASE_ID : null
-      })
-    }));
-    (0, _vitest.expect)(resolveArtifact).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.stageBundle).not.toHaveBeenCalled();
-  });
-  (0, _vitest.it)("does not surface a rollback when the app already uses built-in bytes", async () => {
-    mocks.getBundleId.mockReturnValueOnce(MINIMUM_RELEASE_ID);
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client
-    } = createClient(createCatalog({
-      releases: [],
-      rollbackReleases: []
-    }));
-    await (0, _vitest.expect)(checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    })).resolves.toBeNull();
-    (0, _vitest.expect)(mocks.commitReleaseSelection).not.toHaveBeenCalled();
-  });
-  (0, _vitest.it)("reports a rejected generation without selecting or resolving artifacts", async () => {
-    mocks.acceptReleaseCatalog.mockReturnValueOnce(false);
-    const onError = _vitest.vi.fn();
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client,
-      resolveArtifact
-    } = createClient();
-    await (0, _vitest.expect)(checkForUpdate({
-      client,
-      onError,
-      updateStrategy: "appVersion"
-    })).resolves.toBeNull();
-    (0, _vitest.expect)(onError).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      message: "Rejected a stale or inconsistent Release catalog"
-    }));
-    (0, _vitest.expect)(resolveArtifact).not.toHaveBeenCalled();
-  });
-  (0, _vitest.it)("rejects mismatched catalog scope before native catalog state mutates", async () => {
-    const wrongScope = (0, _core.createReleaseCatalogScopeKey)({
-      channelKey: (0, _core.encodeChannelKey)("beta"),
-      platform: "ios",
-      strategy: "APP_VERSION"
-    });
-    const onError = _vitest.vi.fn();
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client
-    } = createClient(createCatalog({
-      scopeKey: wrongScope
-    }));
-    await (0, _vitest.expect)(checkForUpdate({
-      client,
-      onError,
-      updateStrategy: "appVersion"
-    })).resolves.toBeNull();
-    (0, _vitest.expect)(onError).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      message: "Received an invalid Release catalog"
-    }));
-    (0, _vitest.expect)(mocks.acceptReleaseCatalog).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.commitReleaseSelection).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.stageBundle).not.toHaveBeenCalled();
-  });
-  (0, _vitest.it)("rejects an unexpected Catalog identity before accepting catalog state", async () => {
-    const active = {
-      catalogId: "existing-project",
-      bundleId: CURRENT_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: ACTIVE_RELEASE_ID,
-      scopeKey: (0, _core.createReleaseCatalogScopeKey)({
-        channelKey: (0, _core.encodeChannelKey)(CHANNEL),
-        platform: "ios",
-        strategy: "APP_VERSION"
-      }),
-      selectionContextHash: "old-context"
-    };
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false
-    });
-    const onError = _vitest.vi.fn();
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const {
-      client
-    } = createClient();
-    await (0, _vitest.expect)(checkForUpdate({
-      client,
-      onError,
-      updateStrategy: "appVersion"
-    })).resolves.toBeNull();
-    (0, _vitest.expect)(onError).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      message: "Release transition rejected: UNSOLICITED_SCOPE"
-    }));
-    (0, _vitest.expect)(mocks.acceptReleaseCatalog).not.toHaveBeenCalled();
-  });
-  (0, _vitest.it)("reports a check that found nothing to install as UNCHANGED", async () => {
-    mocks.getBundleId.mockReturnValueOnce(MINIMUM_RELEASE_ID);
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const events = await recordPluginEvents();
-    const {
-      client
-    } = createClient(createCatalog({
-      releases: [],
-      rollbackReleases: []
-    }));
-    await (0, _vitest.expect)(checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    })).resolves.toBeNull();
-    (0, _vitest.expect)(events).toEqual([["onUpdateCheck", {
-      status: "UNCHANGED",
-      channel: CHANNEL,
-      bundleId: MINIMUM_RELEASE_ID,
-      releaseId: null,
-      previousReleaseId: null
-    }]]);
-  });
-  (0, _vitest.it)("treats a scope without a catalog as no update, not a failure", async () => {
-    const onError = _vitest.vi.fn();
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const events = await recordPluginEvents();
-    const {
-      client,
-      fetchReleaseCatalog
-    } = createClient();
-    fetchReleaseCatalog.mockResolvedValueOnce(null);
-    await (0, _vitest.expect)(checkForUpdate({
-      client,
-      onError,
-      updateStrategy: "appVersion"
-    })).resolves.toBeNull();
-    (0, _vitest.expect)(onError).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.acceptReleaseCatalog).not.toHaveBeenCalled();
-    (0, _vitest.expect)(events).toEqual([["onUpdateCheck", _vitest.expect.objectContaining({
-      status: "UNCHANGED",
-      channel: CHANNEL
-    })]]);
-  });
-  _vitest.it.each([{
-    label: "an HTTP status",
-    error: () => new _updateError.UpdateHttpError(503, "Service Unavailable"),
-    expected: {
-      reason: "http",
-      httpStatus: 503
-    }
-  }, {
-    label: "no response",
-    error: () => new TypeError("Network request failed"),
-    expected: {
-      reason: "network"
-    }
-  }, {
-    label: "a 404 without the no-catalog mark",
-    error: () => new _updateError.UpdateHttpError(404, "Not Found"),
-    expected: {
-      reason: "http",
-      httpStatus: 404
-    }
-  }, {
-    label: "a timeout",
-    error: () => new Error("Request timed out"),
-    expected: {
-      reason: "network",
-      transport: "timeout"
-    }
-  }, {
-    label: "an invalid catalog",
-    error: () => new _updateError.InvalidUpdateResponseError("Received an invalid Release catalog"),
-    expected: {
-      reason: "invalid_response"
-    }
-  }])("reports a check failed by $label", async ({
-    error,
-    expected
-  }) => {
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const events = await recordPluginEvents();
-    const {
-      client,
-      fetchReleaseCatalog
-    } = createClient();
-    const cause = error();
-    fetchReleaseCatalog.mockRejectedValueOnce(cause);
-    await (0, _vitest.expect)(checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    })).resolves.toBeNull();
-    (0, _vitest.expect)(events).toEqual([["onUpdateError", {
-      stage: "check",
-      resource: "catalog",
-      ...expected,
-      channel: CHANNEL,
-      bundleId: CURRENT_BUNDLE_ID,
-      releaseId: null,
-      updateStrategy: "appVersion",
-      cause
-    }]]);
-  });
-  _vitest.it.each([{
-    label: "an artifact request answered 500",
-    fail: resolveArtifact => resolveArtifact.mockRejectedValueOnce(new _updateError.UpdateHttpError(500, "Internal Server Error")),
-    expected: {
-      stage: "download",
-      reason: "http",
-      resource: "artifact",
-      httpStatus: 500
-    }
-  }, {
-    label: "native extraction",
-    fail: () => mocks.stageBundle.mockRejectedValueOnce(Object.assign(new Error("Failed to extract archive"), {
-      code: "UNKNOWN_ERROR",
-      userInfo: {
-        reason: "extract",
-        stage: "install"
-      }
-    })),
-    expected: {
-      stage: "install",
-      reason: "extract"
-    }
-  }, {
-    label: "a native HTTP status",
-    fail: () => mocks.stageBundle.mockRejectedValueOnce(Object.assign(new Error("Failed to download bundle"), {
-      code: "DOWNLOAD_FAILED",
-      userInfo: {
-        httpStatus: 403,
-        originCode: "ExpiredToken",
-        reason: "http",
-        resource: "archive",
-        stage: "download"
-      }
-    })),
-    expected: {
-      stage: "download",
-      reason: "http",
-      resource: "archive",
-      httpStatus: 403,
-      originCode: "ExpiredToken"
-    }
-  }, {
-    label: "a native connection loss",
-    fail: () => mocks.stageBundle.mockRejectedValueOnce(Object.assign(new Error("The network connection was lost."), {
-      code: "DOWNLOAD_FAILED",
-      userInfo: {
-        reason: "network",
-        resource: "file",
-        stage: "download",
-        transport: "connection"
-      }
-    })),
-    expected: {
-      stage: "download",
-      reason: "network",
-      resource: "file",
-      transport: "connection"
-    }
-  }])("reports an install failed by $label and rethrows it", async ({
-    fail,
-    expected
-  }) => {
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const events = await recordPluginEvents();
-    const {
-      client,
-      resolveArtifact
-    } = createClient();
-    fail(resolveArtifact);
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    await (0, _vitest.expect)(result.updateBundle()).rejects.toThrow();
-    (0, _vitest.expect)(events.filter(([name]) => name === "onUpdateError")).toEqual([["onUpdateError", _vitest.expect.objectContaining({
-      ...expected,
-      channel: CHANNEL,
-      bundleId: CURRENT_BUNDLE_ID,
-      targetBundleId: TARGET_BUNDLE_ID,
-      targetReleaseId: RELEASE_ID,
-      updateStrategy: "appVersion"
-    })]]);
-  });
-  _vitest.it.each([{
-    label: "a native rejection without a failure class",
-    fail: () => mocks.stageBundle.mockRejectedValueOnce(Object.assign(new Error("Release catalog selection is stale"), {
-      code: "UNKNOWN_ERROR"
-    }))
-  }, {
-    label: "a selection that became stale",
-    fail: () => mocks.isReleaseSelectionCurrent.mockReturnValueOnce(false)
-  }])("does not report $label as an update failure", async ({
-    fail
-  }) => {
-    const {
-      checkForUpdate
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
-    const events = await recordPluginEvents();
-    const {
-      client
-    } = createClient();
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion"
-    });
-    fail();
-    await (0, _vitest.expect)(result.updateBundle()).rejects.toThrow();
-    (0, _vitest.expect)(events.map(([name]) => name)).toEqual(["onUpdateCheck"]);
-  });
-});
-//# sourceMappingURL=checkForUpdate.releaseCatalog.spec.js.map