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, verbose):
     """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._verbose = verbose
     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 self._verbose:
+        sys.stderr.write('Beginning action %s\n' % action)
       RunCommand(self._config.actions[action], self._variable_expander)
+      if self._verbose:
+        sys.stderr.write('Finished action %s\n' % action)

[gab, 2014/09/09 15:50:10]

Shouldn't this go to stdout instead? (i.e. this is a log, not an error)

[grt (UTC plus 2), 2014/09/09 15:56:48]

I would have thought so, but since the whole unittest class uses stderr
exclusively, it makes sense to do the same so that there aren't interleaving
problems.

 
       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 self._verbose:
+      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 152 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.verbose))
 
   result = unittest.TextTestRunner(verbosity=(args.verbose + 1)).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 61 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())