Clean the machine before running commands in the mini_installer test framework.

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 51 matching lines @@
     """
     return 'Test: %s' % (' -> '.join(self._test))
 
   def runTest(self):
     """Run the test case."""
     # |test| is an array of alternating state names and action names, starting
     # 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')
 
-    # TODO(sukolsak): run a reset command that puts the machine in clean state.
-
     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]
-      self._RunCommand(self._config.actions[action])
+      command = self._config.actions[action]
+      resolved_command = self._path_resolver.ResolvePath(command)
+      RunCommand(resolved_command)
 
       state = self._test[i + 1]
       self._VerifyState(state)
 
+  def tearDown(self):
+    """Cleans up the machine after running the test case."""
+    RunCleanCommand(True)

[gab, 2013/09/16 13:59:58]

We should only need to do this if the test case failed (otherwise we should
always be clean since the final state is the clean state).

[sukolsak, 2013/09/16 18:19:22]

Done.

+
   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.
     """
     try:
       verifier.Verify(self._config.states[state], self._path_resolver)
     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(self, command):
-    """Runs the given command from the current file's directory.
 
-    Args:
-      command: A command to run. It is expanded using ResolvePath.
-    """
-    resolved_command = self._path_resolver.ResolvePath(command)
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    exit_status = subprocess.call(resolved_command, shell=True, cwd=script_dir)
-    if exit_status != 0:
-      self.fail('Command %s returned non-zero exit status %s' % (
-          resolved_command, exit_status))
+def RunCommand(command):
+  """Runs the given command from the current file's directory.
+
+  This function throws an Exception if the command returns with non-zero exit
+  status.
+
+  Args:
+    command: A command to run.
+  """
+  script_dir = os.path.dirname(os.path.abspath(__file__))
+  exit_status = subprocess.call(command, shell=True, cwd=script_dir)
+  if exit_status != 0:
+    raise Exception('Command %s returned non-zero exit status %s' % (
+        command, exit_status))
+
+
+def RunCleanCommand(force_clean):
+  """Puts the machine in the clean state (i.e. Chrome not installed).
+
+  Args:
+    force_clean: A boolean indicating whether to force cleaning existing
+        installations.
+  """
+  # TODO(sukolsak): Read the clean state from the config file and clean
+  # the machine according to it.
+  # TODO(sukolsak): Handle Chrome SxS installs.
+  commands = []
+  interactive_option = '--interactive' if not force_clean else ''
+  for chrome_long_name in ['Google Chrome', 'Chromium']:

[gab, 2013/09/16 13:59:58]

I don't like having to delete both brands; imo we should only clean the brand we
are testing. It is true however that this is required to have a fully clean
state for a single shared registry value (App Paths for chrome.exe)...

But in practice I think it's the TODO step that should clean the shared value
(i.e., it's rule being: if the uninstall was successful, I shall clean
everything remaining I know of -- this includes the shared registry value).

Cleaning the shared registry value silently is not wrong imo; only one
chrome.exe can own it, and thus any chrome.exe can't rely on it (all it does is
it allows you to enter commands like "start chrome.exe" without providing a full
path -- it's kind of like adding chrome.exe to %PATH%). Removing it even if the
tested chrome doesn't own it isn't a big deal imo.


** tl;dr; Only clean the brand you are testing here.**
(and get the long name from the PathResolver)

[sukolsak, 2013/09/16 18:19:22]

Done.

+    for level_option in ['', '--system-level']:
+      commands.append('python uninstall_chrome.py --chrome-long-name="%s" '
+                      '--no-error-if-absent %s %s' %
+                      (chrome_long_name, level_option, interactive_option))
+  RunCommand(' && '.join(commands))
 
 
 def MergePropertyDictionaries(current_property, new_property):
   """Merges the new property dictionary into the current property dictionary.
 
   This is different from general dictionary merging in that, in case there are
   keys with the same name, we merge values together in the first level, and we
   override earlier values in the second level. For more details, take a look at
   http://goo.gl/uE0RoR
 
@@ skipping 48 matching lines @@
   config = Config()
   config.tests = config_data['tests']
   for state_name, state_property_filenames in config_data['states']:
     config.states[state_name] = ParsePropertyFiles(directory,
                                                    state_property_filenames)
   for action_name, action_command in config_data['actions']:
     config.actions[action_name] = action_command
   return config
 
 
-def RunTests(mini_installer_path, config):
+def RunTests(mini_installer_path, config, force_clean):
   """Tests the installer using the given Config object.
 
   Args:
     mini_installer_path: The path to mini_installer.exe.
     config: A Config object.
+    force_clean: A boolean indicating whether to force cleaning existing
+        installations.
 
   Returns:
     True if all the tests passed, or False otherwise.
   """
+  RunCleanCommand(force_clean)
   suite = unittest.TestSuite()
   path_resolver = PathResolver(mini_installer_path)
   for test in config.tests:
     suite.addTest(InstallerTest(test, config, path_resolver))
   result = unittest.TextTestRunner(verbosity=2).run(suite)
   return result.wasSuccessful()
 
 
 def main():
   usage = 'usage: %prog [options] config_filename'
   parser = optparse.OptionParser(usage, description='Test the installer.')
   parser.add_option('--build-dir', default='out',
                     help='Path to main build directory (the parent of the '
                          'Release or Debug directory)')
   parser.add_option('--target', default='Release',
                     help='Build target (Release or Debug)')
+  parser.add_option('--force-clean', action='store_true', dest='force_clean',
+                    default=False, help='Force cleaning existing installations')
   options, args = parser.parse_args()
   if len(args) != 1:
     parser.error('Incorrect number of arguments.')
   config_filename = args[0]
 
   mini_installer_path = os.path.join(options.build_dir, options.target,
                                      'mini_installer.exe')
   assert os.path.exists(mini_installer_path), ('Could not find file %s' %
                                                mini_installer_path)
   config = ParseConfigFile(config_filename)
-  if not RunTests(mini_installer_path, config):
+  if not RunTests(mini_installer_path, config, options.force_clean):
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())