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

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

@@ -2,6 +2,7 @@
 
 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";
@@ -16,31 +17,38 @@ const SCOPE_KEY = (0, _core.createReleaseCatalogScopeKey)({
   platform: "ios",
   strategy: "APP_VERSION"
 });
-const mocks = _vitest.vi.hoisted(() => ({
-  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),
-  getPersistedUserIdentity: _vitest.vi.fn(() => ({})),
-  isChannelSwitched: _vitest.vi.fn(() => false),
-  isReleaseSelectionCurrent: _vitest.vi.fn(() => true),
-  resetChannel: _vitest.vi.fn(),
-  updateBundle: _vitest.vi.fn(async () => true)
-}));
+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"
@@ -75,11 +83,9 @@ const createClient = (catalog = createCatalog()) => {
     archiveUrl: "https://updates.example.com/bundle.tar.br"
   };
   const resolveArtifact = _vitest.vi.fn(async () => artifact);
-  const sendInsightsEvent = _vitest.vi.fn(async () => undefined);
   const session = {
     fetchReleaseCatalog,
-    resolveArtifact,
-    sendInsightsEvent
+    resolveArtifact
   };
   const client = {
     createSession: _vitest.vi.fn(async () => session)
@@ -87,10 +93,33 @@ const createClient = (catalog = createCatalog()) => {
   return {
     client,
     fetchReleaseCatalog,
-    resolveArtifact,
-    sendInsightsEvent
+    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();
@@ -105,58 +134,74 @@ const createClient = (catalog = createCatalog()) => {
     });
     mocks.isReleaseSelectionCurrent.mockReturnValue(true);
     mocks.commitReleaseSelection.mockResolvedValue(true);
-    mocks.updateBundle.mockResolvedValue(true);
+    mocks.stageBundle.mockResolvedValue({
+      delivery: "manifest",
+      patchFallback: false
+    });
   });
-  (0, _vitest.it)("reports an optional download only after staging, without treating the target as running", async () => {
+  (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,
-      sendInsightsEvent
+      client
     } = createClient();
     let complete;
-    mocks.updateBundle.mockImplementationOnce(() => new Promise(resolve => {
+    mocks.stageBundle.mockImplementationOnce(() => new Promise(resolve => {
       complete = resolve;
     }));
     const update = await checkForUpdate({
       client,
-      insights: true,
       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.updateBundle).toHaveBeenCalledOnce());
-    (0, _vitest.expect)(sendInsightsEvent).not.toHaveBeenCalled();
-    complete(true);
+    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)(sendInsightsEvent).toHaveBeenCalledExactlyOnceWith(_vitest.expect.objectContaining({
-      type: "UPDATE_DOWNLOADED",
+    (0, _vitest.expect)(events[1]).toEqual(["onBundleDownloaded", {
+      channel: CHANNEL,
       fromBundleId: CURRENT_BUNDLE_ID,
-      toBundleId: TARGET_BUNDLE_ID,
       fromReleaseId: null,
+      toBundleId: TARGET_BUNDLE_ID,
       toReleaseId: RELEASE_ID,
-      updateStrategy: "appVersion"
-    }));
-    await update.updateBundle();
-    (0, _vitest.expect)(sendInsightsEvent).toHaveBeenCalledOnce();
+      updateStrategy: "appVersion",
+      delivery: "patch",
+      patchFallback: true
+    }]);
   });
-  _vitest.it.each([false, "failure"])("does not report a download when staging returns %s", async result => {
+  _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,
-      sendInsightsEvent
+      client
     } = createClient();
-    if (result === false) mocks.updateBundle.mockResolvedValueOnce(false);else mocks.updateBundle.mockRejectedValueOnce(new Error("download failed"));
+    if (result === "nothing new") mocks.stageBundle.mockResolvedValueOnce(null);else mocks.stageBundle.mockRejectedValueOnce(new Error("download failed"));
     const update = await checkForUpdate({
       client,
-      insights: true,
       updateStrategy: "appVersion"
     });
     await update.updateBundle().catch(() => false);
-    (0, _vitest.expect)(sendInsightsEvent).not.toHaveBeenCalled();
+    (0, _vitest.expect)(events.map(([name]) => name)).not.toContain("onBundleDownloaded");
   });
   (0, _vitest.it)("selects locally and defers Bundle artifact resolution until install", async () => {
     const {
@@ -193,7 +238,7 @@ const createClient = (catalog = createCatalog()) => {
       requestTimeout: undefined,
       targetBundleId: TARGET_BUNDLE_ID
     });
-    (0, _vitest.expect)(mocks.updateBundle).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+    (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({
@@ -231,10 +276,10 @@ const createClient = (catalog = createCatalog()) => {
         shouldForceUpdate: true
       }]
     });
+    const events = await recordPluginEvents();
     const {
       client,
-      resolveArtifact,
-      sendInsightsEvent
+      resolveArtifact
     } = createClient(forceCatalog);
     const result = await checkForUpdate({
       client,
@@ -247,8 +292,8 @@ const createClient = (catalog = createCatalog()) => {
     });
     await (0, _vitest.expect)(result?.updateBundle()).resolves.toBe(true);
     (0, _vitest.expect)(resolveArtifact).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.updateBundle).not.toHaveBeenCalled();
-    (0, _vitest.expect)(sendInsightsEvent).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,
@@ -260,7 +305,7 @@ const createClient = (catalog = createCatalog()) => {
       })
     });
   });
-  (0, _vitest.it)("reports same-file selection as UNCHANGED with the selected release identity", async () => {
+  (0, _vitest.it)("reports a same-file adoption as UNCHANGED with the adopted Release", async () => {
     const active = {
       catalogId: CATALOG_ID,
       bundleId: TARGET_BUNDLE_ID,
@@ -282,24 +327,22 @@ const createClient = (catalog = createCatalog()) => {
     const {
       checkForUpdate
     } = await Promise.resolve().then(() => _interopRequireWildcard(require("./checkForUpdate")));
+    const events = await recordPluginEvents();
     const {
-      client,
-      sendInsightsEvent
+      client
     } = createClient();
     const result = await checkForUpdate({
-      insights: true,
       client,
       updateStrategy: "appVersion"
     });
     await result?.updateBundle();
-    (0, _vitest.expect)(sendInsightsEvent).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-      fromBundleId: null,
-      updateStrategy: null,
-      fromReleaseId: MINIMUM_RELEASE_ID,
-      toBundleId: TARGET_BUNDLE_ID,
-      toReleaseId: RELEASE_ID,
-      type: "UNCHANGED"
-    }));
+    (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";
@@ -383,7 +426,7 @@ const createClient = (catalog = createCatalog()) => {
     });
     await (0, _vitest.expect)(result?.updateBundle()).resolves.toBe(true);
     (0, _vitest.expect)(resolveArtifact).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.updateBundle).not.toHaveBeenCalled();
+    (0, _vitest.expect)(mocks.stageBundle).not.toHaveBeenCalled();
     (0, _vitest.expect)(mocks.commitReleaseSelection).toHaveBeenCalledWith({
       guard: _vitest.expect.objectContaining({
         catalogHash: CATALOG_HASH,
@@ -414,7 +457,7 @@ const createClient = (catalog = createCatalog()) => {
       updateStrategy: "appVersion"
     });
     await (0, _vitest.expect)(result?.updateBundle()).rejects.toBeInstanceOf(StaleReleaseCatalogError);
-    (0, _vitest.expect)(mocks.updateBundle).not.toHaveBeenCalled();
+    (0, _vitest.expect)(mocks.stageBundle).not.toHaveBeenCalled();
   });
   (0, _vitest.it)("installs an older enabled Release as a forced rollback", async () => {
     const active = {
@@ -463,7 +506,7 @@ const createClient = (catalog = createCatalog()) => {
       transitionKind: "INSTALL"
     });
     await (0, _vitest.expect)(result?.updateBundle()).resolves.toBe(true);
-    (0, _vitest.expect)(mocks.updateBundle).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+    (0, _vitest.expect)(mocks.stageBundle).toHaveBeenCalledWith(_vitest.expect.objectContaining({
       bundleId: TARGET_BUNDLE_ID,
       status: "ROLLBACK"
     }));
@@ -564,7 +607,7 @@ const createClient = (catalog = createCatalog()) => {
       })
     }));
     (0, _vitest.expect)(resolveArtifact).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.updateBundle).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);
@@ -628,7 +671,7 @@ const createClient = (catalog = createCatalog()) => {
     }));
     (0, _vitest.expect)(mocks.acceptReleaseCatalog).not.toHaveBeenCalled();
     (0, _vitest.expect)(mocks.commitReleaseSelection).not.toHaveBeenCalled();
-    (0, _vitest.expect)(mocks.updateBundle).not.toHaveBeenCalled();
+    (0, _vitest.expect)(mocks.stageBundle).not.toHaveBeenCalled();
   });
   (0, _vitest.it)("rejects an unexpected Catalog identity before accepting catalog state", async () => {
     const active = {
@@ -669,5 +712,225 @@ const createClient = (catalog = createCatalog()) => {
     }));
     (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