Add Web Page Replay tests to main perf dashboard.

scripts/master/factory/chromium_commands.py

 # 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.
 
 """Set of utilities to add commands to a buildbot factory.
 
 This is based on commands.py and adds chromium-specific commands."""
 
 import logging
 import os
@@ skipping 268 matching lines @@
                      factory_properties, perf_dashboard_name,
                      process_log.GraphingPageCyclerLogProcessor)
 
     # Get the test's command.
     cmd = self.GetPageCyclerCommand(command_name, enable_http,
                                     factory_properties=factory_properties)
 
     # Add the test step to the factory.
     self.AddTestStep(test_class, test, cmd, do_step_if=self.TestStepFilter)
 
+  def AddWebPageReplayTest(self, test_name, wpr_test,

[tonyg_google, 2012/05/31 01:59:56]

A selfish suggestion: I'm going to be adding some other pyauto perf test steps
here. We could share the same method if you tweak the abstraction slightly and
do:

AddPyAutoPerfTest(self, step_name, pyauto_suite, pyauto_test, ...):
  pyauto_test = 'perf.%s.%s' % (pyauto_suite, pyauto_test)
  ...

Then:

if R('page_cycler_2012Q2-netsim'):
  f.AddPyAutoPerfTest('page_cycler_2012Q2-netsim',
'WebPageReplayPageCyclerTest', 'test2012Q2', fp)

[dennis_jeffrey, 2012/05/31 17:18:53]

I think we could just get rid of this function and call
AddPyAutoFunctionalTest() directly, given the changes to that function below.

[slamm_google, 2012/06/02 22:04:56]

Done.

+                           factory_properties=None, timeout=1800):
+    """Add Web Page Replay Page Cycler test step.
+
+    Args:
+      test_name: a string describing the test, used to build its logfile name
+          and its descriptions in the waterfall display
+      wpr_test_suffix: suffix of pyauto test:
+          perf.WebPageReplayPageCyclerTest.{wpr_test}
+      factory_properties: A dictionary of factory property values.
+      timeout: The buildbot timeout for this step, in seconds.  The step will
+               fail if the test does not produce any output within this time.
+    """
+    pyauto_test = 'perf.WebPageReplayPageCyclerTest.%s' % wpr_test
+    self.AddPyAutoFunctionalTest(
+        test_name, test_args=[pyauto_test], timeout=timeout,
+        perf=True, factory_properties=factory_properties)
+
   def AddStartupTests(self, factory_properties=None):
     factory_properties = factory_properties or {}
     c = self.GetPerfStepClass(factory_properties, 'startup',
                               process_log.GraphingLogProcessor)
 
     test_list = 'StartupTest.*:ShutdownTest.*'
     # We don't need to run the Reference tests in debug mode.
     if self._target == 'Debug':
       test_list += ':-*.*Ref*'
     options = ['--gtest_filter=%s' % test_list]
@@ skipping 357 matching lines @@
     script = J('src', 'chrome', 'test', 'webdriver', 'test',
                'run_chromedriver_tests.py')
     self._AddBasicPythonTest('chromedriver_tests', script, timeout=timeout)
 
   def AddWebDriverTest(self, timeout=1200):
     J = self.PathJoin
     script = J('src', 'chrome', 'test', 'webdriver', 'test',
                'run_webdriver_tests.py')
     self._AddBasicPythonTest('webdriver_tests', script, timeout=timeout)
 
   def AddPyAutoFunctionalTest(self, test_name, timeout=1200,

[slamm_google, 2012/05/31 00:05:28]

Most of this diff is making the code a little easier to read.
All that is needed for Web Page Replay is the new test_args parameter.

I can make this change as a "minimal diff" if needed.

                               workdir=None,
-                              src_base=None,
+                              src_base='.',
                               suite=None,
+                              test_args=None,
                               factory_properties=None,
                               perf=False):
     """Adds a step to run PyAuto functional tests.
 
     Args:
+      test_name: a string describing the test, used to build its logfile name
+          and its descriptions in the waterfall display
+      timeout: The buildbot timeout for this step, in seconds.  The step will
+          fail if the test does not produce any output within this time.
       workdir: the working dir for this step
       src_base: relative path (from workdir) to src. Not needed if workdir is
-                'build' (the default)
+          'build' (the default)
       suite: PyAuto suite to execute.
-      perf: Is this a perf test or not? Requires suite to be set.
+      test_args: list of PyAuto test arguments.
+      factory_properties: A dictionary of factory property values.
+      perf: Is this a perf test or not? Requires suite or test_args to be set.
     """
     factory_properties = factory_properties or {}
     J = self.PathJoin
-    pyauto_script = J('src', 'chrome', 'test', 'functional',
+    pyauto_script = J(src_base, 'src', 'chrome', 'test', 'functional',

[dennis_jeffrey, 2012/05/31 17:18:53]

Cool!  I really like how the "src_base" parameter is being handled now.

                       'pyauto_functional.py')
-    # in case a '..' prefix is needed
-    if src_base:
-      pyauto_script = J(src_base, pyauto_script)
-
-    pyauto_functional_cmd = ['python', pyauto_script, '-v']
+    pyauto_cmd = ['python', pyauto_script, '-v']
     if self._target_platform == 'win32':
-      pyauto_functional_cmd = self.GetPythonTestCommand(pyauto_script, ['-v'])
-      if src_base:  # Adjust runtest.py path if needed.
-        pyauto_functional_cmd[1] = J(src_base, pyauto_functional_cmd[1])
+      pyauto_cmd = self.GetPythonTestCommand(pyauto_script, ['-v'])
+      pyauto_cmd[1] = J(src_base, pyauto_cmd[1])  # adjust runtest.py if needed
     elif self._target_platform == 'darwin':
-      pyauto_functional_cmd = self.GetTestCommand('/usr/bin/python2.5',
-                                                  [pyauto_script, '-v'])
-      if src_base:  # Adjust runtest.py path if needed.
-        pyauto_functional_cmd[1] = J(src_base, pyauto_functional_cmd[1])
+      pyauto_cmd = self.GetTestCommand('/usr/bin/python2.5',
+                                       [pyauto_script, '-v'])
+      pyauto_cmd[1] = J(src_base, pyauto_cmd[1])  # adjust runtest.py if needed
     elif (self._target_platform.startswith('linux') and
           factory_properties.get('use_xvfb_on_linux')):
-      # Run thru runtest.py on linux to launch virtual x server
-      pyauto_functional_cmd = self.GetTestCommand('/usr/bin/python',
-                                                  [pyauto_script, '-v'])
-      if src_base:  # Adjust runtest.py path if needed.
-        pyauto_functional_cmd[1] = J(src_base, pyauto_functional_cmd[1])
+      # On Linux, use runtest.py to launch virtual X server.
+      pyauto_cmd = self.GetTestCommand('/usr/bin/python', [pyauto_script, '-v'])
+      pyauto_cmd[1] = J(src_base, pyauto_cmd[1])  # adjust runtest.py if needed
+    if suite:

[dennis_jeffrey, 2012/05/31 17:18:53]

nit: I recommend adding a blank line right above this, to separate the platform
checks above from the "suite" and "test_args" checks below.

[slamm_google, 2012/06/02 22:04:56]

Done.

+      pyauto_cmd.append('--suite=%s' % suite)
+    if test_args:
+      pyauto_cmd.extend(test_args)
 
-    if suite:
-      pyauto_functional_cmd.append('--suite=%s' % suite)
-
-    # Use special command class for parsing perf values from output.
     command_class = retcode_command.ReturnCodeCommand
-    if perf and suite:
+    if perf and (suite or test_args):
+      # Use special command class for parsing perf values from output.
       command_class = self.GetPerfStepClass(
           factory_properties, suite.lower(),
           process_log.GraphingLogProcessor)
 
     self.AddTestStep(command_class,
                      test_name,
-                     pyauto_functional_cmd,
+                     pyauto_cmd,
                      env={'PYTHONPATH': '.'},
                      workdir=workdir,
                      timeout=timeout,
                      do_step_if=self.GetTestStepFilter(factory_properties))
 
   def AddChromeEndureTest(self, test_class_name, pyauto_test_list,
                           factory_properties, timeout=1200):
     """Adds a step to run PyAuto-based Chrome Endure tests.
 
     Args:
       test_class_name: A string name for this class of tests.
       pyauto_test_list: A list of strings, where each string is the full name
                         of a pyauto test to run (file.class.test_name).
       factory_properties: A dictionary of factory property values.
       timeout: The buildbot timeout for this step, in seconds.  The step will
                fail if the test does not produce any output within this time.
     """
     pyauto_script = self.PathJoin('src', 'chrome', 'test', 'functional',
                                   'pyauto_functional.py')
     # Only run on linux for now.
     if not self._target_platform.startswith('linux'):
       return
 
     for pyauto_test_name in pyauto_test_list:
-      pyauto_functional_cmd = ['python', pyauto_script, '-v']
+      pyauto_cmd = ['python', pyauto_script, '-v']
       if factory_properties.get('use_xvfb_on_linux'):
         # Run through runtest.py on linux to launch virtual x server.
-        pyauto_functional_cmd = self.GetTestCommand('/usr/bin/python',
-                                                    [pyauto_script, '-v'])
-
-      pyauto_functional_cmd.append(pyauto_test_name)
+        pyauto_cmd = self.GetTestCommand('/usr/bin/python',
+                                         [pyauto_script, '-v'])
+      pyauto_cmd.append(pyauto_test_name)
       test_step_name = (test_class_name + ' ' +
                         pyauto_test_name[pyauto_test_name.rfind('.') + 1:])
       self.AddTestStep(retcode_command.ReturnCodeCommand,
                        test_step_name,
-                       pyauto_functional_cmd,
+                       pyauto_cmd,
                        env={'PYTHONPATH': '.'},
                        timeout=timeout,
                        do_step_if=self.GetTestStepFilter(factory_properties))
 
   def AddDevToolsTests(self, factory_properties=None):
     factory_properties = factory_properties or {}
     c = self.GetPerfStepClass(factory_properties, 'devtools_perf',
                               process_log.GraphingLogProcessor)
 
     cmd = [self._python, self._devtools_perf_test_tool,
@@ skipping 367 matching lines @@
   # ArchiveCommand.createSummary.
   return '%s/%s/%s' % (config.Master.archive_url, archive_type, builder_name)
 
 def _GetSnapshotUrl(factory_properties=None, builder_name='%(build_name)s'):
   if not factory_properties or 'gs_bucket' not in factory_properties:
     return (_GetArchiveUrl('snapshots', builder_name), None)
   gs_bucket = factory_properties['gs_bucket']
   gs_bucket = re.sub(r'^gs://', 'http://commondatastorage.googleapis.com/',
                      gs_bucket)
   return ('%s/index.html?path=%s' % (gs_bucket, builder_name), '/')