Make output placeholders like json.output index-able by name.

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 .util import ModuleInjectionSite, Placeholder, static_call, static_wraps
 from .types import freeze
 
-def combineify(name, dest, a, b):
+def combineify(name, dest, a, b, overwrite=False):
   """
   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
+    overwrite - whether to over write the value from a with the same key.

[iannucci, 2016/03/10 03:17:42]

So I think that now they're all named, there's no longer a need for override vs.
non-override. The behavior should always be override-by-name

[stgao, 2016/03/10 20:34:22]

Unfortunately, we still have to do it this way, because of `mod_data`,
'step_data`, and `depend_on_data` in TestData, see line #174-176.

We could only overwrite `placeholder_data`.

   """
   dest_dict = getattr(dest, name)
   dest_dict.update(getattr(a, name))
   for k, v in getattr(b, name).iteritems():
     if k in dest_dict:
-      dest_dict[k] += v
+      if not overwrite:
+        dest_dict[k] += v
+      else:
+        dest_dict[k] = v
     else:
       dest_dict[k] = v
 
 
 class BaseTestData(object):
   def __init__(self, enabled=True):
     super(BaseTestData, self).__init__()
     self._enabled = enabled
 
   @property
   def enabled(self):
     return self._enabled
 
 
 class PlaceholderTestData(BaseTestData):
-  def __init__(self, data=None):
+  def __init__(self, data=None, id=None):
     super(PlaceholderTestData, self).__init__()
     self.data = data
+    self.id = id or Placeholder.DEFAULT_ID
 
   def __repr__(self):
     return "PlaceholderTestData(%r)" % (self.data,)
 
 
 class StepTestData(BaseTestData):
   """
   Mutable container for per-step test data.
 
   This data is consumed while running the recipe (during
   annotated_run.run_steps).
   """
   def __init__(self):
     super(StepTestData, self).__init__()
-    # { (module, placeholder) -> [data] }
-    self.placeholder_data = collections.defaultdict(list)
+    # { (module, placeholder, id) -> data }
+    self.placeholder_data = {}
     self.override = False
     self._stdout = None
     self._stderr = None
     self._retcode = None
 
   def __add__(self, other):
     assert isinstance(other, StepTestData)
 
     if other.override:
       return other
 
     ret = StepTestData()
 
-    combineify('placeholder_data', ret, self, other)
+    combineify('placeholder_data', ret, self, other, overwrite=True)
 
     # pylint: disable=W0212
     ret._stdout = other._stdout or self._stdout
     ret._stderr = other._stderr or self._stderr
     ret._retcode = self._retcode
     if other._retcode is not None:
       assert ret._retcode is None
       ret._retcode = other._retcode
 
     return ret
 
   def unwrap_placeholder(self):
-    # {(module, placeholder): [data]} => data.
+    # {(module, placeholder, id): data} => data.
     assert len(self.placeholder_data) == 1
-    data_list = self.placeholder_data.items()[0][1]
-    assert len(data_list) == 1
-    return data_list[0]
+    return self.placeholder_data.values()[0]
 
-  def pop_placeholder(self, name_pieces):
-    l = self.placeholder_data[name_pieces]
-    if l:
-      return l.pop(0)
-    else:
-      return PlaceholderTestData()
+  def pop_placeholder(self, module_name, placeholder_name, id):
+    return self.placeholder_data.pop((module_name, placeholder_name, id),
+                                     PlaceholderTestData())
 
   @property
   def retcode(self):  # pylint: disable=E0202
     return self._retcode or 0
 
   @retcode.setter
   def retcode(self, value):  # pylint: disable=E0202
     self._retcode = value
 
   @property
@@ skipping 142 matching lines @@
     },)
 
 
 class DisabledTestData(BaseTestData):
   def __init__(self):
     super(DisabledTestData, self).__init__(False)
 
   def __getattr__(self, name):
     return self
 
-  def pop_placeholder(self, _name_pieces):
+  def pop_placeholder(self, _module_name, _placeholder_name, _id):
     return self
 
   def pop_step_test_data(self, _step_name, _step_test_data_fn):
     return self
 
   def get_module_test_data(self, _module_name):
     return self
 
   @contextlib.contextmanager
   def should_raise_exception(self, exception): # pylint: disable=unused-argument
@@ skipping 10 matching lines @@
     return ret
   return inner
 
 
 def placeholder_step_data(func):
   """Decorates RecipeTestApi member functions to allow those functions to
   return just the placeholder data, instead of the normally required
   StepTestData() object.
 
   The wrapped function may return either:
-    * <placeholder data>, <retcode or None>
+    * <placeholder data>, <retcode or None>, <id or None>
     * StepTestData containing exactly one PlaceholderTestData and possible a
       retcode. This is useful for returning the result of another method which
       is wrapped with placeholder_step_data.
 
   In either case, the wrapper function will return a StepTestData object with
   the retcode and placeholder datum inserted with a name of:
-    (<Test module name>, <wrapped function name>)
+    (<Test module name>, <wrapped function name>, <id>)
 
   Say you had a 'foo_module' with the following RecipeTestApi:
     class FooTestApi(RecipeTestApi):
       @placeholder_step_data
       @staticmethod
-      def cool_method(data, retcode=None):
-        return ("Test data (%s)" % data), retcode
+      def cool_method(data, retcode=None, id=None):
+        return ("Test data (%s)" % data), retcode, id
 
       @placeholder_step_data
-      def other_method(self, retcode=None):
-        return self.cool_method('hammer time', retcode)
+      def other_method(self, retcode=None, id=None):
+        return self.cool_method('hammer time', retcode=retcode, id=id)
 
-  Code calling cool_method('hello') would get a StepTestData:
+  Code calling cool_method('hello', id='cool1') would get a StepTestData:
     StepTestData(
       placeholder_data = {
-        ('foo_module', 'cool_method'): [
+        ('foo_module', 'cool_method', 'cool1') :
           PlaceholderTestData('Test data (hello)')
-        ]
       },
       retcode = None
     )
 
-  Code calling other_method(50) would get a StepTestData:
+  Code calling other_method(retcode=50, id='other1') would get a StepTestData:
     StepTestData(
       placeholder_data = {
-        ('foo_module', 'other_method'): [
+        ('foo_module', 'other_method', 'other1'):
           PlaceholderTestData('Test data (hammer time)')
-        ]
       },
       retcode = 50
     )
   """
   @static_wraps(func)
   def inner(self, *args, **kwargs):
     assert isinstance(self, RecipeTestApi)
     mod_name = self._module.NAME  # pylint: disable=W0212
     data = static_call(self, func, *args, **kwargs)
     if isinstance(data, StepTestData):
       all_data = [i
                   for l in data.placeholder_data.values()
                   for i in l]
       assert len(all_data) == 1, (
         'placeholder_step_data is only expecting a single placeholder datum. '
         'Got: %r' % data
       )
       placeholder_data, retcode = all_data[0], data.retcode
     else:
-      placeholder_data, retcode = data
-      placeholder_data = PlaceholderTestData(placeholder_data)
+      placeholder_data, retcode, id = data
+      placeholder_data = PlaceholderTestData(placeholder_data, id=id)
 
     ret = StepTestData()
-    ret.placeholder_data[(mod_name, inner.__name__)].append(placeholder_data)
+    key = (mod_name, inner.__name__, placeholder_data.id)
+    ret.placeholder_data[key] = placeholder_data
     ret.retcode = retcode
     return ret
   return inner
 
 
 class RecipeTestApi(object):
   """Provides testing interface for GenTest method.
 
   There are two primary components to the test api:
     * Test data creation methods (test and step_data)
     * test_api's from all the modules in DEPS.
 
   Every test in GenTests(api) takes the form:
     yield <instance of TestData>
 
   There are 4 basic pieces to TestData:
     name       - The name of the test.
     properties - Simple key-value dictionary which is used as the combined
                  build_properties and factory_properties for this test.
     mod_data   - Module-specific testing data (see the platform module for a
                  good example). This is testing data which is only used once at
                  the start of the execution of the recipe. Modules should
                  provide methods to get their specific test information. See
                  the platform module's test_api for a good example of this.
     step_data  - Step-specific data. There are two major components to this.
         retcode          - The return code of the step
-        placeholder_data - A mapping from placeholder name to the a list of
+        placeholder_data - A mapping from placeholder name to the list of
                            PlaceholderTestData objects, one for each instance
                            of that kind of Placeholder in the step.
         stdout, stderr   - PlaceholderTestData objects for stdout and stderr.
 
   TestData objects are concatenatable, so it's convenient to phrase test cases
   as a series of added TestData objects. For example:
     DEPS = ['properties', 'platform', 'json']
     def GenTests(api):
       yield (
         api.test('try_win64') +
@@ skipping 115 matching lines @@
 
   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