Added tests for implementing handlers

test/test_event_system.py

@@ -66,6 +66,29 @@ class EventSystemTestCase(unittest.TestCase):
         self.assertEqual(result, "world", "Result should be `world` as this"
                          " is an intercepting handler")
 
+    def test_emit_event_implementing_handler(self):
+        EVENT_NAME = "event.hello.world"
+        callback_tracker = ['']
+
+        def my_callback(*args, **kwargs):
+            self.assertSequenceEqual(args, ['first_pos_arg'])
+            self.assertDictEqual(kwargs, {'a_keyword_arg': 'another_thing'})
+            callback_tracker[0] += "impl"
+            return "world"
+
+        dispatcher = SimpleEventDispatcher()
+        handler = dispatcher.implement(event_pattern=EVENT_NAME, priority=1000,
+                                       callback=my_callback)
+        self.assertIsInstance(handler, EventHandler)
+        result = dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
+                                     a_keyword_arg='another_thing')
+        self.assertEqual(
+            callback_tracker[0], "impl", "callback should have been invoked"
+            "once and contain value `intcpt` but tracker value is {0}".format(
+                callback_tracker[0]))
+        self.assertEqual(result, "world", "Result should be `world` as this"
+                         " is an implementing handler")
+
     def test_emit_event_observe_precedes_intercept(self):
         EVENT_NAME = "event.hello.world"
         callback_tracker = ['']
@@ -178,6 +201,72 @@ class EventSystemTestCase(unittest.TestCase):
         self.assertEqual(result, "helloworld", "Result should be `helloworld` "
                          "as this is the expected return value from the chain")
 
+    def test_emit_event_implement_follows_intercept(self):
+        EVENT_NAME = "event.hello.world"
+        callback_tracker = ['']
+
+        def my_callback_intcpt(event_args, *args, **kwargs):
+            self.assertEqual(event_args.get('sender'), self)
+            next_handler = event_args.get('next_handler')
+            self.assertEqual(next_handler.priority, 2020)
+            self.assertEqual(next_handler.callback.__name__,
+                             "my_callback_impl")
+            callback_tracker[0] += "intcpt_"
+            # invoke next handler but ignore return value
+            return "hello" + next_handler.invoke(event_args, *args, **kwargs)
+
+        def my_callback_impl(*args, **kwargs):
+            self.assertSequenceEqual(args, ['first_pos_arg'])
+            self.assertDictEqual(kwargs, {'a_keyword_arg': 'another_thing'})
+            callback_tracker[0] += "impl_"
+            return "world"
+
+        dispatcher = SimpleEventDispatcher()
+        dispatcher.intercept(EVENT_NAME, 2000, my_callback_intcpt)
+        dispatcher.implement(EVENT_NAME, 2020, my_callback_impl)
+        result = dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
+                                     a_keyword_arg='another_thing')
+        self.assertEqual(
+            callback_tracker[0], "intcpt_impl_", "callback was not invoked"
+            " in expected order. Should have been intcpt_impl_ but is"
+            " {0}".format(callback_tracker[0]))
+        self.assertEqual(result, "helloworld", "Result should be `helloworld` "
+                         "as this is the expected return value from the chain")
+
+    def test_emit_event_implement_precedes_intercept(self):
+        EVENT_NAME = "event.hello.world"
+        callback_tracker = ['']
+
+        def my_callback_intcpt(event_args, *args, **kwargs):
+            # Impl result should be accessible to intercepts that follow
+            self.assertDictEqual(event_args,
+                                 {'sender': self,
+                                  'event': EVENT_NAME,
+                                  'result': 'world',
+                                  'next_handler': None})
+            self.assertSequenceEqual(args, ['first_pos_arg'])
+            self.assertDictEqual(kwargs, {'a_keyword_arg': 'another_thing'})
+            callback_tracker[0] += "intcpt_"
+            return "hello"
+
+        def my_callback_impl(*args, **kwargs):
+            self.assertSequenceEqual(args, ['first_pos_arg'])
+            self.assertDictEqual(kwargs, {'a_keyword_arg': 'another_thing'})
+            callback_tracker[0] += "impl_"
+            return "world"
+
+        dispatcher = SimpleEventDispatcher()
+        dispatcher.implement(EVENT_NAME, 2000, my_callback_impl)
+        dispatcher.intercept(EVENT_NAME, 2020, my_callback_intcpt)
+        result = dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
+                                     a_keyword_arg='another_thing')
+        self.assertEqual(
+            callback_tracker[0], "impl_intcpt_", "callback was not invoked"
+            " in expected order. Should have been intcpt_intcpt_ but is"
+            " {0}".format(callback_tracker[0]))
+        self.assertEqual(result, "world", "Result should be `world` "
+                         "as this is the expected return value from the chain")
+
     def test_subscribe_event_duplicate_priority(self):
 
         def my_callback(event_args, *args, **kwargs):

test/test_middleware_system.py

@@ -3,6 +3,7 @@ import unittest
 from cloudbridge.cloud.base.events import SimpleEventDispatcher
 from cloudbridge.cloud.base.middleware import BaseMiddleware
 from cloudbridge.cloud.base.middleware import SimpleMiddlewareManager
+from cloudbridge.cloud.base.middleware import implement
 from cloudbridge.cloud.base.middleware import intercept
 from cloudbridge.cloud.base.middleware import observe
 from cloudbridge.cloud.interfaces.middleware import Middleware
@@ -44,20 +45,28 @@ class MiddlewareSystemTestCase(unittest.TestCase):
             def __init__(self):
                 self.invocation_order = ""
 
-            @observe(event_pattern="some.event.*", priority=1000)
-            def my_callback_obs(self, *args, **kwargs):
-                self.invocation_order += "observe"
-                assert 'first_pos_arg' in args
-                assert kwargs.get('a_keyword_arg') == "something"
-
             @intercept(event_pattern="some.event.*", priority=900)
             def my_callback_intcpt(self, event_args, *args, **kwargs):
-                self.invocation_order += "intercept_"
+                self.invocation_order += "intcpt_"
                 assert 'first_pos_arg' in args
                 assert kwargs.get('a_keyword_arg') == "something"
                 next_handler = event_args.get('next_handler')
                 return next_handler.invoke(event_args, *args, **kwargs)
 
+            @implement(event_pattern="some.event.*", priority=950)
+            def my_callback_impl(self, *args, **kwargs):
+                self.invocation_order += "impl_"
+                assert 'first_pos_arg' in args
+                assert kwargs.get('a_keyword_arg') == "something"
+                return "hello"
+
+            @observe(event_pattern="some.event.*", priority=1000)
+            def my_callback_obs(self, event_args, *args, **kwargs):
+                self.invocation_order += "obs"
+                assert 'first_pos_arg' in args
+                assert event_args['result'] == "hello"
+                assert kwargs.get('a_keyword_arg') == "something"
+
         dispatcher = SimpleEventDispatcher()
         manager = SimpleMiddlewareManager(dispatcher)
         middleware = DummyMiddleWare()
@@ -65,9 +74,10 @@ class MiddlewareSystemTestCase(unittest.TestCase):
         dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
                             a_keyword_arg='something')
 
-        self.assertEqual(middleware.invocation_order, "intercept_observe")
+        self.assertEqual(middleware.invocation_order, "intcpt_impl_obs")
         self.assertListEqual(
-            [middleware.my_callback_intcpt, middleware.my_callback_obs],
+            [middleware.my_callback_intcpt, middleware.my_callback_impl,
+             middleware.my_callback_obs],
             [handler.callback for handler
              in dispatcher.get_handlers_for_event(EVENT_NAME)])
 
@@ -81,25 +91,33 @@ class MiddlewareSystemTestCase(unittest.TestCase):
         class DummyMiddleWare1(BaseMiddleware):
 
             @observe(event_pattern="some.really.*", priority=1000)
-            def my_callback_obs1(self, *args, **kwargs):
+            def my_obs1_3(self, *args, **kwargs):
                 pass
 
+            @implement(event_pattern="some.*", priority=970)
+            def my_impl1_2(self, *args, **kwargs):
+                return "hello"
+
             @intercept(event_pattern="some.*", priority=900)
-            def my_callback_intcpt2(self, event_args, *args, **kwargs):
+            def my_intcpt1_1(self, event_args, *args, **kwargs):
                 next_handler = event_args.get('next_handler')
                 return next_handler.invoke(event_args, *args, **kwargs)
 
         class DummyMiddleWare2(BaseMiddleware):
 
             @observe(event_pattern="some.really.*", priority=1050)
-            def my_callback_obs3(self, *args, **kwargs):
+            def my_obs2_3(self, *args, **kwargs):
                 pass
 
             @intercept(event_pattern="*", priority=950)
-            def my_callback_intcpt4(self, event_args, *args, **kwargs):
+            def my_intcpt2_2(self, event_args, *args, **kwargs):
                 next_handler = event_args.get('next_handler')
                 return next_handler.invoke(event_args, *args, **kwargs)
 
+            @implement(event_pattern="some.really.*", priority=920)
+            def my_impl2_1(self, *args, **kwargs):
+                pass
+
         dispatcher = SimpleEventDispatcher()
         manager = SimpleMiddlewareManager(dispatcher)
         middleware1 = DummyMiddleWare1()
@@ -110,8 +128,9 @@ class MiddlewareSystemTestCase(unittest.TestCase):
 
         # Callbacks in both middleware classes should be registered
         self.assertListEqual(
-            [middleware1.my_callback_intcpt2, middleware2.my_callback_intcpt4,
-             middleware1.my_callback_obs1, middleware2.my_callback_obs3],
+            [middleware1.my_intcpt1_1, middleware2.my_impl2_1,
+             middleware2.my_intcpt2_2, middleware1.my_impl1_2,
+             middleware1.my_obs1_3, middleware2.my_obs2_3],
             [handler.callback for handler
              in dispatcher.get_handlers_for_event(EVENT_NAME)])
 
@@ -119,7 +138,8 @@ class MiddlewareSystemTestCase(unittest.TestCase):
 
         # Only middleware2 callbacks should be registered
         self.assertListEqual(
-            [middleware2.my_callback_intcpt4, middleware2.my_callback_obs3],
+            [middleware2.my_impl2_1, middleware2.my_intcpt2_2,
+             middleware2.my_obs2_3],
             [handler.callback for handler in
              dispatcher.get_handlers_for_event(EVENT_NAME)])
 
@@ -128,8 +148,9 @@ class MiddlewareSystemTestCase(unittest.TestCase):
 
         # should one again equal original list
         self.assertListEqual(
-            [middleware1.my_callback_intcpt2, middleware2.my_callback_intcpt4,
-             middleware1.my_callback_obs1, middleware2.my_callback_obs3],
+            [middleware1.my_intcpt1_1, middleware2.my_impl2_1,
+             middleware2.my_intcpt2_2, middleware1.my_impl1_2,
+             middleware1.my_obs1_3, middleware2.my_obs2_3],
             [handler.callback for handler
              in dispatcher.get_handlers_for_event(EVENT_NAME)])
 
@@ -153,6 +174,10 @@ class MiddlewareSystemTestCase(unittest.TestCase):
             def my_callback_obs1(self, *args, **kwargs):
                 pass
 
+            @implement(event_pattern="another.interesting.*", priority=1050)
+            def my_callback_impl(self, *args, **kwargs):
+                pass
+
         dispatcher = SimpleEventDispatcher()
         manager = SimpleMiddlewareManager(dispatcher)
         some_obj = SomeDummyClass()
@@ -162,7 +187,8 @@ class MiddlewareSystemTestCase(unittest.TestCase):
         # Middleware should be discovered even if class containing interceptors
         # doesn't inherit from Middleware
         self.assertListEqual(
-            [some_obj.my_callback_intcpt2, some_obj.my_callback_obs1],
+            [some_obj.my_callback_intcpt2, some_obj.my_callback_obs1,
+             some_obj.my_callback_impl],
             [handler.callback for handler
              in dispatcher.get_handlers_for_event(EVENT_NAME)])