Add simple depends_on API.

recipe_engine/unittests/loader_test.py

 #!/usr/bin/env python
 # Copyright 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 os
 import sys
 import unittest
 
 sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(
@@ skipping 28 matching lines @@
     loader.invoke_with_properties = lambda *args, **kwargs: FakeReturn()
 
     self.assertEqual(mocked_return, script.run(None, None))
 
 def make_prop(**kwargs):
   name = kwargs.pop('name', "dumb_name")
   return recipe_api.Property(**kwargs).bind(name, 'test', 'properties_test')
 
 
 class TestInvoke(unittest.TestCase):
-  def invoke(self, callable, all_properties, prop_defs, **kwargs):
-    return loader.invoke_with_properties(
-        callable, all_properties, prop_defs, **kwargs)
+  def invoke(self, callable, all_properties, prop_defs, arg_names, **kwargs):
+    return loader._invoke_with_properties(
+        callable, all_properties, prop_defs, arg_names, **kwargs)
 
   def testInvokeFuncSimple(self):
     """Simple test of invoke."""
     def func():
       pass
 
-    self.assertEqual(self.invoke(func, {}, {}), None)
+    self.assertEqual(self.invoke(func, {}, {}, []), None)
 
   def testInvokeFuncComplex(self):
     """Tests invoke with two different properties."""
     def func(a, b): # pylint: disable=unused-argument
       return a
 
     prop_defs = {
       'a': make_prop(name="a"),
       'b': make_prop(name="b"),
     }
 
     props = {
       'a': 1,
       'b': 2,
     }
-    self.assertEqual(1, self.invoke(func, props, prop_defs))
+    self.assertEqual(1, self.invoke(func, props, prop_defs, ['a', 'b']))
 
   def testInvokeParamName(self):
     """Tests invoke with two different properties."""
     def func(a):
       return a
 
     prop_defs = {
       'a': make_prop(name='b'),
     }
 
     props = {
       'b': 2,
     }
-    self.assertEqual(2, self.invoke(func, props, prop_defs))
+    self.assertEqual(2, self.invoke(func, props, prop_defs, ['a']))
 
   def testInvokeClass(self):
     """Tests invoking a class."""
     class test(object):
       def __init__(self, a, b): # pylint: disable=unused-argument
         self.answer = a
 
     prop_defs = {
       'a': make_prop(name="a"),
       'b': make_prop(name="b"),
     }
 
     props = {
       'a': 1,
       'b': 2,
     }
-    self.assertEqual(1, self.invoke(test, props, prop_defs).answer)
+    self.assertEqual(1, self.invoke(test, props, prop_defs, ['a', 'b']).answer)
 
   def testMissingProperty(self):
     """Tests that invoke raises an error when missing a property."""
     def func(a):
       return a
 
     with self.assertRaises(recipe_api.UndefinedPropertyException):
-      self.invoke(func, {}, {})
+      self.invoke(func, {}, {}, ['a'])
 
   def testMustBeBound(self):
     """Tests that calling invoke with a non BoundProperty fails."""
     prop_defs = {
       "a": recipe_api.Property()
     }
 
     with self.assertRaises(ValueError):
-      self.invoke(None, None, prop_defs)
+      self.invoke(None, None, prop_defs, ['a'])
+
+  def testInvokeArgNamesFunc(self):
+    def test_function(a, b):
+      return a
+
+    self._old_inner_invoke = loader._invoke_with_properties
+    def mock_inner_invoke(_, __, ___, names):
+      return names
+    loader._invoke_with_properties = mock_inner_invoke

[luqui, 2015/11/20 01:07:02]

Doesn't mock provide a cleaner way of doing things like this?  I'm not that
familiar, I just have a feeling.  (mock is vendored in already)

[iannucci, 2015/11/20 02:00:19]

(yes it does)

[martiniss, 2015/11/23 22:05:07]

much wow.

Had to fix it, since we don't actually use it anywhere :P

+
+    try:
+      self.assertEqual(
+        ['a', 'b'],
+        loader.invoke_with_properties(test_function, None, None))
+    finally:
+      loader._invoke_with_properties = self._old_inner_invoke
+
+  def testInvokeArgNamesClass(self):
+    class TestClass(object):
+      def __init__(self, api, foo, bar):
+        pass
+
+    self._old_inner_invoke = loader._invoke_with_properties
+    def mock_inner_invoke(_, __, ___, names):
+      return names
+
+    loader._invoke_with_properties = mock_inner_invoke
+
+    try:
+      self.assertEqual(
+        ['api', 'foo', 'bar'],
+        loader.invoke_with_properties(TestClass, None, None))
+    finally:
+      loader._invoke_with_properties = self._old_inner_invoke
 
 if __name__ == '__main__':
   unittest.main()