AU: Don't send no-op operations in the delta payload.

delta_performer_unittest.cc

 // Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <sys/mount.h>
 #include <inttypes.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
+#include <base/file_util.h>
 #include <base/scoped_ptr.h>
 #include <base/string_util.h>
 #include <google/protobuf/repeated_field.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/delta_diff_generator.h"
 #include "update_engine/delta_performer.h"
 #include "update_engine/extent_ranges.h"
 #include "update_engine/graph_types.h"
 #include "update_engine/payload_signer.h"
@@ skipping 83 matching lines @@
   int fd = open(path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0644);
   TEST_AND_RETURN_FALSE_ERRNO(fd >= 0);
   ScopedFdCloser fd_closer(&fd);
   off_t rc = lseek(fd, size + 1, SEEK_SET);
   TEST_AND_RETURN_FALSE_ERRNO(rc != static_cast<off_t>(-1));
   int return_code = ftruncate(fd, size);
   TEST_AND_RETURN_FALSE_ERRNO(return_code == 0);
   return true;
 }
 
-void DoSmallImageTest(bool full_kernel) {
+void DoSmallImageTest(bool full_kernel, bool noop) {
   string a_img, b_img;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/a_img.XXXXXX", &a_img, NULL));
   ScopedPathUnlinker a_img_unlinker(a_img);
   EXPECT_TRUE(utils::MakeTempFile("/tmp/b_img.XXXXXX", &b_img, NULL));
   ScopedPathUnlinker b_img_unlinker(b_img);
 
   CreateExtImageAtPath(a_img, NULL);
-  CreateExtImageAtPath(b_img, NULL);
 
   int image_size = static_cast<int>(utils::FileSize(a_img));
 
   // Extend the "partitions" holding the file system a bit.
   EXPECT_EQ(0, System(base::StringPrintf(
       "dd if=/dev/zero of=%s seek=%d bs=1 count=1",
       a_img.c_str(),
       image_size + 1024 * 1024 - 1)));
-  EXPECT_EQ(0, System(base::StringPrintf(
-      "dd if=/dev/zero of=%s seek=%d bs=1 count=1",
-      b_img.c_str(),
-      image_size + 1024 * 1024 - 1)));
   EXPECT_EQ(image_size + 1024 * 1024, utils::FileSize(a_img));
-  EXPECT_EQ(image_size + 1024 * 1024, utils::FileSize(b_img));
 
   // Make some changes to the A image.
   {
     string a_mnt;
     ScopedLoopMounter b_mounter(a_img, &a_mnt, 0);
 
     EXPECT_TRUE(utils::WriteFile(StringPrintf("%s/hardtocompress",
                                               a_mnt.c_str()).c_str(),
                                  reinterpret_cast<const char*>(kRandomString),
                                  sizeof(kRandomString) - 1));
     // Write 1 MiB of 0xff to try to catch the case where writing a bsdiff
     // patch fails to zero out the final block.
     vector<char> ones(1024 * 1024, 0xff);
     EXPECT_TRUE(utils::WriteFile(StringPrintf("%s/ones",
                                               a_mnt.c_str()).c_str(),
                                  &ones[0],
                                  ones.size()));
   }
 
-  // Make some changes to the B image.
-  {
+  if (noop) {
+    EXPECT_TRUE(file_util::CopyFile(FilePath(a_img), FilePath(b_img)));
+  } else {
+    CreateExtImageAtPath(b_img, NULL);
+    EXPECT_EQ(0, System(base::StringPrintf(
+        "dd if=/dev/zero of=%s seek=%d bs=1 count=1",
+        b_img.c_str(),
+        image_size + 1024 * 1024 - 1)));
+    EXPECT_EQ(image_size + 1024 * 1024, utils::FileSize(b_img));
+
+    // Make some changes to the B image.
     string b_mnt;
     ScopedLoopMounter b_mounter(b_img, &b_mnt, 0);
 
     EXPECT_EQ(0, system(StringPrintf("cp %s/hello %s/hello2", b_mnt.c_str(),
                                      b_mnt.c_str()).c_str()));
     EXPECT_EQ(0, system(StringPrintf("rm %s/hello", b_mnt.c_str()).c_str()));
     EXPECT_EQ(0, system(StringPrintf("mv %s/hello2 %s/hello", b_mnt.c_str(),
                                      b_mnt.c_str()).c_str()));
     EXPECT_EQ(0, system(StringPrintf("echo foo > %s/foo",
                                      b_mnt.c_str()).c_str()));
@@ skipping 20 matching lines @@
 
   vector<char> old_kernel_data(4096);  // Something small for a test
   vector<char> new_kernel_data(old_kernel_data.size());
   FillWithData(&old_kernel_data);
   FillWithData(&new_kernel_data);
 
   // change the new kernel data
   const char* new_data_string = "This is new data.";
   strcpy(&new_kernel_data[0], new_data_string);
 
+  if (noop) {
+    old_kernel_data = new_kernel_data;
+  }
+
   // Write kernels to disk
   EXPECT_TRUE(utils::WriteFile(
       old_kernel.c_str(), &old_kernel_data[0], old_kernel_data.size()));
   EXPECT_TRUE(utils::WriteFile(
       new_kernel.c_str(), &new_kernel_data[0], new_kernel_data.size()));
 
   string delta_path;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/delta.XXXXXX", &delta_path, NULL));
   LOG(INFO) << "delta path: " << delta_path;
   ScopedPathUnlinker delta_path_unlinker(delta_path);
@@ skipping 42 matching lines @@
     EXPECT_EQ(1, sigs_message.signatures_size());
     const Signatures_Signature& signature = sigs_message.signatures(0);
     EXPECT_EQ(1, signature.version());
 
     uint64_t expected_sig_data_length = 0;
     EXPECT_TRUE(PayloadSigner::SignatureBlobLength(kUnittestPrivateKeyPath,
                                                    &expected_sig_data_length));
     EXPECT_EQ(expected_sig_data_length, manifest.signatures_size());
     EXPECT_FALSE(signature.data().empty());
 
+    if (noop) {
+      EXPECT_EQ(1, manifest.install_operations_size());
+      EXPECT_EQ(1, manifest.kernel_install_operations_size());
+    }
+
     if (full_kernel) {
       EXPECT_FALSE(manifest.has_old_kernel_info());
     } else {
       EXPECT_EQ(old_kernel_data.size(), manifest.old_kernel_info().size());
       EXPECT_FALSE(manifest.old_kernel_info().hash().empty());
     }
 
     EXPECT_EQ(new_kernel_data.size(), manifest.new_kernel_info().size());
     EXPECT_EQ(image_size, manifest.old_rootfs_info().size());
     EXPECT_EQ(image_size, manifest.new_rootfs_info().size());
@@ skipping 55 matching lines @@
   EXPECT_TRUE(utils::FileExists(kUnittestPublicKeyPath));
   EXPECT_TRUE(performer.VerifyPayload(
       kUnittestPublicKeyPath,
       OmahaHashCalculator::OmahaHashOfData(delta),
       delta.size()));
   EXPECT_TRUE(performer.VerifyAppliedUpdate(a_img, old_kernel));
 }
 }
 
 TEST(DeltaPerformerTest, RunAsRootSmallImageTest) {
-  DoSmallImageTest(false);
+  DoSmallImageTest(false, false);
 }
 
 TEST(DeltaPerformerTest, RunAsRootFullKernelSmallImageTest) {
-  DoSmallImageTest(true);
+  DoSmallImageTest(true, false);
+}
+
+TEST(DeltaPerformerTest, RunAsRootNoopSmallImageTest) {
+  DoSmallImageTest(false, true);
 }
 
 TEST(DeltaPerformerTest, NewFullUpdateTest) {
   vector<char> new_root(20 * 1024 * 1024);
   vector<char> new_kern(16 * 1024 * 1024);
   const off_t kChunkSize = 128 * 1024;
   FillWithData(&new_root);
   FillWithData(&new_kern);
   // Assume hashes take 2 MiB beyond the rootfs.
   off_t new_rootfs_size = new_root.size() - 2 * 1024 * 1024;
@@ skipping 63 matching lines @@
   op.clear_src_extents();
   *(op.add_src_extents()) = ExtentForRange(5, 3);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_dst_extents()) = ExtentForRange(20, 6);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_src_extents()) = ExtentForRange(19, 2);
   EXPECT_FALSE(DeltaPerformer::IsIdempotentOperation(op));
 }
 
 }  // namespace chromeos_update_engine