Split Placeholder into InputPlaceholder and OutputPlaceholder.

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 9015267afb6ebfe730a8bb84ead952205403c470..117bfe33ae8d39eb769454d3f5a0bf14309fbdce 100644
--- a/recipe_engine/recipe_test_api.py
+++ b/recipe_engine/recipe_test_api.py
@@ -5,7 +5,7 @@
 import collections
 import contextlib
 
-from .util import ModuleInjectionSite, static_call, static_wraps
+from . import util
 from .types import freeze
 
 def combineify(name, dest, a, b):
@@ -56,7 +56,8 @@ class StepTestData(BaseTestData):
   def __init__(self):
     super(StepTestData, self).__init__()
     # { (module, placeholder) -> [data] }
-    self.placeholder_data = collections.defaultdict(list)
+    self.input_placeholder_data = collections.defaultdict(list)

[iannucci, 2016/03/12 03:36:12]

I don't think there needs to be input_placeholder_data here; inputs are never
mocked in tests. This file shouldn't need to change very much at all, just
clarify that 'placeholder_data' means output placeholders.

[stgao, 2016/03/22 05:56:43]

Done. Also update other docstrings and error messages.

+    self.output_placeholder_data = collections.defaultdict(list)
     self.override = False
     self._stdout = None
     self._stderr = None
@@ -70,7 +71,8 @@ class StepTestData(BaseTestData):
 
     ret = StepTestData()
 
-    combineify('placeholder_data', ret, self, other)
+    combineify('input_placeholder_data', ret, self, other)
+    combineify('output_placeholder_data', ret, self, other)
 
     # pylint: disable=W0212
     ret._stdout = other._stdout or self._stdout
@@ -82,20 +84,26 @@ class StepTestData(BaseTestData):
 
     return ret
 
-  def unwrap_placeholder(self):
+  def unwrap_output_placeholder(self):
     # {(module, placeholder): [data]} => data.
-    assert len(self.placeholder_data) == 1
-    data_list = self.placeholder_data.items()[0][1]
+    assert len(self.output_placeholder_data) == 1
+    data_list = self.output_placeholder_data.items()[0][1]
     assert len(data_list) == 1
     return data_list[0]
 
-  def pop_placeholder(self, name_pieces):
-    l = self.placeholder_data[name_pieces]
+  def _pop_placeholder(self, name_pieces, placeholder_data):
+    l = placeholder_data[name_pieces]
     if l:
       return l.pop(0)
     else:
       return PlaceholderTestData()
 
+  def pop_input_placeholder(self, name_pieces):
+    return self._pop_placeholder(name_pieces, self.input_placeholder_data)
+
+  def pop_output_placeholder(self, name_pieces):
+    return self._pop_placeholder(name_pieces, self.output_placeholder_data)
+
   @property
   def retcode(self):  # pylint: disable=E0202
     return self._retcode or 0
@@ -257,7 +265,10 @@ class DisabledTestData(BaseTestData):
   def __getattr__(self, name):
     return self
 
-  def pop_placeholder(self, _name_pieces):
+  def pop_input_placeholder(self, _name_pieces):
+    return self
+
+  def pop_output_placeholder(self, _name_pieces):
     return self
 
   def pop_step_test_data(self, _step_name, _step_test_data_fn):
@@ -271,12 +282,12 @@ class DisabledTestData(BaseTestData):
     yield True
 
 def mod_test_data(func):
-  @static_wraps(func)
+  @util.static_wraps(func)
   def inner(self, *args, **kwargs):
     assert isinstance(self, RecipeTestApi)
     mod_name = self._module.NAME  # pylint: disable=W0212
     ret = TestData(None)
-    data = static_call(self, func, *args, **kwargs)
+    data = util.static_call(self, func, *args, **kwargs)
     ret.mod_data[mod_name][inner.__name__] = data
     return ret
   return inner
@@ -284,7 +295,7 @@ def mod_test_data(func):
 
 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:
@@ -310,7 +321,7 @@ def placeholder_step_data(func):
 
   Code calling cool_method('hello') would get a StepTestData:
     StepTestData(
-      placeholder_data = {
+      output_placeholder_data = {
         ('foo_module', 'cool_method'): [
           PlaceholderTestData('Test data (hello)')
         ]
@@ -320,7 +331,7 @@ def placeholder_step_data(func):
 
   Code calling other_method(50) would get a StepTestData:
     StepTestData(
-      placeholder_data = {
+      output_placeholder_data = {
         ('foo_module', 'other_method'): [
           PlaceholderTestData('Test data (hammer time)')
         ]
@@ -328,18 +339,16 @@ def placeholder_step_data(func):
       retcode = 50
     )
   """
-  @static_wraps(func)
+  @util.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)
+    data = util.static_call(self, func, *args, **kwargs)
     if isinstance(data, StepTestData):
-      all_data = [i
-                  for l in data.placeholder_data.values()
-                  for i in l]
+      all_data = data.output_placeholder_data.values()
       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:
@@ -347,7 +356,8 @@ def placeholder_step_data(func):
       placeholder_data = PlaceholderTestData(placeholder_data)
 
     ret = StepTestData()
-    ret.placeholder_data[(mod_name, inner.__name__)].append(placeholder_data)
+    ret.output_placeholder_data[(mod_name, inner.__name__)].append(
+        placeholder_data)
     ret.retcode = retcode
     return ret
   return inner
@@ -410,7 +420,7 @@ class RecipeTestApi(object):
     """Note: Injected dependencies are NOT available in __init__()."""
     # If we're the 'root' api, inject directly into 'self'.
     # Otherwise inject into 'self.m'
-    self.m = self if module is None else ModuleInjectionSite()
+    self.m = self if module is None else util.ModuleInjectionSite()
     self._module = module
 
   @staticmethod
@@ -444,8 +454,10 @@ class RecipeTestApi(object):
              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.
 
@@ -487,7 +499,8 @@ class RecipeTestApi(object):
       if key in kwargs:
         stdio_test_data = kwargs[key]
         assert isinstance(stdio_test_data, StepTestData)
-        setattr(ret.step_data[name], key, stdio_test_data.unwrap_placeholder())
+        setattr(ret.step_data[name], key,
+                stdio_test_data.unwrap_output_placeholder())
     return ret
 
   def step_data(self, name, *data, **kwargs):