Chrome updater test framework

pyautolib/pyauto.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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,
 run pydoc on this file.
@@ skipping 31 matching lines @@
 import string
 import subprocess
 import sys
 import tempfile
 import time
 import types
 import unittest
 import urllib
 
 import pyauto_paths
+from pyauto_utils import GTestTextTestRunner
 
 
 def _LocateBinDirs():
   """Setup a few dirs where we expect to find dependency libraries."""
   deps_dirs = [
       os.path.dirname(__file__),
       pyauto_paths.GetThirdPartyDir(),
       os.path.join(pyauto_paths.GetThirdPartyDir(), 'webdriver', 'pylib'),
   ]
   sys.path += map(os.path.normpath, pyauto_paths.GetBuildDirs() + deps_dirs)
@@ skipping 48 matching lines @@
 
   Example:
 
     class MyTest(PyUITest):
 
       def testNavigation(self):
         self.NavigateToURL("http://www.google.com")
         self.assertEqual("Google", self.GetActiveTabTitle())
   """
 
   def __init__(self, methodName='runTest', **kwargs):

[Nirnimesh, 2012/08/09 21:32:48]

why not add browser_path arg here?

[nkang, 2012/08/16 23:46:24]

I included it in kwargs at Ken's recommendation. Adding a separate broswer_path
argument might confuse users. Up until now, users didn't have to worry about
providing the browser path, as initialization was always done by calling
BrowserPath. We added a broser_path variable so we could provide a path for the
Chrome binary if need be, which would be the case for the updater tests where
the Chrome binary and pyautolib files are in different locations (see comment
below for why they are in different places). At the same time, we didn't want to
change things for other tests that 'fetch' a chrome build and run pyauto tests
using the fetched build. So kwargs seemed like a natural choice. If you feel
that we should not include it in kwargs, let me know and I'll change it.

     """Initialize PyUITest.
 
     When redefining __init__ in a derived class, make sure that:
       o you make a call this __init__
       o __init__ takes methodName as an arg. this is mandated by unittest module
 
     Args:
       methodName: the default method name. Internal use by unittest module
 
       (The rest of the args can be in any order. They can even be skipped in
        which case the defaults will be used.)
 
       clear_profile: If True, clean the profile dir before use. Defaults to True
       homepage: the home page. Defaults to "about:blank"
     """
     # Fetch provided keyword args, or fill in defaults.
+    browser_path = kwargs.get('browser_path', None)

[Nirnimesh, 2012/08/09 21:32:48]

So BrowserPath() method will be out of sync?

[nkang, 2012/08/16 23:46:24]

BrowserPath returns the same path as the pyautolib file, which makes sense if
you're fetching a build because then the binary and pyautolib are in the same
location. But we wanted to run the tests using the installed version of Chrome,
which is either in User\AppData\Local\Google\Chrome\Application <or> Program
Files(x86)\Google\Chrome\Application, depending on the type of installation. At
first we decided to just download the pyautolib files in the same directory as
the Chrome binary, but that didn't work. The initial installation would work,
but upgrade would fail because the pyautolib files, due to being in use, would
cause an access violation error, causing the upgrade to fail. So ultimately we
decided to download pyautolib and all other dependencies in the Temp folder.
That's why we created the browser_path variable, which, if set, would provide
the location for the Chrome binary. If browser_path is not set, BrowserPath
would be used for initialization. So, to answer you question, BrowserPath would
be out of sync if it were used, but it wouldn't even be used in this case. For
tests that don't need to specify browser_path, they can simply ignore the
browser_path arg. In which case, broser_path will be None and BrowserPath() will
be used for initialization.

[Nirnimesh, 2012/08/22 07:06:34]

All this is so confusing. You'll not remember it 1 month later.
BrowserPath() is supposed to point to the dir containing the browser being used.
It should be correct at all times. Make it so.

     clear_profile = kwargs.get('clear_profile', True)
     homepage = kwargs.get('homepage', 'about:blank')
 
     pyautolib.PyUITestBase.__init__(self, clear_profile, homepage)
-    self.Initialize(pyautolib.FilePath(self.BrowserPath()))
+    if browser_path:
+      self.Initialize(pyautolib.FilePath(browser_path))
+    else:
+      self.Initialize(pyautolib.FilePath(self.BrowserPath()))
     unittest.TestCase.__init__(self, methodName)
 
     # Give all pyauto tests easy access to pprint.PrettyPrinter functions.
     self.pprint = pprint.pprint
     self.pformat = pprint.pformat
 
     # Set up remote proxies, if they were requested.
     self.remotes = []
     self.remote = None
     global _REMOTE_PROXY
@@ skipping 5605 matching lines @@
     if env.get('PYTHONPATH', None):
       env['PYTHONPATH'] += ':' + main_path
     else:
       env['PYTHONPATH'] = main_path
 
     # Run it!
     subprocess.Popen([sys.executable, os.path.join(os.path.dirname(__file__),
                                                    'remote_host.py')], env=env)
 
 
-class _GTestTextTestResult(unittest._TextTestResult):
-  """A test result class that can print formatted text results to a stream.
-
-  Results printed in conformance with gtest output format, like:
-  [ RUN        ] autofill.AutofillTest.testAutofillInvalid: "test desc."
-  [         OK ] autofill.AutofillTest.testAutofillInvalid
-  [ RUN        ] autofill.AutofillTest.testFillProfile: "test desc."
-  [         OK ] autofill.AutofillTest.testFillProfile
-  [ RUN        ] autofill.AutofillTest.testFillProfileCrazyCharacters: "Test."
-  [         OK ] autofill.AutofillTest.testFillProfileCrazyCharacters
-  """
-  def __init__(self, stream, descriptions, verbosity):
-    unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
-
-  def _GetTestURI(self, test):
-    if sys.version_info[:2] <= (2, 4):
-      return '%s.%s' % (unittest._strclass(test.__class__),
-                        test._TestCase__testMethodName)
-    return '%s.%s.%s' % (test.__class__.__module__,
-                         test.__class__.__name__,
-                         test._testMethodName)
-
-  def getDescription(self, test):
-    return '%s: "%s"' % (self._GetTestURI(test), test.shortDescription())
-
-  def startTest(self, test):
-    unittest.TestResult.startTest(self, test)
-    self.stream.writeln('[ RUN        ] %s' % self.getDescription(test))
-
-  def addSuccess(self, test):
-    unittest.TestResult.addSuccess(self, test)
-    self.stream.writeln('[         OK ] %s' % self._GetTestURI(test))
-
-  def addError(self, test, err):
-    unittest.TestResult.addError(self, test, err)
-    self.stream.writeln('[      ERROR ] %s' % self._GetTestURI(test))
-
-  def addFailure(self, test, err):
-    unittest.TestResult.addFailure(self, test, err)
-    self.stream.writeln('[     FAILED ] %s' % self._GetTestURI(test))
-
-
-class PyAutoTextTestRunner(unittest.TextTestRunner):
-  """Test Runner for PyAuto tests that displays results in textual format.
-
-  Results are displayed in conformance with gtest output.
-  """
-  def __init__(self, verbosity=1):
-    unittest.TextTestRunner.__init__(self,
-                                     stream=sys.stderr,
-                                     verbosity=verbosity)
-
-  def _makeResult(self):
-    return _GTestTextTestResult(self.stream, self.descriptions, self.verbosity)
-
-
 # Implementation inspired from unittest.main()
 class Main(object):
   """Main program for running PyAuto tests."""
 
   _options, _args = None, None
   _tests_filename = 'PYAUTO_TESTS'
   _platform_map = {
     'win32':  'win',
     'darwin': 'mac',
     'linux2': 'linux',
@@ skipping 283 matching lines @@
     if self._options.list_tests:  # List tests and exit
       for name in test_names:
         print name
       sys.exit(0)
     pyauto_suite = PyUITestSuite(suite_args)
     loaded_tests = unittest.defaultTestLoader.loadTestsFromNames(test_names)
     pyauto_suite.addTests(loaded_tests)
     verbosity = 1
     if self._options.verbose:
       verbosity = 2
-    result = PyAutoTextTestRunner(verbosity=verbosity).run(pyauto_suite)
+    result = GTestTextTestRunner(verbosity=verbosity).run(pyauto_suite)
     del loaded_tests  # Need to destroy test cases before the suite
     del pyauto_suite
     successful = result.wasSuccessful()
     if not successful:
       pyauto_tests_file = os.path.join(self.TestsDir(), self._tests_filename)
       print >>sys.stderr, 'Tests can be disabled by editing %s. ' \
                           'Ref: %s' % (pyauto_tests_file, _PYAUTO_DOC_URL)
     sys.exit(not successful)
 
 
 if __name__ == '__main__':
   Main()