Add components to pass vm flag to dev server.

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
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '../lib'))
 from cros_build_lib import Die
 from cros_build_lib import Info
 from cros_build_lib import ReinterpretPathForChroot
 from cros_build_lib import RunCommand
 from cros_build_lib import Warning
 
-
-_KVM_PID_FILE = '/tmp/harness_pid'
+# VM Constants.
 _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 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__))
@@ skipping 198 matching lines @@
                    enter_chroot=False)
         RunCommand(['sudo', 'rm', pid_file], enter_chroot=False)
 
   def setUp(self):
     """Unit test overriden method.  Is called before every test."""
     AUTest.setUp(self)
     self._KillExistingVM(_KVM_PID_FILE)
 
   def PrepareBase(self):
     """Creates an update-able VM based on base image."""
+    self.vm_image_path = '%s/chromiumos_qemu_image.bin' % os.path.dirname(
+        base_image_path)
 
-    self.vm_image_path = ('%s/chromiumos_qemu_image.bin' % os.path.dirname(
-          base_image_path))
     if not os.path.exists(self.vm_image_path):
-      Info('Qemu image not found, creating one.')
+      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(base_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')
+      Info('Using existing VM image %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
 
     RunCommand(['%s/cros_run_vm_update' % self.crosutilsbin,
@@ skipping 33 matching lines @@
                     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('-q', '--quick_test', default=False, action='store_true',
+                    help='Use a basic test to verify image.')
   # 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'
-
+  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
 
     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')