Emit actions and states from test_installer.py when not in quiet mode.

chrome/test/mini_installer/test_installer.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """This script tests the installer with test cases specified in the config file.
 
 For each test case, it checks that the machine states after the execution of
 each command match the expected machine states. For more details, take a look at
 the design documentation at http://goo.gl/Q0rGM6
 """
@@ skipping 22 matching lines @@
   """
   def __init__(self):
     self.states = {}
     self.actions = {}
     self.tests = []
 
 
 class InstallerTest(unittest.TestCase):
   """Tests a test case in the config file."""
 
-  def __init__(self, name, test, config, variable_expander):
+  def __init__(self, name, test, config, variable_expander, quiet):
     """Constructor.
 
     Args:
       name: The name of this test.
       test: An array of alternating state names and action names, starting and
           ending with state names.
       config: The Config object.
       variable_expander: A VariableExpander object.
     """
     super(InstallerTest, self).__init__()
     self._name = name
     self._test = test
     self._config = config
     self._variable_expander = variable_expander
+    self._quiet = quiet
     self._verifier_runner = verifier_runner.VerifierRunner()
     self._clean_on_teardown = True
 
   def __str__(self):
     """Returns a string representing the test case.
 
     Returns:
       A string created by joining state names and action names together with
       ' -> ', for example, 'Test: clean -> install chrome -> chrome_installed'.
     """
@@ skipping 12 matching lines @@
     # and ending with state names. Therefore, its length must be odd.
     self.assertEqual(1, len(self._test) % 2,
                      'The length of test array must be odd')
 
     state = self._test[0]
     self._VerifyState(state)
 
     # Starting at index 1, we loop through pairs of (action, state).
     for i in range(1, len(self._test), 2):
       action = self._test[i]
+      if not self._quiet:
+        sys.stderr.write('Beginning action %s\n' % action)
       RunCommand(self._config.actions[action], self._variable_expander)
+      if not self._quiet:
+        sys.stderr.write('Finished action %s\n' % action)
 
       state = self._test[i + 1]
       self._VerifyState(state)
 
     # If the test makes it here, it means it was successful, because RunCommand
     # and _VerifyState throw an exception on failure.
     self._clean_on_teardown = False
 
   def tearDown(self):
     """Cleans up the machine if the test case fails."""
     if self._clean_on_teardown:
       RunCleanCommand(True, self._variable_expander)
 
   def shortDescription(self):
     """Overridden from unittest.TestCase.
 
     We return None as the short description to suppress its printing.
     The default implementation of this method returns the docstring of the
     runTest method, which is not useful since it's the same for every test case.
     The description from the __str__ method is informative enough.
     """
     return None
 
   def _VerifyState(self, state):
     """Verifies that the current machine state matches a given state.
 
     Args:
       state: A state name.
     """
+    if not self._quiet:
+      sys.stderr.write('Verifying state %s\n' % state)
     try:
       self._verifier_runner.VerifyAll(self._config.states[state],
                                       self._variable_expander)
     except AssertionError as e:
       # If an AssertionError occurs, we intercept it and add the state name
       # to the error message so that we know where the test fails.
       raise AssertionError("In state '%s', %s" % (state, e))
 
 
 def RunCommand(command, variable_expander):
@@ skipping 118 matching lines @@
 
 def main():
   parser = argparse.ArgumentParser()
   parser.add_argument('--build-dir', default='out',
                       help='Path to main build directory (the parent of the '
                       'Release or Debug directory)')
   parser.add_argument('--target', default='Release',
                       help='Build target (Release or Debug)')
   parser.add_argument('--force-clean', action='store_true', default=False,
                       help='Force cleaning existing installations')
-  parser.add_argument('-v', '--verbose', action='count', default=0,
-                      help='Increase test runner verbosity level')
+  parser.add_argument('-q', '--quiet', action='store_true', default=False,
+                      help='Reduce test runner output')
   parser.add_argument('--write-full-results-to', metavar='FILENAME',
                       help='Path to write the list of full results to.')
   parser.add_argument('--config', metavar='FILENAME',
                       help='Path to test configuration file')
   parser.add_argument('test', nargs='*',
                       help='Name(s) of tests to run.')
   args = parser.parse_args()
   if not args.config:
     parser.error('missing mandatory --config FILENAME argument')
 
@@ skipping 12 matching lines @@
 
     variable_expander = VariableExpander(mini_installer_path)
     RunCleanCommand(args.force_clean, variable_expander)
     for test in config.tests:
       # If tests were specified via |tests|, their names are formatted like so:
       test_name = '%s.%s.%s' % (InstallerTest.__module__,
                                 InstallerTest.__name__,
                                 test['name'])
       if not args.test or test_name in args.test:
         suite.addTest(InstallerTest(test['name'], test['traversal'], config,
-                                    variable_expander))
+                                    variable_expander, args.quiet))
 
-  result = unittest.TextTestRunner(verbosity=(args.verbose + 1)).run(suite)
+  verbosity = 2 if not args.quiet else 1
+  result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
   if is_component_build:
     print ('Component build is currently unsupported by the mini_installer: '
            'http://crbug.com/377839')
   if args.write_full_results_to:
     with open(args.write_full_results_to, 'w') as fp:
       json.dump(_FullResults(suite, result, {}), fp, indent=2)
       fp.write("\n")
   return 0 if result.wasSuccessful() else 1
 
 
@@ skipping 59 matching lines @@
     trie[path] = value
     return
   directory, rest = path.split(TEST_SEPARATOR, 1)
   if directory not in trie:
     trie[directory] = {}
   _AddPathToTrie(trie[directory], rest, value)
 
 
 if __name__ == '__main__':
   sys.exit(main())