Add simple depends_on API.

recipe_engine/recipe_test_api.py

 # Copyright 2013-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 collections
 
 from .util import ModuleInjectionSite, static_call, static_wraps
+from .types import freeze
 
 def combineify(name, dest, a, b):
   """
   Combines dictionary members in two objects into a third one using addition.
 
   Args:
     name - the name of the member
     dest - the destination object
     a - the first source object
     b - the second source object
@@ skipping 134 matching lines @@
     return "ModuleTestData(%r)" % super(ModuleTestData, self).__repr__()
 
 
 class TestData(BaseTestData):
   def __init__(self, name=None):
     super(TestData, self).__init__()
     self.name = name
     self.properties = {}  # key -> val
     self.mod_data = collections.defaultdict(ModuleTestData)
     self.step_data = collections.defaultdict(StepTestData)
+    self.depend_on_data = {}
     self.expected_exception = None
 
   def __add__(self, other):
     assert isinstance(other, TestData)
     ret = TestData(self.name or other.name)
 
     ret.properties.update(self.properties)
     ret.properties.update(other.properties)
 
     combineify('mod_data', ret, self, other)
     combineify('step_data', ret, self, other)
+    combineify('depend_on_data', ret, self, other)
     ret.expected_exception = self.expected_exception
     if other.expected_exception:
       ret.expected_exception = other.expected_exception
 
     return ret
 
   def empty(self):
     return not self.step_data
 
   def pop_step_test_data(self, step_name, step_test_data_fn):
     step_test_data = step_test_data_fn()
     if step_name in self.step_data:
       step_test_data += self.step_data.pop(step_name)
     return step_test_data
 
   def get_module_test_data(self, module_name):
     return self.mod_data.get(module_name, ModuleTestData())
 
   def expect_exception(self, exception):
     assert not self.expected_exception
     assert isinstance(exception, basestring), (
         'expect_exception expects a string containing the exception class name')
     self.expected_exception = exception
 
   def is_unexpected_exception(self, exception):
     name = exception.__class__.__name__
     return not (self.enabled and name == self.expected_exception)
 
+  def depend_on(self, recipe, properties, result):

[iannucci, 2015/11/20 02:00:19]

can we check that result conforms to the RETURN_SCHEMA of recipe?

[martiniss, 2015/11/23 22:05:07]

Yes. Did this in run.py since this file doesn't know how to load the recipe.

+    tup = freeze((recipe, properties))
+    assert tup not in self.depend_on_data, (
+        'Already gave test data for recipe %s with properties %r' % tup)
+    self.depend_on_data[tup] = freeze(result)

[iannucci, 2015/11/20 02:00:19]

Is there a way to distinguish the case where we re-try the same job
(recipe+properties) intentionally? e.g. when we retry to detect potential flake?

What about depending on multiple runs of the same job in parallel (preemptive
flake detection)?

Or will these flows require the 'advanced' API and are out of scope for this CL?

[martiniss, 2015/11/23 22:05:07]

Retrying the same job may partially be supported by this API. It will be much
more fully supported by the more advanced API.

One thing we could do is to de-dup the recipe "names" in a similar way that we
de-duplicate step names. If we see a recipe twice, then we just add a " (1)" to
the end of it. Not totally sure if that will work, but I'll think about it more
carefully in the future.

+
   def __repr__(self):
     return "TestData(%r)" % ({
       'name': self.name,
       'properties': self.properties,
       'mod_data': dict(self.mod_data.iteritems()),
       'step_data': dict(self.step_data.iteritems()),
       'expected_exception': self.expected_exception,
+      'depend_on_data': self.depend_on_data,
     },)
 
 
 class DisabledTestData(BaseTestData):
   def __init__(self):
     super(DisabledTestData, self).__init__(False)
 
   def __getattr__(self, name):
     return self
 
@@ skipping 237 matching lines @@
   def override_step_data(self, name, *data, **kwargs):
     """See _step_data()"""
     kwargs['override'] = True
     return self._step_data(name, *data, **kwargs)
   override_step_data.__doc__ = _step_data.__doc__
 
   def expect_exception(self, exc_type): #pylint: disable=R0201
     ret = TestData(None)
     ret.expect_exception(exc_type)
     return ret
+
+  def depend_on(self, recipe, properties, result):
+    ret = TestData()
+    ret.depend_on(recipe, properties, result)
+    return ret