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 580 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')
-    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.NavigateToURL(self._GetConfig().get('gmail_url'))
+    self.assertTrue(
+        self.WaitUntil(lambda: self._TAB_TITLE_SUBSTRING in
+                       self.GetActiveTabTitle(),
+                       timeout=60, expect_retval=True, retry_sleep=1),

[Nirnimesh, 2012/08/21 00:54:43]

why are you overriding the timeout?

+        msg='Timed out waiting for Gmail to load. Tab title is: %s' %
+        self.GetActiveTabTitle())
 
     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)
 
     # Wait until Gmail's 'canvas_frame' loads and the 'Inbox' link is present.
     # TODO(dennisjeffrey): Check with the Gmail team to see if there's a better
     # way to tell when the webpage is ready for user interaction.
     self._wait.until(
         self._SwitchToCanvasFrame)  # Raises exception if the timeout is hit.
     # Wait for the inbox to appear.
     self.WaitForDomNode('//a[starts-with(@title, "Inbox")]',
                         frame_xpath=self._FRAME_XPATH)
 
+    # Test whether latency dom element is available.
+    try:
+      self._GetLatencyDomElement(5000)
+      self._has_latency = True
+    except pyauto_errors.JSONInterfaceError:
+      logging.info('Skip recording latency as latency ' +
+                   'dom element is not available.')
+      self._has_latency = False
+
   def _SwitchToCanvasFrame(self, driver):
     """Switch the WebDriver to Gmail's 'canvas_frame', if it's available.
 
     Args:
       driver: A selenium.webdriver.remote.webdriver.WebDriver object.
 
     Returns:
       True, if the switch to Gmail's 'canvas_frame' is successful, or
       False if not.
     """
     try:
       driver.switch_to_frame('canvas_frame')
       return True
     except selenium.common.exceptions.NoSuchFrameException:
       return False
 
-  def _GetLatencyDomElement(self):
-    """Returns a reference to the latency info element in the Gmail DOM."""
+  def _GetLatencyDomElement(self, timeout=-1):
+    """Returns a reference to the latency info element in the Gmail DOM.
+
+    Args:
+      timeout: The maximum amount of time (in milliseconds) to wait for
+               the latency dom element to appear, defaults to the
+               default automation timeout.
+    Returns:
+      A latency dom element.
+    """
     latency_xpath = (
         '//span[starts-with(text(), "Why was the last action slow?")]')
-    self.WaitForDomNode(latency_xpath, frame_xpath=self._FRAME_XPATH)
+    self.WaitForDomNode(latency_xpath, timeout=timeout,
+                        frame_xpath=self._FRAME_XPATH)
     return self._GetElement(self._driver.find_element_by_xpath, latency_xpath)
 
   def _WaitUntilDomElementRemoved(self, dom_element):
     """Waits until the given element is no longer attached to the DOM.
 
     Args:
       dom_element: A selenium.webdriver.remote.WebElement object.
     """
     def _IsElementStale():
       try:
@@ skipping 12 matching lines @@
     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'.
     """
+    if not self._has_latency:
+      element.click()
+      return
     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')
+    self.NavigateToURL(self._GetConfig().get('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')
+    self.NavigateToURL(self._GetConfig().get('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()