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 . import util
 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
@@ skipping 30 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] }
-    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
     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('input_placeholder_data', ret, self, other)
+    combineify('output_placeholder_data', ret, self, other)
 
     # 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):
+  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
 
   @retcode.setter
   def retcode(self, value):  # pylint: disable=E0202
     self._retcode = value
 
   @property
   def stdout(self):
@@ skipping 141 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_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):
     return self
 
   def get_module_test_data(self, _module_name):
     return self
 
   @contextlib.contextmanager
   def should_raise_exception(self, exception): # pylint: disable=unused-argument
     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
 
 
 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:
     (<Test module name>, <wrapped function name>)
 
   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
 
       @placeholder_step_data
       def other_method(self, retcode=None):
         return self.cool_method('hammer time', retcode)
 
   Code calling cool_method('hello') would get a StepTestData:
     StepTestData(
-      placeholder_data = {
+      output_placeholder_data = {
         ('foo_module', 'cool_method'): [
           PlaceholderTestData('Test data (hello)')
         ]
       },
       retcode = None
     )
 
   Code calling other_method(50) would get a StepTestData:
     StepTestData(
-      placeholder_data = {
+      output_placeholder_data = {
         ('foo_module', 'other_method'): [
           PlaceholderTestData('Test data (hammer time)')
         ]
       },
       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:
       placeholder_data, retcode = data
       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
 
 
 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)
@@ skipping 42 matching lines @@
 
   The properties.tryserver() call is documented in the 'properties' module's
   test_api.
   The platform() call is documented in the 'platform' module's test_api.
   The json.output() call is documented in the 'json' module's test_api.
   """
   def __init__(self, module=None):
     """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
   def test(name):
     """Returns a new empty TestData with the name filled in.
 
     Use in GenTests:
       def GenTests(api):
         yield api.test('basic')
     """
@@ skipping 13 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 21 matching lines @@
     if data:
       ret.step_data[name] = reduce(lambda x,y: x + y, data)
     if 'retcode' in kwargs:
       ret.step_data[name].retcode = kwargs['retcode']
     if 'override' in kwargs:
       ret.step_data[name].override = kwargs['override']
     for key in ('stdout', 'stderr'):
       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):
     """See _step_data()"""
     return self._step_data(name, *data, **kwargs)
   step_data.__doc__ = _step_data.__doc__
 
   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