V8: Make sure infra failures fail overall build

scripts/slave/recipe_modules/v8/testing.py

 # Copyright 2015 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
 from recipe_engine.types import freeze
 
 
 class V8TestingVariants(object):
   """Immutable class to manage the testing variant passed to v8.
@@ skipping 480 matching lines @@
 
     # Arguments for actual 'collect' command.
     args.append('--')
     args.extend(self.api.swarming.get_collect_cmd_args(task))
 
     return self.api.python(
         name=self.test['name'] + self.test_step_config.suffix,
         script=self.v8.resource('collect_v8_task.py'),
         args=args,
         allow_subannotations=True,
+        infra_step=True,
         step_test_data=kwargs.pop('step_test_data', None),
         **kwargs)
 
   def pre_run(self, test=None, coverage_context=NULL_COVERAGE, **kwargs):
     # Set up arguments for test runner.
     self.test = test or TEST_CONFIGS[self.name]
     extra_args, _ = self.v8._setup_test_runner(
         self.test, self.applied_test_filter, self.test_step_config)
 
     # Let json results be stored in swarming's output folder. The collect
@@ skipping 30 matching lines @@
     if 'os' not in self.task.dimensions:
       self.task.dimensions['os'] = self.api.swarming.prefered_os_dimension(
           self.api.platform.name)
 
     self.api.swarming.trigger_task(self.task)
 
   def run(self, coverage_context=NULL_COVERAGE, **kwargs):
     # TODO(machenbach): Soften this when softening 'assert isolated_hash'
     # above.
     assert self.task
+    result = TestResults.empty()
     try:
       # Collect swarming results. Use the same test simulation data for the
       # swarming collect step like for local testing.
-      result = self.api.swarming.collect_task(
+      self.api.swarming.collect_task(
         self.task,
         step_test_data=lambda: self.v8.test_api.output_json(),
       )
-    finally:
-      # Note: Exceptions from post_run might hide a pending exception from the
-      # try block.
-      return self.post_run(self.test, coverage_context)
+    except self.api.step.InfraFailure as e:
+      result += TestResults.infra_failure(e)
+
+    return result + self.post_run(self.test, coverage_context)
 
   def rerun(self, failure_dict, **kwargs):
     self.pre_run(test=self._setup_rerun_config(failure_dict), **kwargs)
     return self.run(**kwargs)
 
 
 class V8Presubmit(BaseTest):
   def run(self, **kwargs):
     self.api.python(
       'Presubmit',
@@ skipping 185 matching lines @@
 class TestResults(object):
   def __init__(self, failures, flakes, infra_failures):
     self.failures = failures
     self.flakes = flakes
     self.infra_failures = infra_failures
 
   @staticmethod
   def empty():
     return TestResults([], [], [])
 
+  @staticmethod
+  def infra_failure(exception):
+    return TestResults([], [], [exception])
+
   @property
   def is_negative(self):
     return bool(self.failures or self.flakes or self.infra_failures)
 
   @property
   def has_failures(self):
     return bool(self.failures or self.infra_failures)
 
   def __add__(self, other):
     return TestResults(
         self.failures + other.failures,
         self.flakes + other.flakes,
         self.infra_failures + other.infra_failures,
     )
 
 
 def create_test(test_step_config, api, v8_api):
   test_cls = V8_NON_STANDARD_TESTS.get(test_step_config.name)
   if not test_cls:
     # TODO(machenbach): Implement swarming for non-standard tests.
     if v8_api.bot_config.get('enable_swarming') and test_step_config.swarming:
       tools_mapping = TOOL_TO_TEST_SWARMING
     else:
       tools_mapping = TOOL_TO_TEST
 
     # The tool the test is going to use. Default: V8 test runner (run-tests).
     tool = TEST_CONFIGS[test_step_config.name].get('tool', 'run-tests')
     test_cls = tools_mapping[tool]
   return test_cls(test_step_config, api, v8_api)