enabled extension manager test instance factory

3 files changed, 89 insertions, 8 deletions

diff --git a/stevedore/enabled.py b/stevedore/enabled.py
index 5cb0033..f277216 100644
--- a/stevedore/enabled.py
+++ b/stevedore/enabled.py
@@ -31,7 +31,7 @@ class EnabledExtensionManager(ExtensionManager):
     :param propagate_map_exceptions: Boolean controlling whether exceptions
         are propagated up through the map call or whether they are logged and
         then ignored
-    :type invoke_on_load: bool
+    :type propagate_map_exceptions: bool
 
     """
 
@@ -47,6 +47,40 @@ class EnabledExtensionManager(ExtensionManager):
             propagate_map_exceptions=propagate_map_exceptions,
         )
 
+    @classmethod
+    def make_test_instance(cls, available_extensions, check_func,
+                           propagate_map_exceptions=False):
+        """Construct a test EnabledExtensionManager
+
+        Test instances are passed a list of extensions to work from rather
+        than loading them from entry points, filtering the available
+        extensions to only those extensions that pass a check function.
+
+        :param available_extensions: Pre-configured Extension instances
+            available for use
+        :type available_extensions: list of
+            :class:`~stevedore.extension.Extension`
+        :param check_func: Function to determine which extensions to load.
+        :type check_func: callable
+        :param propagate_map_exceptions: Boolean controlling whether exceptions
+            are propagated up through the map call or whether they are logged
+            and then ignored
+        :type propagate_map_exceptions: bool
+        :return: The manager instance, initialized for testing
+
+        """
+
+        # simulate excluding plugins not passing check_func, which normally
+        # happens in _load_one_plugin
+        extensions = [extension for extension in available_extensions
+                      if check_func(extension)]
+
+        o = super(EnabledExtensionManager, cls).make_test_instance(
+            extensions, propagate_map_exceptions=propagate_map_exceptions)
+
+        o.check_func = check_func
+        return o
+
     def _load_one_plugin(self, ep, invoke_on_load, invoke_args, invoke_kwds):
         ext = super(EnabledExtensionManager, self)._load_one_plugin(
             ep, invoke_on_load, invoke_args, invoke_kwds,
diff --git a/stevedore/tests/test_enabled.py b/stevedore/tests/test_enabled.py
index 659e710..92cb7ce 100644
--- a/stevedore/tests/test_enabled.py
+++ b/stevedore/tests/test_enabled.py
@@ -1,4 +1,8 @@
+from mock import Mock
+
 from stevedore import enabled
+from stevedore.tests.test_test_manager import (test_extension, test_extension2,
+                                               excluded, unwanted)
 
 
 def test_enabled():
@@ -27,3 +31,37 @@ def test_enabled_after_load():
     )
     assert len(em.extensions) == 1
     assert em.names() == ['t2']
+
+
+def test_enabled_manager_should_check_all_extensions():
+    check_func = Mock()
+
+    enabled.EnabledExtensionManager.make_test_instance([excluded,
+                                                        test_extension,
+                                                        unwanted,
+                                                        test_extension2],
+                                                       check_func)
+
+    check_func.assert_any_call(test_extension)
+    check_func.assert_any_call(test_extension2)
+    check_func.assert_any_call(excluded)
+    check_func.assert_any_call(unwanted)
+
+
+def test_enabled_manager_should_include_only_passing_extensions():
+    def underscore_checker(extension):
+        return '_' in extension.name
+
+    em = enabled.EnabledExtensionManager.make_test_instance([excluded,
+                                                             test_extension,
+                                                             unwanted,
+                                                             test_extension2],
+                                                            underscore_checker)
+
+    extensions = list(em)
+
+    assert test_extension in extensions
+    assert test_extension2 in extensions
+
+    assert excluded not in extensions
+    assert unwanted not in extensions
diff --git a/stevedore/tests/test_test_manager.py b/stevedore/tests/test_test_manager.py
index 9b7830b..3046127 100644
--- a/stevedore/tests/test_test_manager.py
+++ b/stevedore/tests/test_test_manager.py
@@ -1,6 +1,8 @@
 from mock import Mock
-from stevedore import NamedExtensionManager, HookManager
-from stevedore.extension import Extension, ExtensionManager
+from nose.tools import raises
+from stevedore import (ExtensionManager, NamedExtensionManager, HookManager,
+                       EnabledExtensionManager, DriverManager)
+from stevedore.extension import Extension
 
 
 test_extension = Extension('test_extension', None, None, None)
@@ -47,6 +49,16 @@ def test_manager_should_call_all():
     func.assert_any_call(test_extension)
 
 
+def test_manager_return_values():
+    def mapped(ext, *args, **kwds):
+        return ext.name
+
+    em = ExtensionManager.make_test_instance([test_extension2,
+                                              test_extension])
+    results = em.map(mapped)
+    assert sorted(results) == ['another_one', 'test_extension']
+
+
 def test_manager_should_eat_exceptions():
     em = ExtensionManager.make_test_instance([test_extension])
 
@@ -56,16 +68,13 @@ def test_manager_should_eat_exceptions():
     assert results == []
 
 
+@raises(RuntimeError)
 def test_manager_should_propagate_exceptions():
     em = ExtensionManager.make_test_instance([test_extension],
                                              propagate_map_exceptions=True)
     func = Mock(side_effect=RuntimeError('hard coded error'))
 
-    try:
-        em.map(func, 1, 2, a='A', b='B')
-        assert False, 'DID NOT RAISE!'
-    except RuntimeError:
-        pass
+    em.map(func, 1, 2, a='A', b='B')
 
 
 def test_named_manager_should_include_named_extensions():