Added tests for debug logging middleware

cloudbridge/cloud/base/middleware.py

@@ -141,14 +141,14 @@ class EventDebugLoggingMiddleware(BaseMiddleware):
     than for debugging, as it could log sensitive parameters such as
     access keys.
     """
-    @observe(event_pattern="*", priority=1100)
+    @observe(event_pattern="*", priority=100)
     def pre_log_event(self, event_args, *args, **kwargs):
-        log.debug("Event: {0} invoked with args: {1}, kwargs: {2}".format(
+        log.debug("Event: {0}, args: {1} kwargs: {2}".format(
             event_args.get("event"), args, kwargs))
 
-    @observe(event_pattern="*", priority=1150)
+    @observe(event_pattern="*", priority=4900)
     def post_log_event(self, event_args, *args, **kwargs):
-        log.debug("Event: {0} result: {1}".format(
+        log.debug("Event: {0}, result: {1}".format(
             event_args.get("event"), event_args.get("result")))
 
 

test/helpers/__init__.py

@@ -1,4 +1,5 @@
 import functools
+import operator
 import os
 import sys
 import traceback
@@ -81,6 +82,39 @@ def skipIfNoService(services):
     return wrap
 
 
+def skipIfPython(op, major, minor):
+    """
+    A decorator for skipping tests if the python
+    version doesn't match
+    """
+    def stringToOperator(op):
+        op_map = {
+            "=": operator.eq,
+            "==": operator.eq,
+            "<": operator.lt,
+            "<=": operator.le,
+            ">": operator.gt,
+            ">=": operator.ge,
+        }
+        return op_map.get(op)
+
+    def wrap(func):
+        """
+        The actual wrapper
+        """
+        @functools.wraps(func)
+        def wrapper(self, *args, **kwargs):
+            op_func = stringToOperator(op)
+            if op_func(sys.version_info, (major, minor)):
+                self.skipTest(
+                    "Skipping test because python version {0} is {1} expected"
+                    " version {2}".format(sys.version_info[:2],
+                                          op, (major, minor)))
+            func(self, *args, **kwargs)
+        return wrapper
+    return wrap
+
+
 TEST_DATA_CONFIG = {
     "AWSCloudProvider": {
         # Match the ami value with entry in custom_amis.json for use with moto

test/test_middleware_system.py

@@ -2,6 +2,7 @@ import unittest
 
 from cloudbridge.cloud.base.events import SimpleEventDispatcher
 from cloudbridge.cloud.base.middleware import BaseMiddleware
+from cloudbridge.cloud.base.middleware import EventDebugLoggingMiddleware
 from cloudbridge.cloud.base.middleware import ExceptionWrappingMiddleware
 from cloudbridge.cloud.base.middleware import SimpleMiddlewareManager
 from cloudbridge.cloud.base.middleware import implement
@@ -12,6 +13,8 @@ from cloudbridge.cloud.interfaces.exceptions import \
     InvalidConfigurationException
 from cloudbridge.cloud.interfaces.middleware import Middleware
 
+from .helpers import skipIfPython
+
 
 class MiddlewareSystemTestCase(unittest.TestCase):
 
@@ -248,3 +251,36 @@ class ExceptionWrappingMiddlewareTestCase(unittest.TestCase):
 
         with self.assertRaises(InvalidConfigurationException):
             dispatcher.dispatch(self, EVENT_NAME)
+
+
+class EventDebugLoggingMiddlewareTestCase(unittest.TestCase):
+
+    # Only python 3 has assertLogs support
+    @skipIfPython("<", 3, 0)
+    def test_messages_logged(self):
+        EVENT_NAME = "an.exceptional.event"
+
+        class SomeDummyClass(object):
+
+            @implement(event_pattern=EVENT_NAME, priority=2500)
+            def return_some_value(self, *args, **kwargs):
+                return "hello world"
+
+        dispatcher = SimpleEventDispatcher()
+        manager = SimpleMiddlewareManager(dispatcher)
+        middleware = EventDebugLoggingMiddleware()
+        manager.add(middleware)
+        some_obj = SomeDummyClass()
+        manager.add(some_obj)
+
+        with self.assertLogs('cloudbridge.cloud.base.middleware',
+                             level='DEBUG') as cm:
+            dispatcher.dispatch(self, EVENT_NAME,
+                                "named_param", keyword_param="hello")
+        self.assertTrue(
+            "named_param" in cm.output[0]
+            and "keyword_param" in cm.output[0] and "hello" in cm.output[0],
+            "Log output {0} not as expected".format(cm.output[0]))
+        self.assertTrue(
+            "hello world" in cm.output[1],
+            "Log output {0} does not contain result".format(cm.output[1]))