@bravemobile/react-native-code-push 13.0.0 → 13.1.0-beta.0

package/cli/dist/commands/releaseCommand/release.js

@@ -1,13 +1,20 @@
 import fs from "fs";
 import path from "path";
-import { bundleCodePush } from "../bundleCommand/bundleCodePush.js";
+import { bundleCodePush, resolveJsBundleName } from "../bundleCommand/bundleCodePush.js";
 import { addToReleaseHistory } from "./addToReleaseHistory.js";
 import { generatePackageHashFromDirectory } from "../../utils/hash-utils.js";
 import { unzip } from "../../utils/unzip.js";
-export async function release(bundleUploader, getReleaseHistory, setReleaseHistory, binaryVersion, appVersion, framework, platform, identifier, outputPath, entryFile, jsBundleName, mandatory, enable, rollout, skipBundle, skipCleanup, bundleDirectory, outputMetroDir, hashCalc) {
-    const bundleFileName = skipBundle
-        ? readBundleFileNameFrom(bundleDirectory)
-        : await bundleCodePush(framework, platform, outputPath, entryFile, jsBundleName, bundleDirectory, outputMetroDir);
+import { BINARY_PATCH_ARCHIVE_SUFFIX, BINARY_PATCH_BASE_RECORD_NAME, DEFAULT_OVERSIZED_PATCH_POLICY, extractCodePushBundleContents, formatBinaryPatchSummary, hashBundleFile, isPatchArchiveOversized, makeBinaryPatchBundle, readBinaryPatchBaseRecord, } from "../../functions/makeBinaryPatchBundle.js";
+export async function release(bundleUploader, getReleaseHistory, setReleaseHistory, binaryVersion, appVersion, framework, platform, identifier, outputPath, entryFile, jsBundleName, mandatory, enable, rollout, skipBundle, skipCleanup, bundleDirectory, outputMetroDir, hashCalc, baseBundlePath, onOversizedPatch = DEFAULT_OVERSIZED_PATCH_POLICY) {
+    if (baseBundlePath) {
+        // Checked before the bundler runs, so the wrong base bundle costs a second rather
+        // than a full build.
+        verifyExportedBaseBundleRecord(baseBundlePath, binaryVersion);
+    }
+    const codePushBundle = skipBundle
+        ? null
+        : await bundleCodePush(framework, platform, outputPath, entryFile, jsBundleName, bundleDirectory, outputMetroDir, baseBundlePath);
+    const bundleFileName = codePushBundle?.bundleFileName ?? readBundleFileNameFrom(bundleDirectory);
     const bundleFilePath = `${bundleDirectory}/${bundleFileName}`;
     const packageHash = await (() => {
         if (skipBundle && hashCalc) {
@@ -16,17 +23,28 @@ export async function release(bundleUploader, getReleaseHistory, setReleaseHisto
         // If not using --skip-bundle, the bundleFileName represents package hash already.
         return bundleFileName;
     })();
-    const downloadUrl = await (async () => {
-        try {
-            const { downloadUrl } = await bundleUploader(bundleFilePath, platform, identifier);
-            return downloadUrl;
-        }
-        catch (error) {
-            console.error('Failed to upload the bundle file. Exiting the program.\n', error);
-            process.exit(1);
-        }
-    })();
-    await addToReleaseHistory(appVersion, binaryVersion, downloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout);
+    const binaryPatch = baseBundlePath
+        ? await makeBinaryPatchArtifact({
+            baseBundlePath,
+            contentsPath: codePushBundle?.contentsPath,
+            bundleFilePath,
+            jsBundleName: codePushBundle?.jsBundleName ?? resolveJsBundleName(platform, jsBundleName),
+            bundleDirectory,
+            packageHash,
+            outputPath,
+            platform,
+            onOversizedPatch,
+        })
+        : null;
+    // Every artifact is uploaded before the release history is touched, so a failed
+    // upload leaves the history describing only updates that can actually be downloaded.
+    const downloadUrl = await uploadArtifact(bundleUploader, bundleFilePath, platform, identifier, 'bundle');
+    let patchDownloadUrl;
+    if (binaryPatch) {
+        patchDownloadUrl = await uploadArtifact(bundleUploader, binaryPatch.patchBundleFilePath, platform, identifier, 'binary patch bundle');
+        console.log(`log: Binary patch archive uploaded (download url: ${patchDownloadUrl})`);
+    }
+    await addToReleaseHistory(appVersion, binaryVersion, downloadUrl, patchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout);
     if (!skipCleanup) {
         cleanUpOutputs(outputPath);
     }
@@ -35,7 +53,9 @@ function cleanUpOutputs(dir) {
     fs.rmSync(dir, { recursive: true });
 }
 function readBundleFileNameFrom(bundleDirectory) {
-    const files = fs.readdirSync(bundleDirectory);
+    // A previous release of the same bundle may have left its patch archive here, and
+    // that archive is derived from the bundle file rather than a candidate for release.
+    const files = fs.readdirSync(bundleDirectory).filter((file) => !file.endsWith(BINARY_PATCH_ARCHIVE_SUFFIX));
     if (files.length !== 1) {
         console.error('The bundlePath must contain only one file.');
         process.exit(1);
@@ -60,3 +80,131 @@ async function calcHashFromBundleFile(bundleFilePath) {
         fs.rmSync(tempDir, { recursive: true, force: true });
     }
 }
+/**
+ * Builds the binary patch artifact of this release and reports what it saves, before
+ * anything is uploaded.
+ *
+ * A patch that is not smaller than the full archive is not worth publishing, and the
+ * CLI cannot ask: it runs unattended. `onOversizedPatch` decides instead - `skip`
+ * releases the full bundle alone, `fail` stops the release while nothing has been
+ * uploaded yet.
+ *
+ * @param contentsPath {string | undefined} Update contents of a bundle that was just built. Absent with `--skip-bundle`, where the bundle file being released is unpacked instead, so the patch describes exactly the bytes that go out.
+ * @return {Promise<BinaryPatchBundle | null>} The artifact to upload, or `null` when the patch was skipped.
+ */
+async function makeBinaryPatchArtifact({ baseBundlePath, contentsPath, bundleFilePath, jsBundleName, bundleDirectory, packageHash, outputPath, platform, onOversizedPatch, }) {
+    warnOnBaseBundleMismatch(outputPath, baseBundlePath);
+    let patchContentsPath = contentsPath;
+    let extractDir = null;
+    if (patchContentsPath === undefined) {
+        const extracted = await extractCodePushBundleContents(bundleFilePath, outputPath);
+        patchContentsPath = extracted.contentsPath;
+        extractDir = extracted.extractDir;
+    }
+    try {
+        const binaryPatch = await makeBinaryPatchBundle({
+            contentsPath: patchContentsPath,
+            baseBundlePath,
+            bundleRelativePath: jsBundleName,
+            bundleDirectory,
+            packageHash,
+        });
+        const fullArchiveSize = fs.statSync(bundleFilePath).size;
+        const patchArchiveSize = fs.statSync(binaryPatch.patchBundleFilePath).size;
+        const oversized = isPatchArchiveOversized(fullArchiveSize, patchArchiveSize);
+        console.log(formatBinaryPatchSummary({
+            platform,
+            baseBundleHash: binaryPatch.manifest.baseBundleHash,
+            targetBundleHash: binaryPatch.manifest.targetBundleHash,
+            fullArchiveSize,
+            patchArchiveSize,
+            patchSkipped: oversized && onOversizedPatch === 'skip',
+        }));
+        if (oversized) {
+            if (onOversizedPatch === 'fail') {
+                throw new Error(`The binary patch archive (${patchArchiveSize} bytes) is not smaller than the full archive (${fullArchiveSize} bytes), ` +
+                    'and --on-oversized-patch is set to "fail". Nothing was uploaded.');
+            }
+            console.warn(`warn: The binary patch archive (${patchArchiveSize} bytes) is not smaller than the full archive (${fullArchiveSize} bytes). ` +
+                'Releasing the full bundle only, without a binary patch.');
+            return null;
+        }
+        return binaryPatch;
+    }
+    finally {
+        if (extractDir) {
+            fs.rmSync(extractDir, { recursive: true, force: true });
+        }
+    }
+}
+/**
+ * Cross-checks the base bundle against the record a build hook exported next to it.
+ *
+ * The base bundle is the one input a release cannot verify on its own: pass the bundle of
+ * a different build and everything still succeeds, only for the patch to be unappliable
+ * on every device. The record says which bytes and which binary the export came from, so
+ * when it is there, the two mistakes that produce a broken release - a base file that was
+ * replaced after it was exported, and a base exported from a different binary version -
+ * stop the release before anything is built or uploaded.
+ *
+ * A base bundle produced some other way has no record next to it, and releases exactly as
+ * it did before. A record that cannot be read only warns: it is a cross-check, and losing
+ * it must never be able to fail a release that is otherwise fine.
+ */
+function verifyExportedBaseBundleRecord(baseBundlePath, binaryVersion) {
+    const recordPath = path.join(path.dirname(path.resolve(baseBundlePath)), BINARY_PATCH_BASE_RECORD_NAME);
+    let contents;
+    try {
+        contents = fs.readFileSync(recordPath, 'utf8');
+    }
+    catch {
+        return;
+    }
+    let record = {};
+    try {
+        record = JSON.parse(contents) ?? {};
+    }
+    catch {
+        // Left empty, which is reported below as a record that says nothing to check.
+    }
+    if (typeof record.baseBundleHash !== 'string') {
+        console.warn(`warn: "${recordPath}" is not a readable binary patch base record, so the base bundle was released without cross-checking it.`);
+        return;
+    }
+    const baseBundleHash = hashBundleFile(baseBundlePath);
+    if (record.baseBundleHash !== baseBundleHash) {
+        throw new Error(`The base bundle "${baseBundlePath}" does not match the record exported next to it: the record describes ${record.baseBundleHash}, ` +
+            `but the file hashes to ${baseBundleHash}. Export the bundle again from the build that produced the binary.`);
+    }
+    if (typeof record.binaryVersion === 'string' && record.binaryVersion !== binaryVersion) {
+        throw new Error(`The base bundle "${baseBundlePath}" was exported from binary version ${record.binaryVersion}, but this release targets ${binaryVersion} ` +
+            '(--binary-version). Release against the bundle of the binary being targeted.');
+    }
+}
+/**
+ * The bundle being released may have been compiled by an earlier `bundle` run against a
+ * different base. The patch stays valid - it is always computed against the base given
+ * here - but the bytecode alignment that keeps it small is lost, which is worth saying
+ * out loud instead of leaving it to be noticed in the size summary.
+ */
+function warnOnBaseBundleMismatch(outputPath, baseBundlePath) {
+    const record = readBinaryPatchBaseRecord(outputPath);
+    if (!record) {
+        return;
+    }
+    const baseBundleHash = hashBundleFile(baseBundlePath);
+    if (record.baseBundleHash !== baseBundleHash) {
+        console.warn(`warn: The bundle was compiled against base bundle ${record.baseBundleHash}, but this release patches against ${baseBundleHash}. ` +
+            'The patch is valid but larger than an aligned one.');
+    }
+}
+async function uploadArtifact(bundleUploader, filePath, platform, identifier, artifactName) {
+    try {
+        const { downloadUrl } = await bundleUploader(filePath, platform, identifier);
+        return downloadUrl;
+    }
+    catch (error) {
+        console.error(`Failed to upload the ${artifactName} file. Exiting the program.\n`, error);
+        process.exit(1);
+    }
+}

package/cli/dist/commands/releaseCommand/release.test.js

@@ -0,0 +1,367 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { release } from "./release.js";
+import { makeCodePushBundle } from "../../functions/makeCodePushBundle.js";
+import { BINARY_PATCH_ARCHIVE_SUFFIX, BINARY_PATCH_BASE_RECORD_NAME, BINARY_PATCH_MANIFEST_NAME, hashBundleFile, writeBinaryPatchBaseRecord, } from "../../functions/makeBinaryPatchBundle.js";
+import { applyPatch } from "../../utils/binaryPatch.js";
+import { generatePackageHashFromDirectory } from "../../utils/hash-utils.js";
+import { unzip } from "../../utils/unzip.js";
+/**
+ * Covers the release flow around the binary patch option with `--skip-bundle`, which is
+ * the one path that reaches every decision - which artifacts exist, in which order they
+ * are uploaded, what the history ends up saying - without running the bundler.
+ */
+/** Filled in by `bundle`, so `release --skip-bundle` starts from a real archive. */
+const CONTENTS_DIR_NAME = 'CodePush';
+const OUTPUT_DIR_NAME = 'build';
+const BUNDLE_OUTPUT_DIR_NAME = 'bundleOutput';
+const BINARY_VERSION = '9.9.9';
+const APP_VERSION = '9.9.10';
+function findRepoRoot() {
+    let dir = process.cwd();
+    for (;;) {
+        if (fs.existsSync(path.join(dir, "scripts", "binary-patch", "build-hdiffpatch.sh"))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error(`cannot locate the repository root from ${process.cwd()}`);
+        }
+        dir = parent;
+    }
+}
+const repoRoot = findRepoRoot();
+const fixtureDir = path.join(repoRoot, "cli", "fixtures", "binary-patch");
+const baseFixture = path.join(fixtureDir, "base.bundle");
+const targetFixture = path.join(fixtureDir, "target.bundle");
+let workDir;
+/**
+ * Leaves an output directory in the state a finished `bundle` run leaves it in: the
+ * bundle file, and no update contents - the contents are the bundler's scratch space,
+ * and `--skip-bundle` cannot assume they survived.
+ */
+async function stageBundleOutput(caseName, files = { 'main.jsbundle': fs.readFileSync(targetFixture) }) {
+    const caseDir = fs.mkdtempSync(path.join(workDir, `${caseName}-`));
+    const outputPath = path.join(caseDir, OUTPUT_DIR_NAME);
+    const contentsPath = path.join(outputPath, CONTENTS_DIR_NAME);
+    for (const [relativePath, content] of Object.entries(files)) {
+        const filePath = path.join(contentsPath, relativePath);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content);
+    }
+    const bundleDirectory = path.join(outputPath, BUNDLE_OUTPUT_DIR_NAME);
+    const { bundleFileName } = await makeCodePushBundle(contentsPath, bundleDirectory);
+    fs.rmSync(contentsPath, { recursive: true, force: true });
+    return { outputPath, bundleDirectory, bundleFileName };
+}
+class ProcessExitError extends Error {
+    code;
+    constructor(code) {
+        super(`process.exit(${code})`);
+        this.code = code;
+    }
+}
+function recordingUploader(uploads, failOn) {
+    return async (filePath) => {
+        if (failOn?.(filePath)) {
+            throw new Error(`upload rejected: ${path.basename(filePath)}`);
+        }
+        const downloadUrl = `https://cdn.example.com/${path.basename(filePath)}`;
+        uploads.push({ filePath, downloadUrl, logCountBeforeUpload: logs.length });
+        return { downloadUrl };
+    };
+}
+function historyStore() {
+    const saved = [];
+    return {
+        saved,
+        getReleaseHistory: async () => ({}),
+        setReleaseHistory: async (_binaryVersion, _jsonFilePath, releaseInfo) => {
+            saved.push(releaseInfo);
+        },
+    };
+}
+async function runRelease(staged, overrides = {}) {
+    const uploads = overrides.uploads ?? [];
+    const history = historyStore();
+    await release(recordingUploader(uploads, overrides.uploadFailsFor), history.getReleaseHistory, history.setReleaseHistory, BINARY_VERSION, APP_VERSION, undefined, overrides.platform ?? 'ios', undefined, staged.outputPath, 'index.ts', 
+    // Left unset unless the case is about -j, the way commander leaves it.
+    overrides.jsBundleName, false, true, undefined, true, // skipBundle
+    overrides.skipCleanup ?? true, staged.bundleDirectory, undefined, undefined, overrides.binaryBundlePath, overrides.onOversizedPatch);
+    return { uploads, releaseHistories: history.saved };
+}
+let logs;
+beforeAll(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "codepush-release-"));
+});
+afterAll(() => {
+    fs.rmSync(workDir, { recursive: true, force: true });
+});
+beforeEach(() => {
+    logs = [];
+    const collect = (...args) => {
+        logs.push(args.map(String).join(' '));
+    };
+    jest.spyOn(console, 'log').mockImplementation(collect);
+    jest.spyOn(console, 'warn').mockImplementation(collect);
+    jest.spyOn(console, 'error').mockImplementation(collect);
+    jest.spyOn(process, 'exit').mockImplementation(((code) => {
+        throw new ProcessExitError(code ?? 0);
+    }));
+});
+afterEach(() => {
+    jest.restoreAllMocks();
+    // addToReleaseHistory writes its JSON next to the invocation, and only removes it
+    // when the history was stored successfully.
+    fs.rmSync(path.resolve(process.cwd(), `${BINARY_VERSION}.json`), { force: true });
+});
+describe("release without --binary-bundle-path", () => {
+    it("uploads the full bundle only, exactly as before binary patches existed", async () => {
+        const staged = await stageBundleOutput("full-only");
+        const { uploads, releaseHistories } = await runRelease(staged);
+        expect(uploads).toHaveLength(1);
+        expect(uploads[0].filePath).toBe(`${staged.bundleDirectory}/${staged.bundleFileName}`);
+        expect(fs.readdirSync(staged.bundleDirectory)).toEqual([staged.bundleFileName]);
+        expect(releaseHistories[0][APP_VERSION]).toEqual({
+            enabled: true,
+            mandatory: false,
+            downloadUrl: uploads[0].downloadUrl,
+            packageHash: staged.bundleFileName,
+        });
+        // A release without a patch says nothing about one, so a client reading this
+        // history behaves exactly as it did before binary patches existed.
+        expect(releaseHistories[0][APP_VERSION]).not.toHaveProperty('binaryPatchDownloadUrl');
+    });
+});
+describe("release --skip-bundle --binary-bundle-path", () => {
+    it("patches the bundle that is already in the output directory and uploads both artifacts", async () => {
+        const staged = await stageBundleOutput("skip-bundle");
+        const { uploads, releaseHistories } = await runRelease(staged, { binaryBundlePath: baseFixture });
+        const patchFileName = `${staged.bundleFileName}${BINARY_PATCH_ARCHIVE_SUFFIX}`;
+        // The full archive goes first: the patch is an optimisation on top of it.
+        expect(uploads.map(({ filePath }) => path.basename(filePath))).toEqual([staged.bundleFileName, patchFileName]);
+        expect(fs.existsSync(path.join(staged.bundleDirectory, patchFileName))).toBe(true);
+        // Both artifacts are described in the same entry: the full bundle every client can
+        // download, and the patch a client holding the matching binary can apply instead.
+        expect(releaseHistories[0][APP_VERSION].downloadUrl).toBe(uploads[0].downloadUrl);
+        expect(releaseHistories[0][APP_VERSION].binaryPatchDownloadUrl).toBe(uploads[1].downloadUrl);
+        expect(releaseHistories[0][APP_VERSION].packageHash).toBe(staged.bundleFileName);
+    });
+    it("prints the size summary before uploading anything", async () => {
+        const staged = await stageBundleOutput("summary");
+        const { uploads } = await runRelease(staged, { binaryBundlePath: baseFixture });
+        const summaryIndex = logs.findIndex((line) => line.startsWith('Binary patch summary (ios)'));
+        expect(summaryIndex).toBeGreaterThanOrEqual(0);
+        expect(logs[summaryIndex]).toContain('Saved:');
+        // Printed while the release can still be stopped, so before the first upload.
+        expect(uploads).toHaveLength(2);
+        expect(summaryIndex).toBeLessThan(uploads[0].logCountBeforeUpload);
+    });
+    it("uses the platform's own bundle name when picking the target to patch", async () => {
+        const staged = await stageBundleOutput("android", {
+            'index.android.bundle': fs.readFileSync(targetFixture),
+        });
+        await runRelease(staged, { binaryBundlePath: baseFixture, platform: 'android' });
+        expect(logs.some((line) => line.startsWith('Binary patch summary (android)'))).toBe(true);
+    });
+    it("patches a bundle that was built with a custom JS bundle name", async () => {
+        const staged = await stageBundleOutput("custom-name", {
+            'custom.jsbundle': fs.readFileSync(targetFixture),
+        });
+        const { uploads } = await runRelease(staged, {
+            binaryBundlePath: baseFixture,
+            jsBundleName: 'custom.jsbundle',
+        });
+        expect(uploads.map(({ filePath }) => path.basename(filePath))).toEqual([
+            staged.bundleFileName,
+            `${staged.bundleFileName}${BINARY_PATCH_ARCHIVE_SUFFIX}`,
+        ]);
+        const extractRoot = path.join(staged.outputPath, 'extracted');
+        fs.mkdirSync(extractRoot, { recursive: true });
+        await unzip(path.join(staged.bundleDirectory, `${staged.bundleFileName}${BINARY_PATCH_ARCHIVE_SUFFIX}`), extractRoot);
+        const manifest = JSON.parse(fs.readFileSync(path.join(extractRoot, CONTENTS_DIR_NAME, BINARY_PATCH_MANIFEST_NAME), 'utf8'));
+        expect(manifest.bundlePath).toBe('custom.jsbundle');
+        expect(manifest.patchFile).toBe('custom.jsbundle.patch');
+    });
+    it("fails without -j when the released bundle uses a custom JS bundle name", async () => {
+        const staged = await stageBundleOutput("custom-name-without-option", {
+            'custom.jsbundle': fs.readFileSync(targetFixture),
+        });
+        // The error names -j because passing it is what makes this release work.
+        await expect(runRelease(staged, { binaryBundlePath: baseFixture })).rejects.toThrow(/main\.jsbundle.*--js-bundle-name/s);
+    });
+    it("fails with an actionable error when the released bundle holds no matching JS bundle", async () => {
+        const staged = await stageBundleOutput("no-target", {
+            'index.android.bundle': fs.readFileSync(targetFixture),
+        });
+        await expect(runRelease(staged, { binaryBundlePath: baseFixture, platform: 'ios' })).rejects.toThrow(/main\.jsbundle.*--js-bundle-name/s);
+    });
+    it("warns when the bundle was compiled against a different base bundle", async () => {
+        const staged = await stageBundleOutput("mismatch");
+        writeBinaryPatchBaseRecord(staged.outputPath, 'f'.repeat(64));
+        await runRelease(staged, { binaryBundlePath: baseFixture });
+        expect(logs.filter((line) => line.startsWith('warn:')).join('\n')).toMatch(/compiled against base bundle/);
+    });
+    it("does not warn when the recorded base bundle is the one being patched against", async () => {
+        const staged = await stageBundleOutput("match");
+        // The record the `bundle` command writes holds the hash of this same file.
+        writeBinaryPatchBaseRecord(staged.outputPath, hashBundleFile(baseFixture));
+        await runRelease(staged, { binaryBundlePath: baseFixture });
+        expect(logs.filter((line) => line.startsWith('warn:'))).toEqual([]);
+    });
+    it("keeps the release history untouched when the patch archive cannot be uploaded", async () => {
+        const staged = await stageBundleOutput("patch-upload-failure");
+        const uploads = [];
+        const history = historyStore();
+        await expect(release(recordingUploader(uploads, (filePath) => filePath.endsWith(BINARY_PATCH_ARCHIVE_SUFFIX)), history.getReleaseHistory, history.setReleaseHistory, BINARY_VERSION, APP_VERSION, undefined, 'ios', undefined, staged.outputPath, 'index.ts', '', false, true, undefined, true, true, staged.bundleDirectory, undefined, undefined, baseFixture)).rejects.toThrow(ProcessExitError);
+        expect(uploads.map(({ filePath }) => path.basename(filePath))).toEqual([staged.bundleFileName]);
+        expect(history.saved).toEqual([]);
+    });
+    it("leaves no working directories behind and cleans up the output when asked", async () => {
+        const staged = await stageBundleOutput("cleanup");
+        await runRelease(staged, { binaryBundlePath: baseFixture, skipCleanup: true });
+        expect(fs.readdirSync(staged.outputPath)).toEqual([BUNDLE_OUTPUT_DIR_NAME]);
+        await runRelease(staged, { binaryBundlePath: baseFixture, skipCleanup: false });
+        expect(fs.existsSync(staged.outputPath)).toBe(false);
+    });
+    it("still finds the bundle to release when a previous run left its patch archive behind", async () => {
+        const staged = await stageBundleOutput("leftover-patch");
+        fs.writeFileSync(path.join(staged.bundleDirectory, `stale${BINARY_PATCH_ARCHIVE_SUFFIX}`), 'stale');
+        const { uploads } = await runRelease(staged, { binaryBundlePath: baseFixture });
+        expect(path.basename(uploads[0].filePath)).toBe(staged.bundleFileName);
+    });
+    it("uploads the patch when it is smaller than the full bundle, without warning about its size", async () => {
+        const staged = await stageBundleOutput("worthwhile-patch");
+        const { uploads } = await runRelease(staged, { binaryBundlePath: baseFixture });
+        expect(uploads).toHaveLength(2);
+        expect(logs.filter((line) => line.startsWith('warn:'))).toEqual([]);
+        expect(logs.join('\n')).not.toContain('Patch skipped:');
+    });
+    it("ships a patch archive a client can turn back into the released bundle", async () => {
+        const staged = await stageBundleOutput("manifest", {
+            'main.jsbundle': fs.readFileSync(targetFixture),
+            'assets/logo.png': Buffer.from('logo-bytes'),
+        });
+        await runRelease(staged, { binaryBundlePath: baseFixture });
+        const extractRoot = path.join(staged.outputPath, 'extracted');
+        fs.mkdirSync(extractRoot, { recursive: true });
+        await unzip(path.join(staged.bundleDirectory, `${staged.bundleFileName}${BINARY_PATCH_ARCHIVE_SUFFIX}`), extractRoot);
+        const contents = path.join(extractRoot, CONTENTS_DIR_NAME);
+        const manifest = JSON.parse(fs.readFileSync(path.join(contents, BINARY_PATCH_MANIFEST_NAME), 'utf8'));
+        expect(manifest.bundlePath).toBe('main.jsbundle');
+        applyPatch(baseFixture, path.join(contents, manifest.patchFile), path.join(contents, manifest.bundlePath));
+        fs.rmSync(path.join(contents, manifest.patchFile));
+        fs.rmSync(path.join(contents, BINARY_PATCH_MANIFEST_NAME));
+        expect(await generatePackageHashFromDirectory(contents, extractRoot)).toBe(staged.bundleFileName);
+    });
+});
+/**
+ * The build hooks export the bundle of a native build with a record describing it, so the
+ * base bundle a release is handed can be checked against the build it came out of.
+ */
+describe("release --binary-bundle-path with an exported base bundle record", () => {
+    /** A base bundle laid out the way a build hook leaves it: the bundle, and its record beside it. */
+    function stageExportedBaseBundle(caseName, record) {
+        const exportDir = fs.mkdtempSync(path.join(workDir, `${caseName}-export-`));
+        const baseBundlePath = path.join(exportDir, 'main.jsbundle');
+        fs.copyFileSync(baseFixture, baseBundlePath);
+        if (record !== undefined) {
+            fs.writeFileSync(path.join(exportDir, BINARY_PATCH_BASE_RECORD_NAME), record);
+        }
+        return baseBundlePath;
+    }
+    function exportedRecord(overrides = {}) {
+        return JSON.stringify({
+            baseBundleHash: hashBundleFile(baseFixture),
+            binaryVersion: BINARY_VERSION,
+            buildNumber: '42',
+            gitSha: 'a'.repeat(40),
+            ...overrides,
+        }, null, 2);
+    }
+    it("releases both artifacts when the record describes this bundle and this binary version", async () => {
+        const staged = await stageBundleOutput("record-match");
+        const baseBundlePath = stageExportedBaseBundle("record-match", exportedRecord());
+        const { uploads } = await runRelease(staged, { binaryBundlePath: baseBundlePath });
+        expect(uploads).toHaveLength(2);
+        expect(logs.filter((line) => line.startsWith('warn:'))).toEqual([]);
+    });
+    it("fails before anything is built when the base bundle is not the file the record describes", async () => {
+        const staged = await stageBundleOutput("record-hash-mismatch");
+        const baseBundlePath = stageExportedBaseBundle("record-hash-mismatch", exportedRecord({ baseBundleHash: 'f'.repeat(64) }));
+        const uploads = [];
+        await expect(runRelease(staged, { binaryBundlePath: baseBundlePath, uploads })).rejects.toThrow(/does not match the record exported next to it/);
+        expect(uploads).toEqual([]);
+    });
+    it("fails when the base bundle was exported from a different binary version", async () => {
+        const staged = await stageBundleOutput("record-version-mismatch");
+        const baseBundlePath = stageExportedBaseBundle("record-version-mismatch", exportedRecord({ binaryVersion: '1.0.0' }));
+        const uploads = [];
+        await expect(runRelease(staged, { binaryBundlePath: baseBundlePath, uploads })).rejects.toThrow(new RegExp(`exported from binary version 1\\.0\\.0, but this release targets ${BINARY_VERSION}`));
+        expect(uploads).toEqual([]);
+    });
+    it.each([
+        ['is not JSON at all', 'not json at all'],
+        ['holds nothing to read a record out of', 'null'],
+    ])("warns and releases when the record %s", async (caseName, contents) => {
+        const staged = await stageBundleOutput("record-unreadable");
+        const baseBundlePath = stageExportedBaseBundle(`record-unreadable-${caseName.replace(/\W+/g, '-')}`, contents);
+        const { uploads } = await runRelease(staged, { binaryBundlePath: baseBundlePath });
+        expect(logs.filter((line) => line.startsWith('warn:')).join('\n')).toMatch(/not a readable binary patch base record/);
+        expect(uploads).toHaveLength(2);
+    });
+    it("warns and releases when the record leaves out the hash it is checked against", async () => {
+        const staged = await stageBundleOutput("record-no-hash");
+        const baseBundlePath = stageExportedBaseBundle("record-no-hash", JSON.stringify({ binaryVersion: '1.0.0' }));
+        const { uploads } = await runRelease(staged, { binaryBundlePath: baseBundlePath });
+        expect(logs.filter((line) => line.startsWith('warn:')).join('\n')).toMatch(/not a readable binary patch base record/);
+        expect(uploads).toHaveLength(2);
+    });
+    it("releases exactly as before when the base bundle has no record beside it", async () => {
+        const staged = await stageBundleOutput("record-absent");
+        const baseBundlePath = stageExportedBaseBundle("record-absent");
+        const { uploads } = await runRelease(staged, { binaryBundlePath: baseBundlePath });
+        expect(uploads).toHaveLength(2);
+        expect(logs.filter((line) => line.startsWith('warn:'))).toEqual([]);
+    });
+});
+/**
+ * A patch is only worth publishing when it is smaller than the archive it replaces. The
+ * CLI runs unattended, so `--on-oversized-patch` decides what happens when it is not.
+ *
+ * An update whose bundle is a few bytes long produces one: the patch container and the
+ * manifest that describes it together outweigh the whole full archive.
+ */
+describe("release --on-oversized-patch", () => {
+    const tinyContents = () => ({ 'main.jsbundle': Buffer.from('tiny') });
+    it("skips the patch by default and releases the full bundle alone", async () => {
+        const staged = await stageBundleOutput("oversized-skip", tinyContents());
+        const { uploads, releaseHistories } = await runRelease(staged, { binaryBundlePath: baseFixture });
+        expect(uploads.map(({ filePath }) => path.basename(filePath))).toEqual([staged.bundleFileName]);
+        expect(logs.filter((line) => line.startsWith('warn:')).join('\n')).toMatch(/not smaller than the full archive/);
+        expect(logs.join('\n')).toContain('Patch skipped:');
+        expect(releaseHistories[0][APP_VERSION].downloadUrl).toBe(uploads[0].downloadUrl);
+        // Nothing was uploaded to patch from, so the entry must not point at one.
+        expect(releaseHistories[0][APP_VERSION]).not.toHaveProperty('binaryPatchDownloadUrl');
+    });
+    it("fails before any upload when the policy is fail", async () => {
+        const staged = await stageBundleOutput("oversized-fail", tinyContents());
+        const uploads = [];
+        const history = historyStore();
+        await expect(release(recordingUploader(uploads), history.getReleaseHistory, history.setReleaseHistory, BINARY_VERSION, APP_VERSION, undefined, 'ios', undefined, staged.outputPath, 'index.ts', undefined, false, true, undefined, true, true, staged.bundleDirectory, undefined, undefined, baseFixture, 'fail')).rejects.toThrow(/not smaller than the full archive/);
+        expect(uploads).toEqual([]);
+        expect(history.saved).toEqual([]);
+        // The temp directories are still cleaned up on the way out.
+        expect(fs.readdirSync(staged.outputPath)).toEqual([BUNDLE_OUTPUT_DIR_NAME]);
+    });
+    it("uploads a worthwhile patch even when the policy is fail", async () => {
+        const staged = await stageBundleOutput("worthwhile-under-fail");
+        const { uploads } = await runRelease(staged, {
+            binaryBundlePath: baseFixture,
+            onOversizedPatch: 'fail',
+        });
+        expect(uploads).toHaveLength(2);
+    });
+});