@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/src/db/updateArtifacts.spec.ts

@@ -1,359 +1,235 @@
 import { NIL_UUID, type Bundle } from "@hot-updater/core";
-import { createDatabaseClient } from "@hot-updater/plugin-core";
+import { createMemoryAdapter } from "@hot-updater/plugin-core/internal";
 import { describe, expect, it, vi } from "vitest";
 
-import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
-import { createArtifactResolver } from "./releaseCatalog";
+import { createCoreApi } from "../core/api";
+import { coreModule } from "../core/schema";
+import { createDatabaseEngine } from "../database/database";
+import { resolveSchema } from "../database/resolveSchema";
 import { resolveManifestArtifacts } from "./updateArtifacts";
 
-type TestManifestAsset = {
-  downloadByteSize?: unknown;
-  downloadFileHash?: unknown;
-  fileHash: string;
-};
-
-const CURRENT_BUNDLE_ID = "00000000-0000-0000-0000-000000000101";
-const TARGET_BUNDLE_ID = "00000000-0000-0000-0000-000000000102";
-const CURRENT_MANIFEST_URI = `s3://test-bucket/bundles/${CURRENT_BUNDLE_ID}/manifest.json`;
-const TARGET_MANIFEST_URI = `s3://test-bucket/bundles/${TARGET_BUNDLE_ID}/manifest.json`;
-const PATCH_STORAGE_URI = `s3://test-bucket/bundles/${TARGET_BUNDLE_ID}/patches/${CURRENT_BUNDLE_ID}/patch.bsdiff`;
-const VALID_DOWNLOAD_FILE_HASH = "a".repeat(64);
+const CURRENT_ID = "00000000-0000-0000-0000-000000000101";
+const TARGET_ID = "00000000-0000-0000-0000-000000000102";
+const CURRENT_MANIFEST_URI = `s3://bucket/bundles/${CURRENT_ID}/manifest.json`;
+const TARGET_MANIFEST_URI = `s3://bucket/bundles/${TARGET_ID}/manifest.json`;
+const PATCH_URI = `s3://bucket/bundles/${TARGET_ID}/patch.bsdiff`;
 
-const getUtf8ByteSize = (value: string) =>
-  new TextEncoder().encode(value).byteLength;
-
-const createBundle = (
-  id: string,
-  archiveByteSize: number,
-  overrides: Partial<Bundle> = {},
-): Bundle => ({
-  archiveByteSize,
-  assetBaseStorageUri: "s3://test-bucket/assets",
-  fileHash: `${id}-archive-hash`,
-  gitCommitHash: null,
+const createBundle = (id: string, overrides: Partial<Bundle> = {}): Bundle => ({
   id,
-  manifestFileHash: `${id}-manifest-hash`,
-  manifestStorageUri:
-    id === CURRENT_BUNDLE_ID ? CURRENT_MANIFEST_URI : TARGET_MANIFEST_URI,
   platform: "ios",
-  storageUri: `s3://test-bucket/bundles/${id}/bundle.zip`,
+  gitCommitHash: null,
+  manifestStorageUri:
+    id === CURRENT_ID ? CURRENT_MANIFEST_URI : TARGET_MANIFEST_URI,
+  manifestFileHash: `manifest-hash-${id}`,
+  assetBaseStorageUri: "s3://bucket/assets",
   ...overrides,
 });
 
-async function runScenario({
-  archiveByteSize,
-  archiveUrlUsable = true,
-  assetPath = "index.ios.bundle",
+const runScenario = async ({
+  currentHash = "current-hash",
   patchByteSize,
+  targetHash = "target-hash",
+  targetDownloadByteSize = 10,
   resolveUrl,
-  targetAsset,
-  targetManifestSuffix = "",
+  archive,
 }: {
-  archiveByteSize: number | ((manifestByteSize: number) => number);
-  archiveUrlUsable?: boolean;
-  assetPath?: string;
-  patchByteSize?: unknown;
-  resolveUrl?: (storageUri: string) => Promise<string | null>;
-  targetAsset: TestManifestAsset;
-  targetManifestSuffix?: string;
-}) {
-  const currentManifestText = JSON.stringify({
-    assets: {
-      [assetPath]: {
-        fileHash: "current-file-hash",
-      },
-    },
-    bundleId: CURRENT_BUNDLE_ID,
-  });
-  const targetManifestText = `${JSON.stringify({
-    assets: {
-      [assetPath]: targetAsset,
-    },
-    bundleId: TARGET_BUNDLE_ID,
-  })}${targetManifestSuffix}`;
-  const manifestByteSize = getUtf8ByteSize(targetManifestText);
-  const resolvedArchiveByteSize =
-    typeof archiveByteSize === "function"
-      ? archiveByteSize(manifestByteSize)
-      : archiveByteSize;
-  const hasPatch = patchByteSize !== undefined;
-  const currentBundle = createBundle(CURRENT_BUNDLE_ID, 1_024);
-  const targetBundle = createBundle(
-    TARGET_BUNDLE_ID,
-    resolvedArchiveByteSize,
-    hasPatch
-      ? {
-          patches: [
+  currentHash?: string;
+  patchByteSize?: number;
+  targetHash?: string;
+  targetDownloadByteSize?: number;
+  resolveUrl?: (storageUri: string) => string | null;
+  archive?: unknown;
+} = {}) => {
+  const currentBundle = createBundle(CURRENT_ID);
+  const targetBundle = createBundle(TARGET_ID, {
+    patches:
+      patchByteSize === undefined
+        ? []
+        : [
             {
-              baseBundleId: CURRENT_BUNDLE_ID,
-              baseFileHash: "current-file-hash",
-              byteSize: patchByteSize as number,
-              patchFileHash: "patch-file-hash",
-              patchStorageUri: PATCH_STORAGE_URI,
+              baseBundleId: CURRENT_ID,
+              baseFileHash: currentHash,
+              byteSize: patchByteSize,
+              patchFileHash: "patch-hash",
+              patchStorageUri: PATCH_URI,
             },
           ],
-        }
-      : {},
-  );
-  const storageTexts = new Map([
-    [CURRENT_MANIFEST_URI, currentManifestText],
-    [TARGET_MANIFEST_URI, targetManifestText],
-  ]);
-  const resolveFileUrl = vi.fn(async (storageUri: string | null) => {
-    if (!storageUri) return null;
-    if (resolveUrl) return resolveUrl(storageUri);
-    return `https://download.example.com/${encodeURIComponent(storageUri)}`;
   });
-
+  const manifests = new Map([
+    [
+      CURRENT_MANIFEST_URI,
+      JSON.stringify({
+        bundleId: CURRENT_ID,
+        assets: { "index.ios.bundle": { fileHash: currentHash } },
+      }),
+    ],
+    [
+      TARGET_MANIFEST_URI,
+      JSON.stringify({
+        bundleId: TARGET_ID,
+        ...(archive === undefined ? {} : { archive }),
+        assets: {
+          "index.ios.bundle": {
+            downloadByteSize: targetDownloadByteSize,
+            downloadFileHash: "a".repeat(64),
+            fileHash: targetHash,
+          },
+        },
+      }),
+    ],
+  ]);
+  const resolveFileUrl = vi.fn(async (storageUri: string | null) =>
+    storageUri
+      ? resolveUrl
+        ? resolveUrl(storageUri)
+        : `https://download.test/${encodeURIComponent(storageUri)}`
+      : null,
+  );
   const result = await resolveManifestArtifacts({
-    archiveUrlUsable,
     currentBundle,
-    readStorageText: async (storageUri) => storageTexts.get(storageUri) ?? null,
+    readStorageText: async (uri) => manifests.get(uri) ?? null,
     resolveFileUrl,
     targetBundle,
   });
-
-  return {
-    manifestByteSize,
-    resolveFileUrl,
-    result,
-  };
-}
+  return { resolveFileUrl, result };
+};
 
 describe("resolveManifestArtifacts", () => {
-  it("uses raw UTF-8 manifest bytes and selects archive at equal size", async () => {
-    const { resolveFileUrl, result } = await runScenario({
-      archiveByteSize: (manifestByteSize) => manifestByteSize + 7,
-      assetPath: "assets/한글.png",
-      targetAsset: {
-        downloadByteSize: 7,
-        fileHash: "target-file-hash",
-      },
-      targetManifestSuffix: "\n",
-    });
-
-    expect(result).toBeNull();
-    expect(resolveFileUrl).not.toHaveBeenCalled();
+  const archive = {
+    downloadFileHash: "d".repeat(64),
+    downloadByteSize: 100,
+    tarByteSize: 2048,
+  };
+  it("offers the canonical archive URL while preserving every original and patch cost", async () => {
+    const { result } = await runScenario({ archive, patchByteSize: 3 });
+    expect(result?.archiveUrl).toBe(
+      `https://download.test/${encodeURIComponent(`s3://bucket/bundles/${TARGET_ID}/bundle.tar.br`)}`,
+    );
+    expect(result?.assets["index.ios.bundle"]?.file.url).toBeTruthy();
+    expect(result?.assets["index.ios.bundle"]?.patch?.byteSize).toBe(3);
   });
-
-  it("accepts a valid download hash and size pair on a raw asset", async () => {
-    const { resolveFileUrl, result } = await runScenario({
-      archiveByteSize: (manifestByteSize) => manifestByteSize + 7,
-      assetPath: "assets/logo.png",
-      targetAsset: {
-        downloadByteSize: 7,
-        downloadFileHash: VALID_DOWNLOAD_FILE_HASH,
-        fileHash: "target-file-hash",
+  it("keeps originals when optional archive URL resolution fails", async () => {
+    const { result } = await runScenario({
+      archive,
+      resolveUrl(uri) {
+        if (uri.endsWith("bundle.tar.br")) throw new Error("unavailable");
+        return `https://download.test/${encodeURIComponent(uri)}`;
       },
     });
-
-    expect(result).toBeNull();
-    expect(resolveFileUrl).not.toHaveBeenCalled();
+    expect(result?.archiveUrl).toBeUndefined();
+    expect(result?.assets["index.ios.bundle"]?.file.url).toBeTruthy();
+  });
+  it.each([
+    { ...archive, downloadByteSize: -1 },
+    { ...archive, tarByteSize: Number.MAX_SAFE_INTEGER + 1 },
+    { ...archive, downloadFileHash: "not-a-hash" },
+  ])("declines malformed optional archive metadata %o", async (archive) => {
+    const { result, resolveFileUrl } = await runScenario({ archive });
+    expect(result?.archiveUrl).toBeUndefined();
+    expect(
+      resolveFileUrl.mock.calls.some(([uri]) => uri?.endsWith("bundle.tar.br")),
+    ).toBe(false);
   });
+  it("returns an original descriptor for every target file, including unchanged files", async () => {
+    const { result } = await runScenario({
+      currentHash: "same-hash",
+      targetHash: "same-hash",
+    });
 
-  it("treats an invalid present hash on a raw asset as unknown cost", async () => {
-    const { resolveFileUrl, result } = await runScenario({
-      archiveByteSize: 1,
-      assetPath: "assets/logo.png",
-      targetAsset: {
-        downloadByteSize: 100,
-        downloadFileHash: "INVALID",
-        fileHash: "target-file-hash",
+    expect(result).toMatchObject({
+      artifactProtocolVersion: 1,
+      assets: {
+        "index.ios.bundle": {
+          file: { compression: "br", url: expect.any(String) },
+          fileHash: "same-hash",
+        },
       },
     });
-
-    expect(result).not.toBeNull();
-    expect(resolveFileUrl).toHaveBeenCalledWith(
-      "s3://test-bucket/assets/sha256/ta/target-file-hash.png",
-    );
   });
 
-  it.each([
-    ["missing", undefined],
-    ["invalid", "INVALID"],
-  ])(
-    "treats a Brotli asset as unknown cost when its download hash is %s",
-    async (_label, downloadFileHash) => {
-      const { resolveFileUrl, result } = await runScenario({
-        archiveByteSize: 1,
-        targetAsset: {
-          downloadByteSize: 100,
-          downloadFileHash,
-          fileHash: "target-file-hash",
-        },
-      });
-
-      expect(result).not.toBeNull();
-      expect(resolveFileUrl).toHaveBeenCalledWith(
-        "s3://test-bucket/assets/sha256/ta/target-file-hash.br",
-      );
-    },
-  );
-
   it.each([
     ["keeps", 9, true],
     ["omits", 10, false],
   ])(
-    "%s a %i-byte patch when the file is 10 bytes",
-    async (_action, patchByteSize, expectsPatch) => {
-      const { resolveFileUrl, result } = await runScenario({
-        archiveByteSize: (manifestByteSize) => manifestByteSize + 1_000,
-        patchByteSize,
-        targetAsset: {
-          downloadByteSize: 10,
-          downloadFileHash: VALID_DOWNLOAD_FILE_HASH,
-          fileHash: "target-file-hash",
-        },
-      });
-
-      expect(result?.changedAssets?.["index.ios.bundle"]?.patch).toEqual(
+    "%s a patch when it is smaller than the original transfer",
+    async (_label, patchByteSize, expectsPatch) => {
+      const { result } = await runScenario({ patchByteSize });
+      expect(result?.assets?.["index.ios.bundle"]?.patch).toEqual(
         expectsPatch
           ? expect.objectContaining({ patchUrl: expect.any(String) })
           : undefined,
       );
-      expect(resolveFileUrl).toHaveBeenCalledWith(
-        `s3://test-bucket/assets/sha256/aa/${VALID_DOWNLOAD_FILE_HASH}.br`,
-      );
-      expect(resolveFileUrl).toHaveBeenCalledWith(PATCH_STORAGE_URI);
     },
   );
 
-  it("keeps a larger patch when the file and archive URLs are unavailable", async () => {
-    const fileStorageUri = `s3://test-bucket/assets/sha256/aa/${VALID_DOWNLOAD_FILE_HASH}.br`;
-    const { result } = await runScenario({
-      archiveByteSize: 1,
-      archiveUrlUsable: false,
-      patchByteSize: 100,
-      resolveUrl: async (storageUri) =>
-        storageUri === fileStorageUri
-          ? null
-          : `https://download.example.com/${encodeURIComponent(storageUri)}`,
-      targetAsset: {
-        downloadByteSize: 50,
-        downloadFileHash: VALID_DOWNLOAD_FILE_HASH,
-        fileHash: "target-file-hash",
-      },
-    });
-
-    expect(result?.changedAssets?.["index.ios.bundle"]).toEqual({
-      fileHash: "target-file-hash",
-      patch: expect.objectContaining({
-        patchUrl: expect.any(String),
-      }),
-    });
-  });
-
-  it("recalculates from the file when an unknown-size patch URL is unavailable", async () => {
-    const { resolveFileUrl, result } = await runScenario({
-      archiveByteSize: (manifestByteSize) => manifestByteSize + 50,
-      patchByteSize: Number.NaN,
-      resolveUrl: async (storageUri) =>
-        storageUri === PATCH_STORAGE_URI
-          ? null
-          : `https://download.example.com/${encodeURIComponent(storageUri)}`,
-      targetAsset: {
-        downloadByteSize: 100,
-        downloadFileHash: VALID_DOWNLOAD_FILE_HASH,
-        fileHash: "target-file-hash",
-      },
-    });
-
-    expect(result).toBeNull();
-    expect(resolveFileUrl).toHaveBeenCalledWith(PATCH_STORAGE_URI);
-    expect(resolveFileUrl).toHaveBeenCalledWith(
-      `s3://test-bucket/assets/sha256/aa/${VALID_DOWNLOAD_FILE_HASH}.br`,
-    );
-  });
-
-  it("recalculates from a known patch when the file fallback cost is unknown", async () => {
+  it("fails closed when an original file URL cannot be resolved", async () => {
     const { result } = await runScenario({
-      archiveByteSize: (manifestByteSize) => manifestByteSize + 50,
-      patchByteSize: 100,
-      targetAsset: {
-        downloadByteSize: 100,
-        fileHash: "target-file-hash",
-      },
+      patchByteSize: 1,
+      resolveUrl: (uri) => (uri === PATCH_URI ? "https://patch.test" : null),
     });
-
     expect(result).toBeNull();
   });
-
-  it("keeps the manifest path when safe addition overflows", async () => {
-    const { result } = await runScenario({
-      archiveByteSize: 1,
-      assetPath: "assets/logo.png",
-      targetAsset: {
-        downloadByteSize: Number.MAX_SAFE_INTEGER,
-        fileHash: "target-file-hash",
-      },
-    });
-
-    expect(result).not.toBeNull();
-  });
-
-  it("keeps the manifest path when a byte size is invalid", async () => {
-    const { result } = await runScenario({
-      archiveByteSize: 1,
-      assetPath: "assets/logo.png",
-      targetAsset: {
-        downloadByteSize: -1,
-        fileHash: "target-file-hash",
-      },
-    });
-
-    expect(result).not.toBeNull();
-  });
-
-  it("does not select archive when its URL is unavailable", async () => {
-    const { result } = await runScenario({
-      archiveByteSize: 1,
-      archiveUrlUsable: false,
-      assetPath: "assets/logo.png",
-      targetAsset: {
-        downloadByteSize: 100,
-        fileHash: "target-file-hash",
-      },
-    });
-
-    expect(result).not.toBeNull();
-  });
 });
 
-describe("createArtifactResolver", () => {
-  it("returns usable manifest artifacts when the archive URL is null", async () => {
-    const databasePlugin = createInMemoryDatabasePlugin();
-    const database = createDatabaseClient(databasePlugin);
-    const targetManifestText = JSON.stringify({
+describe("core's artifact resolution", () => {
+  const setup = async (readManifest = true) => {
+    const manifestText = JSON.stringify({
+      bundleId: TARGET_ID,
       assets: {
         "assets/logo.png": {
-          downloadByteSize: 100,
-          fileHash: "target-file-hash",
+          downloadByteSize: 4,
+          fileHash: "logo-hash",
         },
       },
-      bundleId: TARGET_BUNDLE_ID,
-    });
-    const targetBundle = createBundle(TARGET_BUNDLE_ID, 1);
-    await database.insertBundle(targetBundle);
-
-    const resolver = createArtifactResolver({
-      database: databasePlugin,
-      readStorageText: async (storageUri) =>
-        storageUri === TARGET_MANIFEST_URI ? targetManifestText : null,
-      resolveFileUrl: async (storageUri) =>
-        storageUri === targetBundle.storageUri
-          ? null
-          : `https://download.example.com/${encodeURIComponent(storageUri ?? "")}`,
     });
+    const core = createCoreApi(
+      createDatabaseEngine({
+        adapter: createMemoryAdapter(),
+        schema: resolveSchema([coreModule]),
+      }).database(coreModule),
+      {
+        ...(readManifest
+          ? {
+              readStorageText: async (uri: string) =>
+                uri === TARGET_MANIFEST_URI ? manifestText : null,
+            }
+          : {}),
+        resolveFileUrl: async (uri) =>
+          uri ? `https://download.test/${encodeURIComponent(uri)}` : null,
+      },
+    );
+    await core.deploy([
+      {
+        bundle: createBundle(TARGET_ID),
+        release: {
+          channel: "production",
+          enabled: true,
+          fingerprintHash: null,
+          message: null,
+          shouldForceUpdate: false,
+          targetAppVersion: "*",
+        },
+      },
+    ]);
+    return core.getArtifactInfo;
+  };
 
-    await expect(resolver(TARGET_BUNDLE_ID, NIL_UUID)).resolves.toMatchObject({
-      changedAssets: {
+  it("serves the explicit manifest artifact protocol", async () => {
+    const resolver = await setup();
+    await expect(resolver(TARGET_ID, NIL_UUID, 1)).resolves.toMatchObject({
+      artifactProtocolVersion: 1,
+      assets: {
         "assets/logo.png": {
           file: { url: expect.any(String) },
-          fileHash: "target-file-hash",
+          fileHash: "logo-hash",
         },
       },
-      fileUrl: null,
       manifestUrl: expect.any(String),
     });
   });
+
+  it("fails closed when manifest storage cannot be read", async () => {
+    const resolver = await setup(false);
+    await expect(resolver(TARGET_ID, NIL_UUID, 1)).resolves.toBeNull();
+  });
 });