Use named automation interface to control primary chrome on ChromeOS

chrome/test/pyautolib/pyauto.py

 #!/usr/bin/python
 
 # Copyright (c) 2010 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.
 
 """PyAuto: Python Interface to Chromium's Automation Proxy.
 
 PyAuto uses swig to expose Automation Proxy interfaces to Python.
 For complete documentation on the functionality available,
@@ skipping 12 matching lines @@
 This script can be used as an executable to fire off other scripts, similar
 to unittest.py
   python pyauto.py test_script
 """
 
 import logging
 import optparse
 import os
 import shutil
 import signal
+import stat
 import subprocess
 import sys
 import tempfile
 import time
 import types
 import unittest
 import urllib
 
 
 def _LocateBinDirs():
@@ skipping 37 matching lines @@
 
 # Should go after sys.path is set appropriately
 import bookmark_model
 import download_info
 import history_info
 import omnibox_info
 import plugins_info
 import prefs_info
 from pyauto_errors import JSONInterfaceError
 from pyauto_errors import NTPThumbnailNotShownError
+import pyauto_utils
 import simplejson as json  # found in third_party
 
 _HTTP_SERVER = None
 _OPTIONS = None
 
 
 class PyUITest(pyautolib.PyUITestBase, unittest.TestCase):
   """Base class for UI Test Cases in Python.
 
   A browser is created before executing each test, and is destroyed after
@@ skipping 38 matching lines @@
     unittest.TestCase.__init__(self, methodName)
 
   def __del__(self):
     pyautolib.PyUITestBase.__del__(self)
 
   def setUp(self):
     """Override this method to launch browser differently.
 
     Can be used to prevent launching the browser window by default in case a
     test wants to do some additional setup before firing browser.
+
+    When using the named interface, it connects to an existing browser
+    instance.
     """
+    named_channel_id = _OPTIONS.channel_id
+    if self.IsChromeOS():  # Enable testing interface on ChromeOS
+      if self.get_clear_profile():
+        self.CleanupBrowserProfileOnChromeOS()
+      if not named_channel_id:
+        named_channel_id = self.EnableChromeTestingOnChromeOS()
+    if named_channel_id:
+      self.UseNamedChannelID(named_channel_id)
     self.SetUp()     # Fire browser
 
   def tearDown(self):
     self.TearDown()  # Destroy browser
 
+  def EnableChromeTestingOnChromeOS(self):
+    """Enables the named automation interface on chromeos.
+
+    Restarts chrome so that you get a fresh instance.
+    Also sets some testing-friendly flags for chrome.
+
+    Expects suid python to be present in the same dir as pyautolib.py
+    """
+    def _IsRootSuid(path):
+      return os.path.isfile(path) and (os.stat(path).st_mode & stat.S_ISUID)
+    suid_python = os.path.normpath(os.path.join(
+        os.path.dirname(pyautolib.__file__), 'python'))
+    assert _IsRootSuid(suid_python), \
+        'Did not find suid-root python at %s' % suid_python
+    file_path = os.path.join(os.path.dirname(__file__), 'chromeos',
+                             'enable_testing.py')
+    args = [suid_python, file_path]
+    # Pass extra chrome flags for testing
+    for flag in self.ExtraChromeFlagsOnChromeOS():
+      args.append('--extra-chrome-flags=%s' % flag)
+    proc = subprocess.Popen(args, stdout=subprocess.PIPE)
+    automation_channel_path = proc.communicate()[0]
+    automation_channel_path = automation_channel_path.strip()
+    assert len(automation_channel_path), 'Could not enable testing interface'
+    return automation_channel_path
+
+  def ExtraChromeFlagsOnChromeOS(self):
+    """Return a list of extra chrome flags to use with chrome for testing.
+
+    These are flags needed to facilitate testing.
+    """
+    return [
+       '--homepage=about:blank',
+       '--allow-file-access',
+       '--enable-file-cookies',
+       '--dom-automation',
+    ]
+
+  @staticmethod
+  def CleanupBrowserProfileOnChromeOS():
+    """Cleanup browser profile dir on ChromeOS.
+
+    Browser should not be running, or else there will be locked files.
+    """
+    profile_dir = '/home/chronos/user'
+    for item in os.listdir(profile_dir):
+      if item != '.pki':  # Causes stateful partition to get erased
+        pyauto_utils.RemovePath(os.path.join(profile_dir, item))
+    # TODO(nirnimesh): Clean up other files in /home/chronos?
+
   def RestartBrowser(self, clear_profile=True):
     """Restart the browser.
 
     For use with tests that require to restart the browser.
 
     Args:
       clear_profile: If True, the browser profile is cleared before restart.
                      Defaults to True, that is restarts browser with a clean
                      profile.
     """
@@ skipping 210 matching lines @@
     and returns it back as a dictionary.
 
     Args:
       cmd_dict: the command dictionary. It must have a 'command' key
                 Sample:
                   {
                     'command': 'SetOmniboxText',
                     'text': text,
                   }
       windex: 0-based window index on which to work. Default: 0 (first window)
+              Use -ve windex if the automation command does not apply to a
+              browser window. example: chromeos login
 
     Returns:
       a dictionary for the output returned by the automation channel.
 
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
     """
     ret_dict = json.loads(self._SendJSONRequest(windex, json.dumps(cmd_dict)))
     if ret_dict.has_key('error'):
       raise JSONInterfaceError(ret_dict['error'])
@@ skipping 1626 matching lines @@
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
     """
     cmd_dict = {
         'command': 'KillRendererProcess',
         'pid': pid
     }
     return self._GetResultFromJSONRequest(cmd_dict)
 
 
+  ## ChromeOS section
+
+  def Login(self, username, password):
+    """Login to chromeos.
+
+    Waits until logged in.
+    Should be displaying the login screen to work.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+    """
+    cmd_dict = {
+        'command': 'Login',
+        'username': username,
+        'password': password,
+    }
+    return self._GetResultFromJSONRequest(cmd_dict, windex=-1)
+
+  ## ChromeOS section -- end
+
+
 class PyUITestSuite(pyautolib.PyUITestSuiteBase, unittest.TestSuite):
   """Base TestSuite for PyAuto UI tests."""
 
   def __init__(self, args):
     pyautolib.PyUITestSuiteBase.__init__(self, args)
 
     # Figure out path to chromium binaries
     browser_dir = os.path.normpath(os.path.dirname(pyautolib.__file__))
     logging.debug('Loading pyauto libs from %s', browser_dir)
     self.Initialize(pyautolib.FilePath(browser_dir))
@@ skipping 138 matching lines @@
              'flakiness. Defaults to 1.')
     parser.add_option(
         '-S', '--suite', type='string', default='FULL',
         help='Name of the suite to load.  Defaults to "FULL".')
     parser.add_option(
         '-L', '--list-tests', action='store_true', default=False,
         help='List all tests, and exit.')
     parser.add_option(
         '', '--no-http-server', action='store_true', default=False,
         help='Do not start an http server to serve files in data dir.')
+    parser.add_option(
+        '', '--channel-id', type='string', default='',
+        help='Name of channel id, if using named interface.')
 
     self._options, self._args = parser.parse_args()
     global _OPTIONS
     _OPTIONS = self._options  # export options so other classes can access
 
     # Setup logging - start with defaults
     level = logging.INFO
     format = None
 
     if self._options.verbose:
@@ skipping 214 matching lines @@
     if self._options.verbose:
       verbosity = 2
     result = PyAutoTextTestRuner(verbosity=verbosity).run(pyauto_suite)
     del loaded_tests  # Need to destroy test cases before the suite
     del pyauto_suite
     sys.exit(not result.wasSuccessful())
 
 
 if __name__ == '__main__':
   Main()