Add swarming support for IsolatedScriptTest.

scripts/slave/recipe_modules/chromium_tests/steps.py

 # Copyright 2014 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.
 
 import re
 import string
 
 
 class Test(object):
   """
@@ skipping 859 matching lines @@
     isolate_file_path = (api.path['checkout'].join(self._android_isolate_path)
                          if self._android_isolate_path else None)
     return AndroidInstrumentationTest(
         name=self.name,
         compile_target=self._compile_target,
         apk_under_test=self._apk_under_test,
         test_apk=self.name,
         isolate_file_path=isolate_file_path).run(api, suffix)
 
 
-class IsolatedScriptTest(Test):
+class LocalIsolatedScriptTest(Test):
   def __init__(self, name, args=None, target_name=None, **runtest_kwargs):
-    """Constructs an instance of IsolatedScriptTest.
+    """Constructs an instance of LocalIsolatedScriptTest.
 
-    An IsolatedScriptTest knows how to invoke an isolate which obeys a certain
+    An LocalIsolatedScriptTest knows how to invoke an isolate which obeys a certain
     contract. The isolate's main target must be a wrapper script which must
     interpret certain command line arguments as follows:
 
       --isolated-script-test-output [FILENAME]
 
     The wrapper script must write the simplified json output that the recipes
     consume (similar to GTestTest and ScriptTest) into |FILENAME|.
 
     The contract may be expanded later to support functionality like sharding
     and retries of specific failed tests. Currently the examples of such wrapper
     scripts live in src/testing/scripts/ in the Chromium workspace.
 
     Args:
       name: Displayed name of the test. May be modified by suffixes.
       args: Arguments to be passed to the test.
       target_name: Actual name of the test. Defaults to name.
       runtest_kwargs: Additional keyword args forwarded to the runtest.
     """
-    super(IsolatedScriptTest, self).__init__()
+    super(LocalIsolatedScriptTest, self).__init__()
     self._name = name
     self._args = args or []
     self._target_name = target_name
     self._runtest_kwargs = runtest_kwargs
 
   @property
   def name(self):
     return self._name
 
   @property
@@ skipping 50 matching lines @@
       self.failures(api, suffix)
 
       return self._test_runs[suffix].json.output['valid']
     except Exception:  # pragma: no cover
       return False
 
   def failures(self, api, suffix):
     return self._test_runs[suffix].json.output['failures']
 
 
+class SwarmingIsolatedScriptTest(SwarmingTest):
+  def __init__(self, name, args=None, target_name=None, shards=1,
+               dimensions=None, tags=None, extra_suffix=None,
+               upload_test_results=True):
+    super(SwarmingIsolatedScriptTest, self).__init__(
+        name, dimensions, tags, target_name, extra_suffix)
+    self._args = args or []
+    self._shards = shards
+    self._upload_test_results = upload_test_results
+
+  @property
+  def target_name(self):
+    return self._target_name or self._name
+
+  def compile_targets(self, _):
+    return [self.target_name]
+
+  @property
+  def uses_swarming(self):
+    return True
+
+  def create_task(self, api, suffix, isolated_hash):
+    # For local tests args are added inside api.chromium.run_telemetry_test.
+    browser_config = api.chromium.c.build_config_fs.lower()
+    args = self._args[:]
+
+    # TODO(nednguyen): only rerun the tests that failed.
+    if suffix == 'without patch':  # pragma: no cover
+      pass
+
+    # For the time being, we assume all isolated_script_test are not idempotent
+    # TODO(nednguyen): make this configurable in isolated_scripts's spec.
+    return api.swarming.isolated_script_task(
+        title=self._step_name(suffix), isolated_hash=isolated_hash,
+        idempotent=False, extra_args=args)
+
+  def validate_task_results(self, api, step_result):
+    results = getattr(step_result, 'isolated_script_results', None) or {}
+
+    try:
+      failures = results['failures']
+      if not failures and step_result.retcode != 0:
+        failures = ['%s (entire test suite)' % self.name]
+      valid = results['valid']
+    except (ValueError, KeyError) as e:
+      step_result.presentation.logs['invalid_results_exc'] = [str(e)]
+      valid = False
+      failures = None
+    if valid:
+      step_result.presentation.step_text += api.test_utils.format_step_text([
+        ['failures:', failures]
+      ])
+    return valid, failures
+
 def generate_isolated_script(api, mastername, buildername, test_spec,
                              enable_swarming=False,
                              scripts_compile_targets=None):
-  for spec in test_spec.get(buildername, {}).get(
-      'isolated_scripts', []):
-    yield IsolatedScriptTest(
-        str(spec['name']),
-        args=spec.get('args', []),
-        target_name=spec['isolate_name'])
+  for spec in test_spec.get(buildername, {}).get('isolated_scripts', []):
+    use_swarming = False
+    swarming_shards = 1
+    if enable_swarming:
+      swarming_spec = spec.get('swarming', {})
+      if swarming_spec.get('can_use_on_swarming_builders', False):
+        use_swarming = True
+        swarming_shards = swarming_spec.get('shards', 1)
+    name = str(spec['name'])
+    args = args=spec.get('args', [])
+    target_name = spec['isolate_name']
+    if use_swarming:
+      yield SwarmingIsolatedScriptTest(
+          name=name, args=args, target_name=target_name, shards=swarming_shards)
+    else:
+      yield LocalIsolatedScriptTest(
+          name=name, args=args, target_name=target_name)
 
 
 class GTestTest(Test):
   def __init__(self, name, args=None, target_name=None, enable_swarming=False,
                swarming_shards=1, swarming_dimensions=None, swarming_tags=None,
                swarming_extra_suffix=None, **runtest_kwargs):
     super(GTestTest, self).__init__()
     if enable_swarming:
       self._test = SwarmingGTestTest(
           name, args, target_name, swarming_shards, swarming_dimensions,
@@ skipping 707 matching lines @@
   def run(self, api, suffix):
     api.chromium_android.coverage_report(upload=False)
     api.chromium_android.get_changed_lines_for_revision()
     api.chromium_android.incremental_coverage_report()
 
 
 GOMA_TESTS = [
   GTestTest('base_unittests'),
   GTestTest('content_unittests'),
 ]