Add some desired options to the au 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 re
 import sys
@@ skipping 12 matching lines @@
 _FULL_VDISK_SIZE = 6072
 _FULL_STATEFULFS_SIZE = 3074
 _KVM_PID_FILE = '/tmp/harness_pid'
 _VERIFY_SUITE = 'suite_Smoke'
 
 # Globals to communicate options to unit tests.
 global base_image_path
 global board
 global remote
 global target_image_path
+global run_command
 global vm_graphics_flag
 
 class UpdateException(Exception):
   """Exception thrown when UpdateImage or UpdateUsingPayload fail"""
   def __init__(self, code, stdout):
     self.code = code
     self.stdout = stdout
 
 class AUTest(object):
   """Abstract interface that defines an Auto Update test."""
@@ skipping 28 matching lines @@
         break
 
     return int(percent_passed)
 
   # TODO(sosa) - Remove try and convert function to DeltaUpdateImage().
   def TryDeltaAndFallbackToFull(self, src_image, image, stateful_change='old'):
     """Tries the delta update first if set and falls back to full update."""
     if self.use_delta_updates:
       try:
         self.source_image = src_image
-        self.UpdateImage(image)
+        self._UpdateImageReportError(image)
       except:
         Warning('Delta update failed, disabling delta updates and retrying.')
         self.use_delta_updates = False
         self.source_image = ''
         self._UpdateImageReportError(image)
     else:
       self._UpdateImageReportError(image)
 
   def _UpdateImageReportError(self, image_path, stateful_change='old'):
     """Calls UpdateImage and reports any error to the console.
-    
+
        Still throws the exception.
     """
     try:
       self.UpdateImage(image_path, stateful_change)
     except UpdateException as err:
       # If the update fails, print it out
       Warning(err.stdout)
       raise
 
   def _AttemptUpdateWithPayloadExpectedFailure(self, payload, expected_msg):
@@ skipping 57 matching lines @@
 
     Args:
       unittest: Handle to the unittest.
       output: stdout from a test run.
       percent_required_to_pass: percentage required to pass.  This should be
         fall between 0-100.
     Returns:
       percent that passed.
     """
     Info('Output from VerifyImage():')
-    print output
+    print >> sys.stderr, output
+    sys.stderr.flush()
     percent_passed = self.ParseGenerateTestReportOutput(output)
     Info('Percent passed: %d vs. Percent required: %d' % (
         percent_passed, percent_required_to_pass))
     unittest.assertTrue(percent_passed >=
                         percent_required_to_pass)
     return percent_passed
 
   def testFullUpdateKeepStateful(self):
     """Tests if we can update normally.
 
@@ skipping 47 matching lines @@
 
     # Image can be updated at:
     # ~chrome-eng/chromeos/localmirror/autest-images
     url = 'http://gsdview.appspot.com/chromeos-localmirror/' \
           'autest-images/truncated_image.gz'
     payload = os.path.join(self.download_folder, 'truncated_image.gz')
 
     # Read from the URL and write to the local file
     urllib.urlretrieve(url, payload)
 
-    expected_msg='download_hash_data == update_check_response_hash failed'
+    expected_msg = 'download_hash_data == update_check_response_hash failed'
     self._AttemptUpdateWithPayloadExpectedFailure(payload, expected_msg)
 
   def testCorruptedUpdate(self):
     """Tests what happens if we attempt to update with a corrupted payload."""
     # Preload with the version we are trying to test.
     self.PrepareBase(image_path=target_image_path)
 
     # Image can be updated at:
     # ~chrome-eng/chromeos/localmirror/autest-images
     url = 'http://gsdview.appspot.com/chromeos-localmirror/' \
           'autest-images/corrupted_image.gz'
     payload = os.path.join(self.download_folder, 'corrupted.gz')
 
     # Read from the URL and write to the local file
     urllib.urlretrieve(url, payload)
 
     # This update is expected to fail...
-    expected_msg='zlib inflate() error:-3'
+    expected_msg = 'zlib inflate() error:-3'
     self._AttemptUpdateWithPayloadExpectedFailure(payload, expected_msg)
 
 class RealAUTest(unittest.TestCase, AUTest):
   """Test harness for updating real images."""
 
   def setUp(self):
     AUTest.setUp(self)
 
   def PrepareBase(self, image_path):
     """Auto-update to base image to prepare for test."""
     self._UpdateImageReportError(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)
 
-    (code, stdout, stderr) = RunCommandCaptureOutput([
+    (code, stdout, stderr) = run_command([
         '%s/image_to_live.sh' % self.crosutils,
         '--image=%s' % image_path,
         '--remote=%s' % remote,
         stateful_change_flag,
         '--verify',
         '--src_image=%s' % self.source_image
         ])
 
     if code != 0:
       raise UpdateException(code, stdout)
 
   def UpdateUsingPayload(self, update_path, stateful_change='old'):
     """Updates a remote image using image_to_live.sh."""
     stateful_change_flag = self.GetStatefulChangeFlag(stateful_change)
 
-    (code, stdout, stderr) = RunCommandCaptureOutput([
+    (code, stdout, stderr) = run_command([
         '%s/image_to_live.sh' % self.crosutils,
         '--payload=%s' % update_path,
         '--remote=%s' % remote,
         stateful_change_flag,
         '--verify',
         ])
 
     if code != 0:
       raise UpdateException(code, stdout)
 
@@ skipping 24 matching lines @@
 
   def setUp(self):
     """Unit test overriden method.  Is called before every test."""
     AUTest.setUp(self)
     self._KillExistingVM(_KVM_PID_FILE)
 
   def PrepareBase(self, image_path):
     """Creates an update-able VM based on base image."""
     self.vm_image_path = '%s/chromiumos_qemu_image.bin' % os.path.dirname(
         image_path)
-    
+
     Info('Creating: %s' % self.vm_image_path)
 
     if not os.path.exists(self.vm_image_path):
       Info('Qemu image %s not found, creating one.' % self.vm_image_path)
       RunCommand(['%s/image_to_vm.sh' % self.crosutils,
                   '--full',
                   '--from=%s' % ReinterpretPathForChroot(
                       os.path.dirname(image_path)),
                   '--vdisk_size=%s' % _FULL_VDISK_SIZE,
                   '--statefulfs_size=%s' % _FULL_STATEFULFS_SIZE,
                   '--board=%s' % board,
                   '--test_image'], enter_chroot=True)
     else:
       Info('Using existing VM image %s' % self.vm_image_path)
 
 
     Info('Testing for %s' % self.vm_image_path)
 
     self.assertTrue(os.path.exists(self.vm_image_path))
 
   def UpdateImage(self, image_path, stateful_change='old'):
     """Updates VM image with image_path."""
     stateful_change_flag = self.GetStatefulChangeFlag(stateful_change)
     if self.source_image == base_image_path:
       self.source_image = self.vm_image_path
 
-    (code, stdout, stderr) = RunCommandCaptureOutput([
+    (code, stdout, stderr) = run_command([
         '%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,
         ])
 
     if code != 0:
       raise UpdateException(code, stdout)
 
   def UpdateUsingPayload(self, update_path, stateful_change='old'):
     """Updates a remote image using image_to_live.sh."""
     stateful_change_flag = self.GetStatefulChangeFlag(stateful_change)
     if self.source_image == base_image_path:
       self.source_image = self.vm_image_path
 
-    (code, stdout, stderr) = RunCommandCaptureOutput([
+    (code, stdout, stderr) = run_command([
         '%s/cros_run_vm_update' % self.crosutilsbin,
         '--payload=%s' % update_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,
         ])
@@ skipping 19 matching lines @@
 
     output = RunCommand(commandWithArgs, error_ok=True, enter_chroot=False,
                         redirect_stdout=True)
     return self.CommonVerifyImage(self, output, percent_required_to_pass)
 
 
 if __name__ == '__main__':
   parser = optparse.OptionParser()
   parser.add_option('-b', '--base_image',
                     help='path to the base image.')
-  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.')
+  parser.add_option('--no_graphics', action='store_true',

[sosa, 2010/12/03 22:33:28]

I just sorted this by long name

+                    help='Disable graphics for the vm test.')
+  parser.add_option('-m', '--remote',
+                    help='Remote address for real test.')
   parser.add_option('-q', '--quick_test', default=False, action='store_true',
                     help='Use a basic test to verify image.')
+  parser.add_option('-t', '--target_image',
+                    help='path to the target image.')
+  parser.add_option('--test_prefix', default='test',
+                    help='Only runs tests with specific prefix i.e. '
+                         'testFullUpdateWipeStateful.')
+  parser.add_option('-p', '--type', default='vm',
+                    help='type of test to run: [vm, real]. Default: vm.')
+  parser.add_option('--verbose', default=False, action='store_true',
+                    help='Print out rather than capture output as much as '
+                         'possible.')
   # 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
+  run_command = RunCommandCaptureOutput
+  if options.verbose: run_command = RunCommand

[dgarrett, 2010/12/06 18:35:23]

This isn't quite what I thought you meant when we discussed this. RunCommand and
RunCommandCaptureOutput don't have the same signatures, especially the return
value(s) are different.

RunCommand returns either the error code, or the output of the command, but not
both.

RunCommandCaptureOutput captures everything and returns all of it as a tuple.

The run_command calls above will fail with --verbose when trying to unpack the
results.

 
   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'
   if options.quick_test: _VERIFY_SUITE = 'build_RootFilesystemSize'
   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
+  test_loader = unittest.TestLoader()
+  test_loader.testMethodPrefix = options.test_prefix

[sosa, 2010/12/03 22:33:28]

Cleaned this up to make it easier to read and put common stuff together

 
-    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 options.type == 'vm':  test_class = VirtualAUTest
+  elif options.type == 'real': test_class = RealAUTest
+  else: parser.error('Could not parse harness type %s.' % options.type)
+
+  test_suite = test_loader.loadTestsFromTestCase(test_class)
+  test_result = unittest.TextTestRunner(verbosity=2).run(test_suite)
 
   if not test_result.wasSuccessful():
     Die('Test harness was not successful')