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
 import contextlib
 
 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
 
   @property
   def consumed(self):
     return not (self.step_data or self.expected_exception)
 
@@ skipping 39 matching lines @@
             raise
     """
     name = exception.__class__.__name__
     should_raise = not (self.enabled and name == self.expected_exception)
 
     yield should_raise
 
     if not should_raise:
       self.expected_exception = None
 
+  def depend_on(self, recipe, properties, result):
+    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)
+
   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