Split Placeholder into InputPlaceholder and OutputPlaceholder.

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
 
@@ skipping 37 matching lines @@
 
 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] }
+    # { (module, placeholder) -> [data] }. These are for output placeholders.
     self.placeholder_data = collections.defaultdict(list)
     self.override = False
     self._stdout = None
     self._stderr = None
     self._retcode = None
 
   def __add__(self, other):
     assert isinstance(other, StepTestData)
 
     if other.override:
@@ skipping 208 matching lines @@
     mod_name = self._module.NAME  # pylint: disable=W0212
     ret = TestData(None)
     data = static_call(self, func, *args, **kwargs)
     ret.mod_data[mod_name][inner.__name__] = data
     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
+  return just the output placeholder data, instead of the normally required
   StepTestData() object.
 
   The wrapped function may return either:
     * <placeholder data>, <retcode 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:
@@ skipping 33 matching lines @@
   @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_step_data is only expecting a single output placeholder '
+        'datum. Got: %r' % data
       )
       placeholder_data, retcode = all_data[0], data.retcode
     else:
       placeholder_data, retcode = data
       placeholder_data = PlaceholderTestData(placeholder_data)
 
     ret = StepTestData()
     ret.placeholder_data[(mod_name, inner.__name__)].append(placeholder_data)
     ret.retcode = retcode
     return ret
@@ skipping 84 matching lines @@
 
     Used by step_data and override_step_data.
 
     Args:
       name - The name of the step we're providing data for
       data - Zero or more StepTestData objects. These may fill in placeholder
              data for zero or more modules, as well as possibly setting the
              retcode for this step.
       retcode=(int or None) - Override the retcode for this step, even if it
              was set by |data|. This must be set as a keyword arg.
-      stdout - StepTestData object with placeholder data for a step's stdout.
-      stderr - StepTestData object with placeholder data for a step's stderr.
+      stdout - StepTestData object with a single output placeholder datum for a
+             step's stdout.
+      stderr - StepTestData object with a single output placeholder datum for a
+             step's stderr.
       override=(bool) - This step data completely replaces any previously
              generated step data, instead of adding on to it.
 
     Use in GenTests:
       # Hypothetically, suppose that your recipe has default test data for two
       # steps 'init' and 'sync' (probably via recipe_api.inject_test_data()).
       # For this example, lets say that the default test data looks like:
       #   api.step_data('init', api.json.output({'some': ["cool", "json"]}))
       # AND
       #   api.step_data('sync', api.json.output({'src': {'rev': 100}}))
@@ skipping 44 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