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.
+    self._RunCleanCommand()
 
     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])
 
       state = self._test[i + 1]
@@ skipping 28 matching lines @@
     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 _RunCleanCommand(self):
+    """Puts the machine in the clean state (i.e. Chrome not installed)."""
+    # TODO(sukolsak): Read the clean state from the config file and clean
+    # the machine according to it.
+    # TODO(sukolsak): Handle Chrome SxS installs.
+    command = ('python uninstall_chrome.py '
+               '--chrome-long-name="$CHROME_LONG_NAME" --silent & '
+               'python uninstall_chrome.py '
+               '--chrome-long-name="$CHROME_LONG_NAME" --system-level --silent')
+    resolved_command = self._path_resolver.ResolvePath(command)
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    subprocess.call(resolved_command, shell=True, cwd=script_dir)
+
 
 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
 
   Args:
@@ skipping 73 matching lines @@
 
 
 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]
 
+  if not options.force_clean:
+    prompt = ('Warning: This script will uninstall Chrome or Chromium if they '

[gab, 2013/09/13 15:06:19]

Instead of always prompting how about an option on uninstall_chrome.py to prompt
if it does find an install?

e.g., --interactive

which would only be passed to uninstall_chrome.py if !force_clean

?

[sukolsak, 2013/09/13 15:59:33]

Then we will only warn the user only when the registry key for uninstalling
Chrome exists. What if the registry key is missing, but everything else
(chrome.exe, browsing data, etc.) is still there? Are we really OK with removing
them without warning the user?

[gab, 2013/09/13 20:12:55]

I'd say yes, I think we shouldn't delete a real/full Chrome install on the
user's machine. However if Chrome is not fully installed (i.e. not visible in
Control Panel/Programs & Features -- which is what the UninstallString triggers
among other things), I think it's fine to clean the machine for the user (as if
we abort he may not even know how to clean his machine...).

So the final design imo should be:

1) If there is a Chrome installed on the system, prompt the user to remove it
(or do it automatically if --force-clean).
2) Unless there was a failure with the uninstall in step 1 (user denying the
prompt is considered failure; the uninstall string not being present is not):
clean up everything that's left behind.

[sukolsak, 2013/09/13 23:11:14]

Done.

+              'are installed. Do you want to continue? (y/N) ')
+    if raw_input(prompt).strip() != 'y':
+      print >> sys.stderr, 'User aborted'
+      return 1
+
   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):
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())