Configuration file for Chrome perf and endure tests.

chrome/test/functional/perf_endure.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.
 
 """Performance tests for Chrome Endure (long-running perf tests on Chrome).
 
 This module accepts the following environment variable inputs:
   TEST_LENGTH: The number of seconds in which to run each test.
   PERF_STATS_INTERVAL: The number of seconds to wait in-between each sampling
@@ skipping 15 matching lines @@
 import time
 
 import perf
 import pyauto_functional  # Must be imported before pyauto.
 import pyauto
 import pyauto_errors
 import pyauto_utils
 import remote_inspector_client
 import selenium.common.exceptions
 from selenium.webdriver.support.ui import WebDriverWait
-
+import test_utils
 
 class NotSupportedEnvironmentError(RuntimeError):
   """Represent an error raised since the environment (OS) is not supported."""
   pass
 
 class ChromeEndureBaseTest(perf.BasePerfTest):
   """Implements common functionality for all Chrome Endure tests.
 
   All Chrome Endure test classes should inherit from this class.
   """
@@ skipping 486 matching lines @@
     try:
       element = self._GetElement(driver.find_element_by_xpath, xpath)
       element.click()
     except (selenium.common.exceptions.StaleElementReferenceException,
             selenium.common.exceptions.TimeoutException) as e:
       logging.exception('WebDriver exception: %s' % e)
       return False
 
     return True
 
+  def _GetConfig(self):
+    """Load endure configuration file."""
+    config_file = os.path.join(os.path.dirname(__file__), 'endure_config.txt')
+    if not os.path.exists(config_file):
+      return {}

[dennis_jeffrey, 2012/08/09 17:29:04]

if the file doesn't exist, let's return a dictionary here that is full with all
default information.  That way, the Gmail/Docs/Plus tests below don't need to
check if the config information exists.  They'll be guaranteed to always get
config information.

[fdeng1, 2012/08/11 00:11:27]

Done.

+    else:
+      return pyauto.PyUITest.EvalDataFrom(config_file)
+
+  def _LoginToGoogleAccount(self, account_key='test_google_account'):
+    """Login to Google account.
+
+    Try to use the url and credential specified in endure_config.txt.
+    If it fails to load valid information, try to login via public
+    google account url with credential in
+    src/data/pyauto_private/private_tests_info.txt.
+
+    Args:
+      account_key: The string key in private_tests_info.txt which is associated
+                   with the test account login credentials to use. It will only
+                   be used when fail to load credential from endure_config.txt
+
+    Raises:
+      RuntimeError: if could not get credential information.
+    """

[dennis_jeffrey, 2012/08/09 17:29:04]

if this function successfully finds credentials to use, we should log a message
indicating whether we're using credentials from the config file or from the
private credentials file.

[fdeng1, 2012/08/11 00:11:27]

Added a log message for each case.
On 2012/08/09 17:29:04, dennis_jeffrey wrote:

+    config = self._GetConfig()
+    google_account_url = (config['google_account_url']
+                          if 'google_account_url' in config
+                          else None)
+    username = (config['username'] if 'username' in config else None)
+    password = (config['password'] if 'password' in config else None)
+    if not username or not password:
+      private_file = os.path.join(pyauto.PyUITest.DataDir(), 'pyauto_private',

[dennis_jeffrey, 2012/08/09 17:29:04]

can we just use the superclass's _LoginToGoogleAccount function here?  We could
do something like this:

if the private_tests_info file exists:
  call the superclass _LoginToGoogleAccount
else:
  raise a runtime error

[fdeng1, 2012/08/11 00:11:27]

I tried to make config file also effective for perf.py.
So I put the code in the superclass's _LoginToGoogleAccount.
On 2012/08/09 17:29:04, dennis_jeffrey wrote:

+                                  'private_tests_info.txt')
+      if os.path.exists(private_file):
+        google_account_url = None
+        creds = self.GetPrivateInfo()[account_key]
+        username = creds['username']
+        password = creds['password']
+      else:
+        message = \
+            'Please sepecify credential information in %s.\n' \
+            'Format:\n\t{\n' \
+            '\t "username": "my_username",\n' \
+            '\t "password": "my_password",\n' \
+            '\t "google_account_url": "https://my-google-account-server/",\n' \
+            '\t "gmail_url: "https://my-gmail-server",\n' \
+            '\t "plus_url": "https://my-plus-server",\n' \
+            '\t "docs_url": "https://my-docs-server",\n\t}\n' \
+            % os.path.join(os.path.dirname(__file__), 'endure_config.txt')
+        raise RuntimeError('Could not get credential information.\n' + message)
+    test_utils.GoogleAccountsLogin(
+        self, username, password, url=google_account_url)
+    self.NavigateToURL('about:blank')
+
 
 class ChromeEndureControlTest(ChromeEndureBaseTest):
   """Control tests for Chrome Endure."""
 
   _WEBAPP_NAME = 'Control'
   _TAB_TITLE_SUBSTRING = 'Chrome Endure Control Test'
 
   def testControlAttachDetachDOMTree(self):
     """Continually attach and detach a DOM tree from a basic document."""
     test_description = 'AttachDetachDOMTree'
@@ skipping 42 matching lines @@
 
   _WEBAPP_NAME = 'Gmail'
   _TAB_TITLE_SUBSTRING = 'Gmail'
   _FRAME_XPATH = 'id("canvas_frame")'
 
   def setUp(self):
     ChromeEndureBaseTest.setUp(self)
 
     # Log into a test Google account and open up Gmail.
     self._LoginToGoogleAccount(account_key='test_google_account_gmail')
-    self.NavigateToURL('http://www.gmail.com')
+    gmail_url = (self._GetConfig()['gmail_url']
+                 if 'gmail_url' in self._GetConfig()
+                 else 'http://www.gmail.com')
+    self.NavigateToURL(gmail_url)
     loaded_tab_title = self.GetActiveTabTitle()
     self.assertTrue(self._TAB_TITLE_SUBSTRING in loaded_tab_title,
                     msg='Loaded tab title does not contain "%s": "%s"' %
                         (self._TAB_TITLE_SUBSTRING, loaded_tab_title))
 
     self._driver = self.NewWebDriver()
     # Any call to wait.until() will raise an exception if the timeout is hit.
     # TODO(dennisjeffrey): Remove the need for webdriver's wait using the new
     # DOM mutation observer mechanism.
     self._wait = WebDriverWait(self._driver, timeout=60)
@@ skipping 52 matching lines @@
     To account for scenario warm-up time, latency values during the first
     minute of test execution are not recorded.
 
     Args:
       element: A selenium.webdriver.remote.WebElement object to click.
       test_description: A string description of what the test does, used for
           outputting results to be graphed.  Should not contain spaces.  For
           example, 'ComposeDiscard' for Gmail.
       action_description: A string description of what action is being
           performed.  Should not contain spaces.  For example, 'Compose'.
     """

[fdeng1, 2012/08/09 04:01:58]

Since we allow user to use their own google account. And their own account
doesn't have the "latency" dom element. As such, gmail tests will hang to wait
for that dom element to appear and then fail. We need some way to know whether
latency dom element is available for the current account. We can let the user
specify it in configuration file or we can choose to only record latency when it
runs with a particular account(but concerns are that gmail team may also have
some other accounts which have latency indicator). Other ideas?

[dennis_jeffrey, 2012/08/09 17:29:04]

Good point.  It would be good to have the code here dynamically check whether
the latency is available on the webpage and only record it if so.  The user
should not have to worry about it.  They'll just see the latency results if
they're available, or else they won't see those results.

[fdeng1, 2012/08/11 00:11:27]

How would a test know the latency is available or not?
Other than waiting for it to appear until it times out, is there another way?

On 2012/08/09 17:29:04, dennis_jeffrey wrote:

     latency_dom_element = self._GetLatencyDomElement()
     element.click()
     # Wait for the old latency value to be removed, before getting the new one.
     self._WaitUntilDomElementRemoved(latency_dom_element)
 
     latency_dom_element = self._GetLatencyDomElement()
     match = re.search(r'\[(\d+) ms\]', latency_dom_element.text)
     if match:
       latency = int(match.group(1))
       elapsed_time = int(round(time.time() - self._test_start_time))
@@ skipping 244 matching lines @@
   """Long-running performance tests for Chrome using Google Docs."""
 
   _WEBAPP_NAME = 'Docs'
   _TAB_TITLE_SUBSTRING = 'Google Drive'
 
   def setUp(self):
     ChromeEndureBaseTest.setUp(self)
 
     # Log into a test Google account and open up Google Docs.
     self._LoginToGoogleAccount()
-    self.NavigateToURL('http://docs.google.com')
+    docs_url = (self._GetConfig()['docs_url']
+                if 'docs_url' in self._GetConfig()
+                else 'http://docs.google.com')
+    self.NavigateToURL(docs_url)
     self.assertTrue(
         self.WaitUntil(lambda: self._TAB_TITLE_SUBSTRING in
                                self.GetActiveTabTitle(),
                        timeout=60, expect_retval=True, retry_sleep=1),
         msg='Timed out waiting for Docs to load. Tab title is: %s' %
             self.GetActiveTabTitle())
 
     self._driver = self.NewWebDriver()
 
   def testDocsAlternatelyClickLists(self):
@@ skipping 51 matching lines @@
   """Long-running performance tests for Chrome using Google Plus."""
 
   _WEBAPP_NAME = 'Plus'
   _TAB_TITLE_SUBSTRING = 'Google+'
 
   def setUp(self):
     ChromeEndureBaseTest.setUp(self)
 
     # Log into a test Google account and open up Google Plus.
     self._LoginToGoogleAccount()
-    self.NavigateToURL('http://plus.google.com')
+    plus_url = (self._GetConfig()['plus_url']
+                if 'plus_url' in self._GetConfig()
+                else 'http://plus.google.com')
+    self.NavigateToURL(plus_url)
     loaded_tab_title = self.GetActiveTabTitle()
     self.assertTrue(self._TAB_TITLE_SUBSTRING in loaded_tab_title,
                     msg='Loaded tab title does not contain "%s": "%s"' %
                         (self._TAB_TITLE_SUBSTRING, loaded_tab_title))
 
     self._driver = self.NewWebDriver()
 
   def testPlusAlternatelyClickStreams(self):
     """Alternates between two different streams.
 
@@ skipping 92 matching lines @@
         self._num_errors += 1
 
       time.sleep(1)
 
     self._RunEndureTest(self._WEBAPP_NAME, self._TAB_TITLE_SUBSTRING,
                         test_description, scenario)
 
 
 if __name__ == '__main__':
   pyauto_functional.Main()