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)
     ret.expected_exception = self.expected_exception
     if other.expected_exception:
       ret.expected_exception = other.expected_exception
+    ret.depend_on_data.update(self.depend_on_data)

[Paweł Hajdan Jr., 2015/11/13 12:30:00]

Would it make sense to use combineify here for consistency with mod_data and
step_data?

If not, consider adding a comment explaining why.

[martiniss, 2015/11/13 23:19:02]

That works alright. Fixed.

+    ret.depend_on_data.update(other.depend_on_data)
 
     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):
+    assert recipe not in self.depend_on_data, (

[Paweł Hajdan Jr., 2015/11/13 12:30:00]

If I understand this correctly, this uses recipe as a key, which means it
wouldn't be possible to have several invocations of the same recipe with
different properties - is that right?

I'd suggest changing the key from recipe to (recipe, properties). WDYT?

[martiniss, 2015/11/13 23:19:02]

Changed to recipe, properties.

+        "Already gave test data for %s" % recipe)

[Paweł Hajdan Jr., 2015/11/13 12:30:00]

nit: Prefer single quotes ' .

[martiniss, 2015/11/13 23:19:02]

Fixed.

+    self.depend_on_data[recipe] = freeze((properties, 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