Add simple depends_on API.

recipe_engine/recipe_test_api.py

Index: recipe_engine/recipe_test_api.py
diff --git a/recipe_engine/recipe_test_api.py b/recipe_engine/recipe_test_api.py
index bb1da1cf0b66c6c54c7829a388d741a477ee3f9d..5a8c76610fb870d106372cbcc571104b88c21f8d 100644
--- a/recipe_engine/recipe_test_api.py
+++ b/recipe_engine/recipe_test_api.py
@@ -5,6 +5,7 @@
 import collections
 
 from .util import ModuleInjectionSite, static_call, static_wraps
+from .types import freeze
 
 def combineify(name, dest, a, b):
   """
@@ -159,6 +160,7 @@ class TestData(BaseTestData):
     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):
@@ -170,6 +172,7 @@ class TestData(BaseTestData):
 
     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
@@ -198,6 +201,12 @@ class TestData(BaseTestData):
     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,
@@ -205,6 +214,7 @@ class TestData(BaseTestData):
       '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,
     },)
 
 
@@ -462,3 +472,8 @@ class RecipeTestApi(object):
     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