Merge "Fix the notify method of the routing notifier" into stable/icehouse

2 files changed, 62 insertions, 22 deletions

diff --git a/oslo/messaging/notify/_impl_routing.py b/oslo/messaging/notify/_impl_routing.py
index 5b32cd0..21c9ba5 100644
--- a/oslo/messaging/notify/_impl_routing.py
+++ b/oslo/messaging/notify/_impl_routing.py
@@ -104,33 +104,31 @@ class RoutingDriver(notifier._Driver):
 
         return list(accepted_drivers)
 
-    def _filter_func(self, ext, context, message, accepted_drivers):
+    def _filter_func(self, ext, context, message, priority, accepted_drivers):
         """True/False if the driver should be called for this message.
         """
         # context is unused here, but passed in by map()
         return ext.name in accepted_drivers
 
-    def _call_notify(self, ext, context, message, accepted_drivers):
+    def _call_notify(self, ext, context, message, priority, accepted_drivers):
         """Emit the notification.
         """
         # accepted_drivers is passed in as a result of the map() function
         LOG.info(_("Routing '%(event)s' notification to '%(driver)s' driver") %
                  {'event': message.get('event_type'), 'driver': ext.name})
-        ext.obj.notify(context, message)
+        ext.obj.notify(context, message, priority)
 
-    def notify(self, context, message):
+    def notify(self, context, message, priority):
         if not self.plugin_manager:
             self._load_notifiers()
 
         # Fail if these aren't present ...
         event_type = message['event_type']
-        priority = message['priority'].lower()
 
         accepted_drivers = set()
         for group in self.routing_groups.values():
-            accepted_drivers.update(self._get_drivers_for_message(group,
-                                                                  event_type,
-                                                                  priority))
-
+            accepted_drivers.update(
+                self._get_drivers_for_message(group, event_type,
+                                              priority.lower()))
         self.plugin_manager.map(self._filter_func, self._call_notify, context,
-                                message, list(accepted_drivers))
+                                message, priority, list(accepted_drivers))
diff --git a/tests/test_notifier.py b/tests/test_notifier.py
index 40733c0..75edc78 100644
--- a/tests/test_notifier.py
+++ b/tests/test_notifier.py
@@ -13,6 +13,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import contextlib
 import datetime
 import logging
 import sys
@@ -20,6 +21,7 @@ import uuid
 
 import fixtures
 import mock
+from stevedore import dispatch
 from stevedore import extension
 import testscenarios
 import yaml
@@ -27,7 +29,6 @@ import yaml
 from oslo import messaging
 from oslo.messaging.notify import _impl_log
 from oslo.messaging.notify import _impl_messaging
-from oslo.messaging.notify import _impl_routing as routing
 from oslo.messaging.notify import _impl_test
 from oslo.messaging.notify import notifier as msg_notifier
 from oslo.messaging.openstack.common import jsonutils
@@ -304,7 +305,11 @@ class TestLogNotifier(test_utils.BaseTestCase):
 class TestRoutingNotifier(test_utils.BaseTestCase):
     def setUp(self):
         super(TestRoutingNotifier, self).setUp()
-        self.router = routing.RoutingDriver(None, None, None)
+        self.config(notification_driver=['routing'])
+
+        transport = _FakeTransport(self.conf)
+        self.notifier = messaging.Notifier(transport)
+        self.router = self.notifier._driver_mgr['routing'].obj
 
     def _fake_extension_manager(self, ext):
         return extension.ExtensionManager.make_test_instance(
@@ -380,22 +385,22 @@ group_1:
         # No matching event ...
         self.assertEqual([],
                          self.router._get_drivers_for_message(
-                             group, "unknown", None))
+                             group, "unknown", "info"))
 
         # Child of foo ...
         self.assertEqual(['rpc'],
                          self.router._get_drivers_for_message(
-                             group, "foo.1", None))
+                             group, "foo.1", "info"))
 
         # Foo itself ...
         self.assertEqual([],
                          self.router._get_drivers_for_message(
-                             group, "foo", None))
+                             group, "foo", "info"))
 
         # Child of blah.zoo
         self.assertEqual(['rpc'],
                          self.router._get_drivers_for_message(
-                             group, "blah.zoo.zing", None))
+                             group, "blah.zoo.zing", "info"))
 
     def test_get_drivers_for_message_accepted_priorities(self):
         config = r"""
@@ -461,21 +466,58 @@ group_1:
         ext.name = "rpc"
 
         # Good ...
-        self.assertTrue(self.router._filter_func(ext, {}, {},
+        self.assertTrue(self.router._filter_func(ext, {}, {}, 'info',
                         ['foo', 'rpc']))
 
         # Bad
-        self.assertFalse(self.router._filter_func(ext, {}, {}, ['foo']))
+        self.assertFalse(self.router._filter_func(ext, {}, {}, 'info',
+                                                  ['foo']))
 
     def test_notify(self):
         self.router.routing_groups = {'group_1': None, 'group_2': None}
-        message = {'event_type': 'my_event', 'priority': 'my_priority'}
-
         drivers_mock = mock.MagicMock()
         drivers_mock.side_effect = [['rpc'], ['foo']]
 
         with mock.patch.object(self.router, 'plugin_manager') as pm:
             with mock.patch.object(self.router, '_get_drivers_for_message',
                                    drivers_mock):
-                self.router.notify({}, message)
-                self.assertEqual(pm.map.call_args[0][4], ['rpc', 'foo'])
+                self.notifier.info({}, 'my_event', {})
+                self.assertEqual(pm.map.call_args[0][5], ['rpc', 'foo'])
+
+    def test_notify_filtered(self):
+        self.config(routing_notifier_config="routing_notifier.yaml")
+        routing_config = r"""
+group_1:
+    rpc:
+        accepted_events:
+          - my_event
+    rpc2:
+        accepted_priorities:
+          - info
+    bar:
+        accepted_events:
+            - nothing
+        """
+        config_file = mock.MagicMock()
+        config_file.return_value = routing_config
+
+        rpc_driver = mock.Mock()
+        rpc2_driver = mock.Mock()
+        bar_driver = mock.Mock()
+
+        pm = dispatch.DispatchExtensionManager.make_test_instance(
+            [extension.Extension('rpc', None, None, rpc_driver),
+             extension.Extension('rpc2', None, None, rpc2_driver),
+             extension.Extension('bar', None, None, bar_driver)],
+        )
+
+        with contextlib.nested(
+            mock.patch.object(self.router, '_get_notifier_config_file',
+                              config_file),
+            mock.patch('stevedore.dispatch.DispatchExtensionManager',
+                       return_value=pm)):
+                self.notifier.info({}, 'my_event', {})
+                self.assertFalse(bar_driver.info.called)
+                rpc_driver.notify.assert_called_once_with({}, mock.ANY, 'INFO')
+                rpc2_driver.notify.assert_called_once_with(
+                    {}, mock.ANY, 'INFO')