@bravemobile/react-native-code-push 13.1.0-beta.3 → 13.1.0-beta.5

package/android/app/src/test/java/com/microsoft/codepush/react/CodePushBinaryPatchTest.java

@@ -55,7 +55,7 @@ public class CodePushBinaryPatchTest {
     public void appliesAPatchAndLeavesTheContentsOfAFullArchiveBehind() throws IOException {
         FakePatchApplier applier = new FakePatchApplier(CodePushBinaryPatch.PatchApplier.RESULT_OK, TARGET_BUNDLE);
 
-        BinaryPatchResult result = restoreBundle(BASE_BUNDLE, applier);
+        ArchiveRestoreResult result = restoreBundle(BASE_BUNDLE, applier);
 
         assertTrue(result.succeeded());
         assertArrayEquals(TARGET_BUNDLE, readFile(mBundleFile));
@@ -77,7 +77,7 @@ public class CodePushBinaryPatchTest {
         assertTrue(mManifestFile.renameTo(new File(archiveRoot, CodePushConstants.BINARY_PATCH_MANIFEST_FILE_NAME)));
         assertTrue(mPatchFile.renameTo(new File(archiveRoot, PATCH_FILE_NAME)));
 
-        BinaryPatchResult result = new CodePushBinaryPatch(providerOf(BASE_BUNDLE), succeedingApplier())
+        ArchiveRestoreResult result = new CodePushBinaryPatch(providerOf(BASE_BUNDLE), succeedingApplier())
                 .restoreBundle(unzippedFolder.getAbsolutePath(), mWorkingFolder.getAbsolutePath(), BUNDLE_FILE_NAME);
 
         assertTrue(result.succeeded());
@@ -101,7 +101,7 @@ public class CodePushBinaryPatchTest {
         File assetFile = new File(contentsFolder, "logo.png");
         writeFile(assetFile, bytes("an asset the diff brought along"));
 
-        BinaryPatchResult result = new CodePushBinaryPatch(providerOf(BASE_BUNDLE), succeedingApplier())
+        ArchiveRestoreResult result = new CodePushBinaryPatch(providerOf(BASE_BUNDLE), succeedingApplier())
                 .restoreBundle(unzippedFolder.getAbsolutePath(), mWorkingFolder.getAbsolutePath(), BUNDLE_FILE_NAME);
 
         assertTrue(result.succeeded());
@@ -117,7 +117,7 @@ public class CodePushBinaryPatchTest {
     public void keepsARootHoldingLooseFilesBesidesTheDiffManifestAsItsOwnContentsRoot() throws IOException {
         writeFile(new File(mContentsFolder, CodePushConstants.DIFF_MANIFEST_FILE_NAME), bytes("{\"deletedFiles\":[]}"));
 
-        BinaryPatchResult result = restoreBundle(BASE_BUNDLE, succeedingApplier());
+        ArchiveRestoreResult result = restoreBundle(BASE_BUNDLE, succeedingApplier());
 
         assertTrue(result.succeeded());
         assertArrayEquals(TARGET_BUNDLE, readFile(mBundleFile));
@@ -129,7 +129,7 @@ public class CodePushBinaryPatchTest {
         assertTrue(mWorkingFolder.mkdirs());
         writeFile(new File(mWorkingFolder, CodePushConstants.BINARY_PATCH_TARGET_FILE_NAME), bytes("half a bundle"));
 
-        BinaryPatchResult result = restoreBundle(BASE_BUNDLE,
+        ArchiveRestoreResult result = restoreBundle(BASE_BUNDLE,
                 new FakePatchApplier(CodePushBinaryPatch.PatchApplier.RESULT_OK, TARGET_BUNDLE));
 
         assertTrue(result.succeeded());
@@ -141,14 +141,14 @@ public class CodePushBinaryPatchTest {
     public void reportsAnInvalidManifestWhenThereIsNone() {
         assertTrue(mManifestFile.delete());
 
-        assertFailure(BinaryPatchResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
     public void reportsAnInvalidManifestWhenItIsNotJson() throws IOException {
         writeFile(mManifestFile, bytes("not json at all"));
 
-        assertFailure(BinaryPatchResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
@@ -156,14 +156,14 @@ public class CodePushBinaryPatchTest {
         writeManifest(putValue(validManifest(), CodePushConstants.BINARY_PATCH_FORMAT_VERSION_KEY,
                 CodePushConstants.BINARY_PATCH_FORMAT_VERSION + 1));
 
-        assertFailure(BinaryPatchResult.REASON_UNSUPPORTED_FORMAT, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_UNSUPPORTED_FORMAT, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
     public void reportsAnUnsupportedFormatForAnotherAlgorithm() throws IOException {
         writeManifest(putValue(validManifest(), CodePushConstants.BINARY_PATCH_ALGORITHM_KEY, "bsdiff-bz2"));
 
-        assertFailure(BinaryPatchResult.REASON_UNSUPPORTED_FORMAT, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_UNSUPPORTED_FORMAT, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
@@ -171,7 +171,7 @@ public class CodePushBinaryPatchTest {
         writeManifest(putValue(validManifest(), CodePushConstants.BINARY_PATCH_BUNDLE_PATH_KEY,
                 "../" + BUNDLE_FILE_NAME));
 
-        assertFailure(BinaryPatchResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
         assertFalse(new File(mTemporaryFolder.getRoot(), BUNDLE_FILE_NAME).exists());
     }
 
@@ -180,7 +180,7 @@ public class CodePushBinaryPatchTest {
         writeFile(new File(mTemporaryFolder.getRoot(), PATCH_FILE_NAME), PATCH);
         writeManifest(putValue(validManifest(), CodePushConstants.BINARY_PATCH_FILE_KEY, "../" + PATCH_FILE_NAME));
 
-        assertFailure(BinaryPatchResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
@@ -188,21 +188,21 @@ public class CodePushBinaryPatchTest {
         writeManifest(putValue(validManifest(), CodePushConstants.BINARY_PATCH_BUNDLE_PATH_KEY,
                 new File(mTemporaryFolder.getRoot(), BUNDLE_FILE_NAME).getAbsolutePath()));
 
-        assertFailure(BinaryPatchResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
     public void reportsAnInvalidManifestWhenTheArchiveHasNoPatchFile() {
         assertTrue(mPatchFile.delete());
 
-        assertFailure(BinaryPatchResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
     public void reportsAnInvalidManifestWhenTheTargetSizeIsEmpty() throws IOException {
         writeManifest(putValue(validManifest(), CodePushConstants.BINARY_PATCH_TARGET_BUNDLE_SIZE_KEY, 0));
 
-        assertFailure(BinaryPatchResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
@@ -210,7 +210,7 @@ public class CodePushBinaryPatchTest {
         writeManifest(putValue(validManifest(), CodePushConstants.BINARY_PATCH_TARGET_BUNDLE_SIZE_KEY,
                 CodePushConstants.BINARY_PATCH_MAX_TARGET_BUNDLE_SIZE + 1));
 
-        assertFailure(BinaryPatchResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
+        assertFailure(ArchiveRestoreResult.REASON_INVALID_MANIFEST, restoreBundle(BASE_BUNDLE, succeedingApplier()));
     }
 
     @Test
@@ -222,50 +222,50 @@ public class CodePushBinaryPatchTest {
             }
         }, succeedingApplier());
 
-        assertFailure(BinaryPatchResult.REASON_BASE_BUNDLE_UNAVAILABLE, restoreBundle(binaryPatch));
+        assertFailure(ArchiveRestoreResult.REASON_BASE_BUNDLE_UNAVAILABLE, restoreBundle(binaryPatch));
     }
 
     @Test
     public void reportsABaseHashMismatchWhenTheBinaryHoldsAnotherBundle() {
         FakePatchApplier applier = new FakePatchApplier(CodePushBinaryPatch.PatchApplier.RESULT_OK, TARGET_BUNDLE);
 
-        BinaryPatchResult result = restoreBundle(bytes("a bundle from another app build"), applier);
+        ArchiveRestoreResult result = restoreBundle(bytes("a bundle from another app build"), applier);
 
-        assertFailure(BinaryPatchResult.REASON_BASE_HASH_MISMATCH, result);
+        assertFailure(ArchiveRestoreResult.REASON_BASE_HASH_MISMATCH, result);
         assertEquals("a patch is not applied to a base it was not computed against", 0, applier.invocationCount);
     }
 
     @Test
     public void reportsAnUnsupportedFormatWhenTheApplierRejectsTheCodec() {
-        BinaryPatchResult result = restoreBundle(BASE_BUNDLE,
+        ArchiveRestoreResult result = restoreBundle(BASE_BUNDLE,
                 new FakePatchApplier(CodePushBinaryPatch.PatchApplier.RESULT_UNSUPPORTED_COMPRESSION, null));
 
-        assertFailure(BinaryPatchResult.REASON_UNSUPPORTED_FORMAT, result);
+        assertFailure(ArchiveRestoreResult.REASON_UNSUPPORTED_FORMAT, result);
     }
 
     @Test
     public void reportsAFailedApplyWhenThePatchHeaderIsCorrupt() {
-        BinaryPatchResult result = restoreBundle(BASE_BUNDLE,
+        ArchiveRestoreResult result = restoreBundle(BASE_BUNDLE,
                 new FakePatchApplier(CodePushBinaryPatch.PatchApplier.RESULT_INVALID_HEADER, null));
 
-        assertFailure(BinaryPatchResult.REASON_PATCH_APPLY_FAILED, result);
+        assertFailure(ArchiveRestoreResult.REASON_PATCH_APPLY_FAILED, result);
         assertNoRestoredBundleInTheContents();
     }
 
     @Test
     public void reportsAFailedApplyWhenTheNativeLibraryIsMissing() {
-        BinaryPatchResult result = restoreBundle(BASE_BUNDLE,
+        ArchiveRestoreResult result = restoreBundle(BASE_BUNDLE,
                 new FakePatchApplier(CodePushBinaryPatch.PatchApplier.RESULT_LIBRARY_UNAVAILABLE, null));
 
-        assertFailure(BinaryPatchResult.REASON_PATCH_APPLY_FAILED, result);
+        assertFailure(ArchiveRestoreResult.REASON_PATCH_APPLY_FAILED, result);
     }
 
     @Test
     public void reportsAFailedVerificationWhenTheRestoredBundleHasAnotherSize() {
-        BinaryPatchResult result = restoreBundle(BASE_BUNDLE,
+        ArchiveRestoreResult result = restoreBundle(BASE_BUNDLE,
                 new FakePatchApplier(CodePushBinaryPatch.PatchApplier.RESULT_OK, bytes("too short")));
 
-        assertFailure(BinaryPatchResult.REASON_TARGET_VERIFICATION_FAILED, result);
+        assertFailure(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED, result);
         assertNoRestoredBundleInTheContents();
     }
 
@@ -276,23 +276,23 @@ public class CodePushBinaryPatchTest {
         byte[] wrongBundle = TARGET_BUNDLE.clone();
         wrongBundle[0] = (byte) (wrongBundle[0] ^ 0xFF);
 
-        BinaryPatchResult result = restoreBundle(BASE_BUNDLE,
+        ArchiveRestoreResult result = restoreBundle(BASE_BUNDLE,
                 new FakePatchApplier(CodePushBinaryPatch.PatchApplier.RESULT_OK, wrongBundle));
 
-        assertFailure(BinaryPatchResult.REASON_TARGET_VERIFICATION_FAILED, result);
+        assertFailure(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED, result);
         assertNoRestoredBundleInTheContents();
     }
 
-    private BinaryPatchResult restoreBundle(byte[] baseBundle, CodePushBinaryPatch.PatchApplier applier) {
+    private ArchiveRestoreResult restoreBundle(byte[] baseBundle, CodePushBinaryPatch.PatchApplier applier) {
         return restoreBundle(new CodePushBinaryPatch(providerOf(baseBundle), applier));
     }
 
-    private BinaryPatchResult restoreBundle(CodePushBinaryPatch binaryPatch) {
+    private ArchiveRestoreResult restoreBundle(CodePushBinaryPatch binaryPatch) {
         return binaryPatch.restoreBundle(mContentsFolder.getAbsolutePath(), mWorkingFolder.getAbsolutePath(),
                 BUNDLE_FILE_NAME);
     }
 
-    private void assertFailure(String expectedReason, BinaryPatchResult result) {
+    private void assertFailure(String expectedReason, ArchiveRestoreResult result) {
         assertFalse(result.succeeded());
         assertEquals(expectedReason, result.getFailureReason());
         assertNoTemporaryFilesLeft();

package/android/app/src/test/java/com/microsoft/codepush/react/CodePushErrorCodeTest.java

@@ -0,0 +1,90 @@
+package com.microsoft.codepush.react;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.ConnectException;
+import java.net.MalformedURLException;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+
+import javax.net.ssl.SSLHandshakeException;
+
+public class CodePushErrorCodeTest {
+
+    @Test
+    public void namesAConnectionThatDroppedAsANetworkFailure() {
+        // The message the reported majority of Android failures arrive with.
+        assertEquals(CodePushErrorCode.NETWORK,
+                CodePushErrorCode.of(new SocketException("Software caused connection abort")));
+    }
+
+    @Test
+    public void namesAConnectionThatTimedOutAsANetworkFailure() {
+        assertEquals(CodePushErrorCode.NETWORK, CodePushErrorCode.of(new SocketTimeoutException("timeout")));
+    }
+
+    @Test
+    public void namesAConnectionThatNeverOpenedAsANetworkFailure() {
+        assertEquals(CodePushErrorCode.NETWORK, CodePushErrorCode.of(new ConnectException("Connection refused")));
+        assertEquals(CodePushErrorCode.NETWORK, CodePushErrorCode.of(new UnknownHostException("cdn.example.test")));
+        assertEquals(CodePushErrorCode.NETWORK, CodePushErrorCode.of(new SSLHandshakeException("handshake failed")));
+    }
+
+    @Test
+    public void namesADownloadThatStoppedShortAsANetworkFailure() {
+        // The socket raised nothing for it, so only the byte count says the body was cut off.
+        Throwable error = new CodePushIncompleteDownloadException(1024, 4096);
+
+        assertEquals(CodePushErrorCode.NETWORK, CodePushErrorCode.of(error));
+        assertTrue(CodePushErrorCode.isNetworkFailure(error));
+    }
+
+    @Test
+    public void namesAnErrorStatusAsAnHttpFailureRatherThanANetworkOne() {
+        Throwable error = new CodePushHttpException("https://cdn.example.test/full.zip", 503);
+
+        assertEquals(CodePushErrorCode.HTTP, CodePushErrorCode.of(error));
+        assertFalse("a server that answered is not a network that failed",
+                CodePushErrorCode.isNetworkFailure(error));
+    }
+
+    @Test
+    public void namesAnUpdateThatIsNotWhatItClaimedAsAnIntegrityFailure() {
+        assertEquals(CodePushErrorCode.INTEGRITY,
+                CodePushErrorCode.of(new CodePushInvalidUpdateException("The update contents failed the data integrity check.")));
+    }
+
+    @Test
+    public void readsThroughTheWrapperADownloadCatchesItsFailuresIn() {
+        Throwable wrapped = new CodePushUnknownException("Error closing IO resources.",
+                new SocketException("Connection reset"));
+
+        assertEquals(CodePushErrorCode.NETWORK, CodePushErrorCode.of(wrapped));
+        assertTrue(CodePushErrorCode.isNetworkFailure(wrapped));
+    }
+
+    @Test
+    public void namesTheFailuresThatUsedToEscapeTheDownloadUncaught() {
+        // Neither is an `IOException`, so the download's old catch let them past and left
+        // the promise waiting on it unsettled. They are classified like anything else now.
+        assertEquals(CodePushErrorCode.UNKNOWN,
+                CodePushErrorCode.of(new CodePushMalformedDataException("not a url", new MalformedURLException())));
+        assertEquals(CodePushErrorCode.UNKNOWN,
+                CodePushErrorCode.of(new IllegalStateException("File is outside extraction target directory.")));
+    }
+
+    @Test
+    public void leavesAFailureNothingHasAWordForUnnamed() {
+        Throwable error = new IOException("the disk is full");
+
+        assertEquals(CodePushErrorCode.UNKNOWN, CodePushErrorCode.of(error));
+        assertFalse("an unnamed failure must not be retried as if the network caused it",
+                CodePushErrorCode.isNetworkFailure(error));
+    }
+}

package/android/app/src/test/java/com/microsoft/codepush/react/CodePushUpdateManagerBinaryPatchTest.java

@@ -15,19 +15,26 @@ import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
- * Which archive an update is downloaded from, and how the one download that is allowed to
- * fail falls back to the other one.
+ * Which archives an update is downloaded from, and how a failed one picks the next rung:
+ * the patch archive after an asset-side diff failure, the full archive after every other.
  */
 public class CodePushUpdateManagerBinaryPatchTest {
 
     private static final String BUNDLE_FILE_NAME = "index.android.bundle";
     private static final String FULL_ARCHIVE_URL = "https://example.test/updates/full.zip";
     private static final String PATCH_ARCHIVE_URL = "https://example.test/updates/full.zip-patch.zip";
+    private static final String DIFF_ARCHIVE_URL = "https://example.test/updates/diff-from-base.zip";
     /** Long enough that a timing that wrongly included it could not be mistaken for one that did not. */
     private static final long FULL_ARCHIVE_DOWNLOAD_DURATION_MS = 300;
+    /** Long enough that a total which dropped the attempt that installed could not be mistaken for one that kept it. */
+    private static final long PATCH_ARCHIVE_DOWNLOAD_DURATION_MS = 300;
 
     @Rule
     public TemporaryFolder mTemporaryFolder = new TemporaryFolder();
@@ -46,7 +53,7 @@ public class CodePushUpdateManagerBinaryPatchTest {
     @Test
     public void downloadsTheFullArchiveWhenTheUpdateHasNoBinaryPatch() throws IOException {
         RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
-                BinaryPatchResult.success());
+                ArchiveRestoreResult.success());
 
         JSONObject patchResult = updateManager.downloadPackage(updatePackage(null), BUNDLE_FILE_NAME, ignoreProgress());
 
@@ -58,7 +65,7 @@ public class CodePushUpdateManagerBinaryPatchTest {
     @Test
     public void downloadsOnlyTheBinaryPatchArchiveWhenThePatchApplies() throws IOException {
         RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
-                BinaryPatchResult.success());
+                ArchiveRestoreResult.success());
 
         JSONObject patchResult = updateManager.downloadPackage(updatePackage(PATCH_ARCHIVE_URL), BUNDLE_FILE_NAME,
                 ignoreProgress());
@@ -71,7 +78,7 @@ public class CodePushUpdateManagerBinaryPatchTest {
     @Test
     public void fallsBackToTheFullArchiveOnceWhenThePatchCannotBeApplied() throws IOException {
         RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
-                BinaryPatchResult.failure(BinaryPatchResult.REASON_BASE_HASH_MISMATCH));
+                ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_BASE_HASH_MISMATCH));
 
         JSONObject patchResult = updateManager.downloadPackage(updatePackage(PATCH_ARCHIVE_URL), BUNDLE_FILE_NAME,
                 ignoreProgress());
@@ -82,7 +89,7 @@ public class CodePushUpdateManagerBinaryPatchTest {
         assertEquals(Arrays.asList(true, false), updateManager.patchAttempts);
         assertEquals("fallback", patchResult.optString("status", null));
         // The reason travels to the app exactly as the applier worded it.
-        assertEquals(BinaryPatchResult.REASON_BASE_HASH_MISMATCH, patchResult.optString("fallbackReason", null));
+        assertEquals(ArchiveRestoreResult.REASON_BASE_HASH_MISMATCH, patchResult.optString("fallbackReason", null));
     }
 
     @Test
@@ -100,10 +107,115 @@ public class CodePushUpdateManagerBinaryPatchTest {
         assertFalse(patchResult.has("fallbackReason"));
     }
 
+    @Test
+    public void downloadsOnlyTheAssetDiffArchiveWhenTheDiffApplies() throws IOException {
+        RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
+                ArchiveRestoreResult.success());
+
+        JSONObject patchResult = updateManager.downloadPackage(updatePackage(PATCH_ARCHIVE_URL, DIFF_ARCHIVE_URL),
+                BUNDLE_FILE_NAME, ignoreProgress());
+
+        assertEquals(Arrays.asList(DIFF_ARCHIVE_URL), updateManager.downloadedUrls);
+        assertEquals("applied", patchResult.optString("status", null));
+        assertEquals("asset-diff", patchResult.optString("archive", null));
+        assertEquals(1, patchResult.optJSONArray("attempts").length());
+    }
+
+    @Test
+    public void fallsBackToThePatchArchiveWhenTheDiffFailsAfterItsBundleWasRestored() throws IOException {
+        RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
+                ArchiveRestoreResult.success());
+        updateManager.urlsRestoringTheBundle.add(DIFF_ARCHIVE_URL);
+        updateManager.patchOutcomesByUrl.put(DIFF_ARCHIVE_URL,
+                ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_ASSET_MERGE_FAILED));
+        updateManager.downloadDurationMsByUrl.put(PATCH_ARCHIVE_URL, PATCH_ARCHIVE_DOWNLOAD_DURATION_MS);
+
+        JSONObject patchResult = updateManager.downloadPackage(updatePackage(PATCH_ARCHIVE_URL, DIFF_ARCHIVE_URL),
+                BUNDLE_FILE_NAME, ignoreProgress());
+
+        // A failure after the restore is on the asset side of the diff, which the patch
+        // archive does not share - so the patch is the next rung, not the full archive.
+        assertEquals(Arrays.asList(DIFF_ARCHIVE_URL, PATCH_ARCHIVE_URL), updateManager.downloadedUrls);
+        assertEquals("applied", patchResult.optString("status", null));
+        assertEquals("binary-patch", patchResult.optString("archive", null));
+        assertEquals(2, patchResult.optJSONArray("attempts").length());
+        JSONObject diffAttempt = patchResult.optJSONArray("attempts").optJSONObject(0);
+        assertEquals("asset-diff", diffAttempt.optString("archive", null));
+        assertEquals(ArchiveRestoreResult.REASON_ASSET_MERGE_FAILED, diffAttempt.optString("fallbackReason", null));
+
+        // The path runs to the end, not to the moment the diff was given up on: the attempt
+        // that installed is most of it, so a total frozen at the first fallback would be
+        // smaller than the attempt it is supposed to contain.
+        long totalDurationMs = patchResult.optLong("totalDurationMs", -1);
+        long patchAttemptDurationMs = patchResult.optJSONArray("attempts").optJSONObject(1)
+                .optLong("durationMs", -1);
+        assertTrue("the total covers the attempt that installed: " + totalDurationMs + " ms total against "
+                        + patchAttemptDurationMs + " ms in that attempt alone",
+                totalDurationMs >= patchAttemptDurationMs);
+        assertTrue("the total covers the download the attempt that installed spent: " + totalDurationMs + " ms",
+                totalDurationMs >= PATCH_ARCHIVE_DOWNLOAD_DURATION_MS);
+    }
+
+    @Test
+    public void skipsThePatchArchiveWhenTheDiffFailedInTheBundlePatchBothArchivesCarry() throws IOException {
+        RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
+                ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_BASE_HASH_MISMATCH));
+
+        JSONObject patchResult = updateManager.downloadPackage(updatePackage(PATCH_ARCHIVE_URL, DIFF_ARCHIVE_URL),
+                BUNDLE_FILE_NAME, ignoreProgress());
+
+        // Both archives carry the same bundle patch, so the patch archive would fail the
+        // same way and is passed over for the full one.
+        assertEquals(Arrays.asList(DIFF_ARCHIVE_URL, FULL_ARCHIVE_URL), updateManager.downloadedUrls);
+        assertEquals("fallback", patchResult.optString("status", null));
+        assertEquals("asset-diff", patchResult.optString("archive", null));
+        assertEquals(ArchiveRestoreResult.REASON_BASE_HASH_MISMATCH, patchResult.optString("fallbackReason", null));
+        assertEquals(1, patchResult.optJSONArray("attempts").length());
+        assertFalse("an attempt that never restored the bundle has no apply to report",
+                patchResult.optJSONArray("attempts").optJSONObject(0).has("applyDurationMs"));
+    }
+
+    @Test
+    public void fallsBackToTheFullArchiveWhenTheDiffAndThePatchBothFail() throws IOException {
+        RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
+                ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED));
+        updateManager.urlsRestoringTheBundle.add(DIFF_ARCHIVE_URL);
+        updateManager.patchOutcomesByUrl.put(DIFF_ARCHIVE_URL,
+                ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_ASSET_MERGE_FAILED));
+
+        JSONObject patchResult = updateManager.downloadPackage(updatePackage(PATCH_ARCHIVE_URL, DIFF_ARCHIVE_URL),
+                BUNDLE_FILE_NAME, ignoreProgress());
+
+        assertEquals(Arrays.asList(DIFF_ARCHIVE_URL, PATCH_ARCHIVE_URL, FULL_ARCHIVE_URL),
+                updateManager.downloadedUrls);
+        assertEquals("fallback", patchResult.optString("status", null));
+        // The top of the result retells the last attempt; the chain holds them both.
+        assertEquals("binary-patch", patchResult.optString("archive", null));
+        assertEquals(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED,
+                patchResult.optString("fallbackReason", null));
+        assertEquals(ArchiveRestoreResult.REASON_ASSET_MERGE_FAILED,
+                patchResult.optJSONArray("attempts").optJSONObject(0).optString("fallbackReason", null));
+        assertEquals(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED,
+                patchResult.optJSONArray("attempts").optJSONObject(1).optString("fallbackReason", null));
+    }
+
+    @Test
+    public void fallsBackToTheFullArchiveWhenTheDiffFailsAndTheUpdateHasNoPatchArchive() throws IOException {
+        RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
+                ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_ASSET_MERGE_FAILED));
+        updateManager.urlsRestoringTheBundle.add(DIFF_ARCHIVE_URL);
+
+        JSONObject patchResult = updateManager.downloadPackage(updatePackage(null, DIFF_ARCHIVE_URL),
+                BUNDLE_FILE_NAME, ignoreProgress());
+
+        assertEquals(Arrays.asList(DIFF_ARCHIVE_URL, FULL_ARCHIVE_URL), updateManager.downloadedUrls);
+        assertEquals("fallback", patchResult.optString("status", null));
+    }
+
     @Test
     public void timesThePatchAttemptRatherThanTheDownloadThatFollowedIt() throws IOException {
         RecordingUpdateManager updateManager = new RecordingUpdateManager(mDocumentsDirectory,
-                BinaryPatchResult.failure(BinaryPatchResult.REASON_PATCH_APPLY_FAILED));
+                ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_PATCH_APPLY_FAILED));
         updateManager.fullArchiveDownloadDurationMs = FULL_ARCHIVE_DOWNLOAD_DURATION_MS;
 
         JSONObject patchResult = updateManager.downloadPackage(updatePackage(PATCH_ARCHIVE_URL), BUNDLE_FILE_NAME,
@@ -111,17 +223,17 @@ public class CodePushUpdateManagerBinaryPatchTest {
 
         // The attempt was over before the full archive was even asked for, so what it reports
         // is time the patch spent and nothing else.
-        long reportedDurationMs = patchResult.optLong("applyDurationMs", -1);
+        long reportedDurationMs = patchResult.optLong("totalDurationMs", -1);
         assertTrue("the fallback is timed over the download that followed it: " + reportedDurationMs + " ms",
                 reportedDurationMs >= 0 && reportedDurationMs < FULL_ARCHIVE_DOWNLOAD_DURATION_MS);
     }
 
     @Test
     public void removesTheBinaryPatchWorkingDirectoryWhateverTheOutcomeIs() throws IOException {
-        List<BinaryPatchResult> outcomes = Arrays.asList(BinaryPatchResult.success(),
-                BinaryPatchResult.failure(BinaryPatchResult.REASON_TARGET_VERIFICATION_FAILED), null);
+        List<ArchiveRestoreResult> outcomes = Arrays.asList(ArchiveRestoreResult.success(),
+                ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED), null);
 
-        for (BinaryPatchResult outcome : outcomes) {
+        for (ArchiveRestoreResult outcome : outcomes) {
             assertTrue(mBinaryPatchFolder.mkdirs());
             assertTrue(new File(mBinaryPatchFolder, CodePushConstants.BINARY_PATCH_TARGET_FILE_NAME).createNewFile());
 
@@ -133,6 +245,10 @@ public class CodePushUpdateManagerBinaryPatchTest {
     }
 
     private static JSONObject updatePackage(String binaryPatchDownloadUrl) {
+        return updatePackage(binaryPatchDownloadUrl, null);
+    }
+
+    private static JSONObject updatePackage(String binaryPatchDownloadUrl, String assetDiffDownloadUrl) {
         JSONObject updatePackage = new JSONObject();
         CodePushUtils.setJSONValueForKey(updatePackage, CodePushConstants.PACKAGE_HASH_KEY, "package-hash");
         CodePushUtils.setJSONValueForKey(updatePackage, CodePushConstants.DOWNLOAD_URL_KEY, FULL_ARCHIVE_URL);
@@ -140,6 +256,10 @@ public class CodePushUpdateManagerBinaryPatchTest {
             CodePushUtils.setJSONValueForKey(updatePackage, CodePushConstants.BINARY_PATCH_DOWNLOAD_URL_KEY,
                     binaryPatchDownloadUrl);
         }
+        if (assetDiffDownloadUrl != null) {
+            CodePushUtils.setJSONValueForKey(updatePackage, CodePushConstants.ASSET_DIFF_DOWNLOAD_URL_KEY,
+                    assetDiffDownloadUrl);
+        }
 
         return updatePackage;
     }
@@ -163,37 +283,57 @@ public class CodePushUpdateManagerBinaryPatchTest {
      */
     private static class RecordingUpdateManager extends CodePushUpdateManager {
 
-        private final BinaryPatchResult mPatchOutcome;
+        private final ArchiveRestoreResult mPatchOutcome;
 
         final List<String> downloadedUrls = new ArrayList<>();
         final List<Boolean> patchAttempts = new ArrayList<>();
 
+        /** Outcomes for one archive at a time; every other archive ends in the shared one. */
+        final Map<String, ArchiveRestoreResult> patchOutcomesByUrl = new HashMap<>();
+
+        /** Archives whose attempt restores the bundle before it ends, whichever way it ends. */
+        final Set<String> urlsRestoringTheBundle = new HashSet<>();
+
         /** How long the full archive takes to download, for timings that must not include it. */
         long fullArchiveDownloadDurationMs = 0;
 
-        /** @param patchOutcome what the patch download ends in, or null when it cannot be downloaded */
-        RecordingUpdateManager(String documentsDirectory, BinaryPatchResult patchOutcome) {
+        /** How long one archive takes to download, for timings that have to tell the attempts apart. */
+        final Map<String, Long> downloadDurationMsByUrl = new HashMap<>();
+
+        /** @param patchOutcome what a patch download ends in, or null when it cannot be downloaded */
+        RecordingUpdateManager(String documentsDirectory, ArchiveRestoreResult patchOutcome) {
             super(documentsDirectory, (CodePushBinaryPatch) null);
             mPatchOutcome = patchOutcome;
         }
 
         @Override
-        BinaryPatchResult downloadAndInstallPackage(JSONObject updatePackage, String expectedBundleFileName,
+        ArchiveRestoreResult downloadAndInstallPackage(JSONObject updatePackage, String expectedBundleFileName,
                                                     DownloadProgressCallback progressCallback,
                                                     String downloadUrlString, boolean isBinaryPatchUpdate,
-                                                    BinaryPatchAttempt patchAttempt) throws IOException {
+                                                    ArchiveAttemptLog patchAttempt) throws IOException {
             downloadedUrls.add(downloadUrlString);
             patchAttempts.add(isBinaryPatchUpdate);
+            if (downloadDurationMsByUrl.containsKey(downloadUrlString)) {
+                sleep(downloadDurationMsByUrl.get(downloadUrlString));
+            }
 
             if (!isBinaryPatchUpdate) {
                 sleep(fullArchiveDownloadDurationMs);
-                return BinaryPatchResult.success();
+                return ArchiveRestoreResult.success();
             }
-            if (mPatchOutcome == null) {
+
+            if (urlsRestoringTheBundle.contains(downloadUrlString)) {
+                patchAttempt.recordBundleRestored(1);
+            }
+
+            ArchiveRestoreResult outcome = patchOutcomesByUrl.containsKey(downloadUrlString)
+                    ? patchOutcomesByUrl.get(downloadUrlString)
+                    : mPatchOutcome;
+            if (outcome == null) {
                 throw new IOException("the binary patch archive is not there");
             }
 
-            return mPatchOutcome;
+            return outcome;
         }
 
         private static void sleep(long durationMs) {