Add delta support to the update test harness.

bin/cros_au_test_harness.py

 #!/usr/bin/python
 
 # Copyright (c) 2010 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.
 
 import optparse
 import os
 import sys
 import unittest
@@ skipping 15 matching lines @@
 global board
 global remote
 global target_image_path
 global vm_graphics_flag
 
 
 _VERIFY_SUITE = 'suite_Smoke'
 
 class AUTest(object):
   """Abstract interface that defines an Auto Update test."""
+  source_image = ''
+  use_delta_updates = False
 
   def setUp(self):
     unittest.TestCase.setUp(self)
     # Set these up as they are used often.
     self.crosutils = os.path.join(os.path.dirname(__file__), '..')
     self.crosutilsbin = os.path.join(os.path.dirname(__file__))
 
   def GetStatefulChangeFlag(self, stateful_change):
     """Returns the flag to pass to image_to_vm for the stateful change."""
     stateful_change_flag = ''
@@ skipping 76 matching lines @@
     This test checks that we can update by updating the stateful partition
     rather than wiping it.
     """
     # Just make sure some tests pass on original image.  Some old images
     # don't pass many tests.
     self.PrepareBase()
     # TODO(sosa): move to 100% once we start testing using the autotest paired
     # with the dev channel.
     percent_passed = self.VerifyImage(10)
 
+    if self.use_delta_updates: self.source_image = base_image_path
+
     # Update to - all tests should pass on new image.
     Info('Updating from base image on vm to target image.')
     self.UpdateImage(target_image_path)
     self.VerifyImage(100)
 
+    if self.use_delta_updates: self.source_image = target_image_path
+
     # Update from - same percentage should pass that originally passed.
     Info('Updating from updated image on vm back to base image.')
     self.UpdateImage(base_image_path)
     self.VerifyImage(percent_passed)
 
   # TODO(sosa): Re-enable once we have a good way of checking for version
   # compatibility.
   def testFullUpdateWipeStateful(self):
     """Tests if we can update after cleaning the stateful partition.
 
     This test checks that we can update successfully after wiping the
     stateful partition.
     """
     # Just make sure some tests pass on original image.  Some old images
     # don't pass many tests.
     self.PrepareBase()
     # TODO(sosa): move to 100% once we start testing using the autotest paired
     # with the dev channel.
     percent_passed = self.VerifyImage(10)
 
+    if self.use_delta_updates: self.source_image = base_image_path
+
     # Update to - all tests should pass on new image.
     Info('Updating from base image on vm to target image and wiping stateful.')
     self.UpdateImage(target_image_path, 'clean')
     self.VerifyImage(100)
 
+    if self.use_delta_updates: self.source_image = target_image_path
+
     # Update from - same percentage should pass that originally passed.
     Info('Updating from updated image back to base image and wiping stateful.')
     self.UpdateImage(base_image_path, 'clean')
     self.VerifyImage(percent_passed)
 
 
 class RealAUTest(unittest.TestCase, AUTest):
   """Test harness for updating real images."""
 
   def setUp(self):
     AUTest.setUp(self)
 
   def PrepareBase(self):
     """Auto-update to base image to prepare for test."""
     self.UpdateImage(base_image_path)
 
   def UpdateImage(self, image_path, stateful_change='old'):
     """Updates a remote image using image_to_live.sh."""
     stateful_change_flag = self.GetStatefulChangeFlag(stateful_change)
 
     RunCommand([
         '%s/image_to_live.sh' % self.crosutils,
         '--image=%s' % image_path,
         '--remote=%s' % remote,
         stateful_change_flag,
         '--verify',
+        '--src_image=%s' % self.source_image,
         ], enter_chroot=False)
 
 
   def VerifyImage(self, percent_required_to_pass):
     """Verifies an image using run_remote_tests.sh with verification suite."""
     output = RunCommand([
         '%s/run_remote_tests.sh' % self.crosutils,
         '--remote=%s' % remote,
         _VERIFY_SUITE,
        ], error_ok=True, enter_chroot=False, redirect_stdout=True)
@@ skipping 45 matching lines @@
     stateful_change_flag = self.GetStatefulChangeFlag(stateful_change)
 
     RunCommand(['%s/cros_run_vm_update' % self.crosutilsbin,
                 '--update_image_path=%s' % image_path,
                 '--vm_image_path=%s' % self.vm_image_path,
                 '--snapshot',
                 vm_graphics_flag,
                 '--persist',
                 '--kvm_pid=%s' % _KVM_PID_FILE,
                 stateful_change_flag,
+                '--src_image=%s' % self.source_image,
                ], enter_chroot=False)
 
   def VerifyImage(self, percent_required_to_pass):
     """Runs vm smoke suite to verify image."""
     # image_to_live already verifies lsb-release matching.  This is just
     # for additional steps.
     output = RunCommand(['%s/cros_run_vm_test' % self.crosutilsbin,
                          '--image_path=%s' % self.vm_image_path,
                          '--snapshot',
                          '--persist',
@@ skipping 12 matching lines @@
   parser.add_option('-t', '--target_image',
                     help='path to the target image.')
   parser.add_option('-r', '--board',
                     help='board for the images.')
   parser.add_option('-p', '--type', default='vm',
                     help='type of test to run: [vm, real]. Default: vm.')
   parser.add_option('-m', '--remote',
                     help='Remote address for real test.')
   parser.add_option('--no_graphics', action='store_true',
                     help='Disable graphics for the vm test.')
+  parser.add_option('--no_delta', action='store_false', default=True,
+                    dest='delta',
+                    help='Disable using delta updates.')
   # Set the usage to include flags.
   parser.set_usage(parser.format_help())
   # Parse existing sys.argv so we can pass rest to unittest.main.
   (options, sys.argv) = parser.parse_args(sys.argv)
 
   base_image_path = options.base_image
   target_image_path = options.target_image
   board = options.board
 
   if not base_image_path:
     parser.error('Need path to base image for vm.')
   elif not os.path.exists(base_image_path):
     Die('%s does not exist' % base_image_path)
 
   if not target_image_path:
     parser.error('Need path to target image to update with.')
   elif not os.path.exists(target_image_path):
     Die('%s does not exist' % target_image_path)
 
   if not board:
     parser.error('Need board to convert base image to vm.')
 
+  # Communicate flags to tests.
   vm_graphics_flag = ''
   if options.no_graphics: vm_graphics_flag = '--no_graphics'
 
+  AUTest.use_delta_updates = options.delta
+
   # Only run the test harness we care about.
   if options.type == 'vm':
     suite = unittest.TestLoader().loadTestsFromTestCase(VirtualAUTest)
     test_result = unittest.TextTestRunner(verbosity=2).run(suite)
   elif options.type == 'real':
     if not options.remote:
       parser.error('Real tests require a remote test machine.')
     else:
       remote = options.remote
 
     suite = unittest.TestLoader().loadTestsFromTestCase(RealAUTest)
     test_result = unittest.TextTestRunner(verbosity=2).run(suite)
   else:
     parser.error('Could not parse harness type %s.' % options.type)
 
   if not test_result.wasSuccessful():
     Die('Test harness was not successful')