Support variable substitution and tryserver- and waterfall-only cmd line args.

scripts/slave/recipe_modules/chromium_tests/api.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 collections
 import contextlib
 import copy
 import itertools
 import json
 
@@ skipping 30 matching lines @@
     'chromium.fyi': 35,  # This should be lower than the CQ.
     'chromium.memory.fyi': 27,
 })
 
 
 class ChromiumTestsApi(recipe_api.RecipeApi):
   def __init__(self, *args, **kwargs):
     super(ChromiumTestsApi, self).__init__(*args, **kwargs)
     self._builders = {}
     self.add_builders(builders.BUILDERS)
+    self._precommit_mode = False
 
   @property
   def builders(self):
     return self._builders
 
   @property
   def steps(self):
     return steps
 
   @property
   def trybots(self):
     return trybots.TRYBOTS
 
   def add_builders(self, builders):
     """Adds builders to our builder map"""
     self._builders.update(builders)
 
   def create_bot_config_object(self, mastername, buildername):
     bot_id = {'mastername': mastername, 'buildername': buildername}
     return bdb_module.BotConfig(self.builders, [bot_id])
 
   def create_generalized_bot_config_object(self, bot_ids):
     return bdb_module.BotConfig(self.builders, bot_ids)
 
+  def set_precommit_mode(self):
+    """Configures this module to indicate that tests are running before
+    the changes are committed. This must be called very early in the
+    recipe, certainly before prepare_checkout, and the action can not
+    be undone.
+    """
+    self._precommit_mode = True
+
+  def is_precommit_mode(self):
+    """Returns a Boolean indicating whether this module is running in
+    precommit mode; i.e., whether tests are running before the changes
+    are committed.
+    """
+    return self._precommit_mode
+
   def configure_build(self, bot_config, override_bot_type=None):
     # Get the buildspec version. It can be supplied as a build property or as
     # a recipe config value.
     buildspec_version = (self.m.properties.get('buildspec_version') or
                          bot_config.get('buildspec_version'))
 
     self.m.chromium.set_config(
         bot_config.get('chromium_config'),
         **bot_config.get('chromium_config_kwargs', {}))
 
@@ skipping 101 matching lines @@
             lambda bot_id: bot_id['mastername'] == 'tryserver.chromium.perf' and
                            bot_id['buildername'].endswith('builder'))
         and bot_config.get('bot_type') == 'builder'):
       if bot_config.should_force_legacy_compiling(self):
         self.m.chromium.c.project_generator.tool = 'gyp'
 
     self.set_up_swarming(bot_config)
     self.runhooks(update_step)
 
     bot_db = bdb_module.BotConfigAndTestDB()
-    bot_config.initialize_bot_db(self, bot_db)
+    bot_config.initialize_bot_db(self, bot_db, update_step)
 
     if self.m.chromium.c.lto and \
         not self.m.chromium.c.env.LLVM_FORCE_HEAD_REVISION:
       self.m.chromium.download_lto_plugin()
 
     return update_step, bot_db
 
   def generate_tests_from_test_spec(self, api, test_spec, builder_dict,
       buildername, mastername, enable_swarming, scripts_compile_targets,
-      generators):
+      generators, bot_update_step):
     tests = builder_dict.get('tests', ())
     # TODO(phajdan.jr): Switch everything to scripts generators and simplify.
     for generator in generators:
       tests = (
-          tuple(generator(api, mastername, buildername, test_spec,
-                         enable_swarming=enable_swarming,
+          tuple(generator(api, self, mastername, buildername, test_spec,
+                         bot_update_step, enable_swarming=enable_swarming,
                          scripts_compile_targets=scripts_compile_targets)) +
           tests)
     return tests
 
   def read_test_spec(self, api, test_spec_file):
     test_spec_path = api.path['checkout'].join('testing', 'buildbot',
                                                test_spec_file)
     test_spec_result = api.json.read(
         'read test spec',
         test_spec_path,
@@ skipping 581 matching lines @@
   def get_compile_targets_for_scripts(self):
     return self.m.python(
         name='get compile targets for scripts',
         script=self.m.path['checkout'].join(
             'testing', 'scripts', 'get_compile_targets.py'),
         args=[
             '--output', self.m.json.output(),
             '--',
         ] + self.get_common_args_for_scripts(),
         step_test_data=lambda: self.m.json.test_api.output({}))