Run Chrome Endure tests with network simulation via Web Page Replay.

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 webpagereplay
 
 
 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.
   """
 
   _DEFAULT_TEST_LENGTH_SEC = 60 * 60 * 6  # Tests run for 6 hours.
   _GET_PERF_STATS_INTERVAL = 60 * 5  # Measure perf stats every 5 minutes.
   # TODO(dennisjeffrey): Do we still need to tolerate errors?
   _ERROR_COUNT_THRESHOLD = 50  # Number of ChromeDriver errors to tolerate.
   _DEEP_MEMORY_PROFILE = False
   _DEEP_MEMORY_PROFILE_INTERVAL = _GET_PERF_STATS_INTERVAL
   _DEEP_MEMORY_PROFILE_SAVE = False
 
   _DMPROF_DIR_PATH = os.path.join(
       os.path.dirname(__file__), os.pardir, os.pardir, os.pardir,
       'tools', 'deep_memory_profiler')
 
   _DMPROF_SCRIPT_PATH = os.path.join(_DMPROF_DIR_PATH, 'dmprof')
 
   _CHROME_BIN_PATH = os.path.join(perf.BasePerfTest.BrowserPath(), 'chrome')
 
   def setUp(self):
+    # The environment variable for the usage of Web Page Replay.
+    # It must be parsed before perf.BasePerfTest.setUp()
+    self._use_wpr = self._NeedReplayServer()
+    # Do NOT mannually set WPR_RECORD for the purpose of
+    # making recording archive for endure tests. Run record_endure.py instead.
+    if self._use_wpr:
+      self._is_replay_mode = 'WPR_RECORD' not in os.environ
+
     # The environment variables for the Deep Memory Profiler must be set
     # before perf.BasePerfTest.setUp() to inherit them to Chrome.
     self._deep_memory_profile = self._GetDeepMemoryProfileEnv(
         'DEEP_MEMORY_PROFILE', bool, self._DEEP_MEMORY_PROFILE)
 
     self._deep_memory_profile_interval = self._GetDeepMemoryProfileEnv(
         'DEEP_MEMORY_PROFILE_INTERVAL', int, self._DEEP_MEMORY_PROFILE_INTERVAL)
 
     if self._deep_memory_profile:
       if not self.IsLinux():
@@ skipping 35 matching lines @@
     self._remote_inspector_client = (
         remote_inspector_client.RemoteInspectorClient())
     logging.info('Connection to remote inspector set up successfully.')
 
     self._test_start_time = 0
     self._num_errors = 0
     self._events_to_output = []
     self._deep_memory_profile_json_file = None
     self._deep_memory_profile_last_json_filename = ''
     self._deep_memory_profile_proc = None
+    self._StartReplayServerIfNecessary()
 
   def tearDown(self):
     logging.info('Terminating connection to remote inspector...')
     self._remote_inspector_client.Stop()
     logging.info('Connection to remote inspector terminated.')
     if self._deep_memory_profile:
       # TODO(dmikurube): Stop to set HEAP_PROFILE_TIME_INTERVAL in setUp when
       # PyAuto supports to dump renderer heap profile.
       del os.environ['HEAP_PROFILE_TIME_INTERVAL']
       del os.environ['DEEP_HEAP_PROFILE']
       del os.environ['HEAP_PROFILE_MMAP']
       del os.environ['HEAPPROFILE']
 
     # Must be done at end of this function except for post-cleaning after
     # Chrome finishes.
     perf.BasePerfTest.tearDown(self)
 
     # Remove the temporary directory after Chrome finishes in tearDown.
     if (self._deep_memory_profile and
         not self._deep_memory_profile_save and
         self._deep_tempdir):
       pyauto_utils.RemovePath(self._deep_tempdir)
+    # Must be done after perf.BasePerfTest.tearDown()
+    self._StopReplayServerIfNecessary()

[fdeng1, 2012/08/02 22:57:30]

StopReplayServerIfNecessary()/StartReplayServerIfNecessary() are in
tearDown/setUp of the base class now.

+
+  def _NeedReplayServer(self):
+    """Check whether the test needs to run against Web Page Replay server.
+
+    Override this function to return False if you want to permanently
+    turn off Web Page Replay for a test.
+
+    Returns:
+      True if need replay server otherwise False.
+
+    Environment variable:
+      ENDURE_NO_WPR: if set, do not need replay server
+    """
+    if 'ENDURE_NO_WPR' in os.environ:
+      return False
+    else:
+      return True
+

[fdeng1, 2012/08/02 22:57:30]

Two tests are offline and don't need WPR. These tests can override this function
to turn off WPR support.

+  def _GenArchiveName(self):
+    """Returns the Web Page Replay archive name that corresponds to a test.
+
+    Use test class name as archive name, e.g. ChromeEndureGmailTest.wpr
+    Override this function to allow other names.
+
+    Returns:
+      An archive name generated using test class name.
+    """
+    # Use class name as archive name.
+    return self.id().split('.')[1] + '.wpr'
 

[fdeng1, 2012/08/02 22:57:30]

I add a function called _GenArchiveName which uses test class name as archive
file name. I feel this can bring some freedom for tests to customize which
archive they want to use. For example, we may break one archive into smaller one
if it is too big or one archive is shared by multiple tests. Please let me know
if there is better way to go here.

   def _GetDeepMemoryProfileEnv(self, env_name, converter, default):
     """Returns a converted environment variable for the Deep Memory Profiler.
 
     Args:
       env_name: A string name of an environment variable.
       converter: A function taking a string to convert an environment variable.
       default: A value used if the environment variable is not specified.
 
     Returns:
       A value converted from the environment variable with 'converter'.
@@ skipping 20 matching lines @@
     # The same with setUp, but need to fetch the environment variable since
     # ExtraChromeFlags is called before setUp.
     deep_memory_profile = self._GetDeepMemoryProfileEnv(
         'DEEP_MEMORY_PROFILE', bool, self._DEEP_MEMORY_PROFILE)
 
     # Ensure Chrome enables remote debugging on port 9222.  This is required to
     # interact with Chrome's remote inspector.
     extra_flags = ['--remote-debugging-port=9222']
     if deep_memory_profile:
       extra_flags.append('--no-sandbox')
-    return (perf.BasePerfTest.ExtraChromeFlags(self) + extra_flags)
+    if self._use_wpr:
+      extra_flags.extend(ChromeEndureReplay.CHROME_FLAGS)
+    return perf.BasePerfTest.ExtraChromeFlags(self) + extra_flags
 
   def _OnTimelineEvent(self, event_info):
     """Invoked by the Remote Inspector Client when a timeline event occurs.
 
     Args:
       event_info: A dictionary containing raw information associated with a
          timeline event received from Chrome's remote inspector.  Refer to
          chrome/src/third_party/WebKit/Source/WebCore/inspector/Inspector.json
          for the format of this dictionary.
     """
@@ skipping 339 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 _StartReplayServerIfNecessary(self):
+    """Start replay server if necessary.
+
+    This method needs to be called BEFORE any connection (which is supposed
+    to go through the Web Page Replay server) occurs.
+    """
+    if self._use_wpr and self._is_replay_mode:
+      archive_name = self._GenArchiveName()
+      self._wpr_server = ChromeEndureReplay.ReplayServer(archive_name)
+      self._wpr_server.StartServer()
+      logging.info('Web Page Replay server has started in Replay mode.')
+
+  def _StopReplayServerIfNecessary(self):
+    """Stop the Web Page Replay server if necessary.
+
+    This method has to be called AFTER all network connections which go
+    through Web Page Replay server have shut down. Otherwise the
+    Web Page Replay server will hang to wait for them. A good
+    place is to call it at the end of the teardown process.
+    """
+    if self._use_wpr and self._is_replay_mode:
+      self._wpr_server.StopServer()
+      logging.info('The Web Page Replay server stopped.')
+
 
 class ChromeEndureControlTest(ChromeEndureBaseTest):
   """Control tests for Chrome Endure."""
 
   _WEBAPP_NAME = 'Control'
   _TAB_TITLE_SUBSTRING = 'Chrome Endure Control Test'
 
+  def _NeedReplayServer(self):
+    """Override parent's function to remove replay support."""
+    return False
+
   def testControlAttachDetachDOMTree(self):
     """Continually attach and detach a DOM tree from a basic document."""
     test_description = 'AttachDetachDOMTree'
     url = self.GetHttpURLForDataPath('chrome_endure', 'endurance_control.html')
     self.NavigateToURL(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))
 
@@ skipping 519 matching lines @@
 
     url = self.GetHttpURLForDataPath('indexeddb', 'endure', 'app.html')
     self.NavigateToURL(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 _NeedReplayServer(self):
+    """Override parent's function to remove replay support."""
+    return False
+
   def testOfflineOnline(self):
     """Simulates user input while offline and sync while online.
 
     This test alternates between a simulated "Offline" state (where user
     input events are queued) and an "Online" state (where user input events
     are dequeued, sync data is staged, and sync data is unstaged).
     """
     test_description = 'OnlineOfflineSync'
 
     def scenario():
@@ skipping 18 matching lines @@
       except (pyauto_errors.JSONInterfaceError,
               pyauto_errors.JavascriptRuntimeError):
         self._num_errors += 1
 
       time.sleep(1)
 
     self._RunEndureTest(self._WEBAPP_NAME, self._TAB_TITLE_SUBSTRING,
                         test_description, scenario)
 
 
+class ChromeEndureReplay(object):
+  """Run Chrome Endure tests with network simulation via Web Page Replay."""
+
+  _PATHS = {
+      'archive':
+      'src/chrome/test/data/pyauto_private/webpagereplay/{archive_name}',
+      'scripts':
+      'src/chrome/test/data/chrome_endure/webpagereplay/wpr_deterministic.js',
+      }
+  CHROME_FLAGS = webpagereplay.CHROME_FLAGS
+
+  @classmethod
+  def Path(cls, key, **kwargs):
+    return perf.FormatChromePath(cls._PATHS[key], **kwargs)
+
+  @classmethod
+  def ReplayServer(cls, archive_name):
+    """Creat a replay server."""
+    # Inject customized scripts for Google webapps.
+    # See the java script file for details.
+    scripts = cls.Path('scripts')
+    if not os.path.exists(scripts):
+      raise webpagereplay.ReplayNotFoundError('injected scripts', scripts)
+    replay_options = ['--inject_scripts', scripts]
+    archive_path = cls.Path('archive', archive_name=archive_name)
+    return webpagereplay.ReplayServer(archive_path, replay_options)
+
+
 if __name__ == '__main__':
   pyauto_functional.Main()