split 'events' portion of reporting into separate file

this just separates events from other things that could conceivably
be reported.

1 files changed, 61 insertions, 60 deletions

diff --git a/tests/unittests/test_reporting.py b/tests/unittests/test_reporting.py
index 66d4e87e..bb67ef73 100644
--- a/tests/unittests/test_reporting.py
+++ b/tests/unittests/test_reporting.py
@@ -5,6 +5,7 @@
 
 from cloudinit import reporting
 from cloudinit.reporting import handlers
+from cloudinit.reporting import events
 
 from .helpers import (mock, TestCase)
 
@@ -16,12 +17,12 @@ def _fake_registry():
 
 class TestReportStartEvent(TestCase):
 
-    @mock.patch('cloudinit.reporting.instantiated_handler_registry',
+    @mock.patch('cloudinit.reporting.events.instantiated_handler_registry',
                 new_callable=_fake_registry)
     def test_report_start_event_passes_something_with_as_string_to_handlers(
             self, instantiated_handler_registry):
         event_name, event_description = 'my_test_event', 'my description'
-        reporting.report_start_event(event_name, event_description)
+        events.report_start_event(event_name, event_description)
         expected_string_representation = ': '.join(
             ['start', event_name, event_description])
         for _, handler in (
@@ -33,9 +34,9 @@ class TestReportStartEvent(TestCase):
 
 class TestReportFinishEvent(TestCase):
 
-    def _report_finish_event(self, result=reporting.status.SUCCESS):
+    def _report_finish_event(self, result=events.status.SUCCESS):
         event_name, event_description = 'my_test_event', 'my description'
-        reporting.report_finish_event(
+        events.report_finish_event(
             event_name, event_description, result=result)
         return event_name, event_description
 
@@ -46,39 +47,39 @@ class TestReportFinishEvent(TestCase):
             event = handler.publish_event.call_args[0][0]
             self.assertEqual(expected_as_string, event.as_string())
 
-    @mock.patch('cloudinit.reporting.instantiated_handler_registry',
+    @mock.patch('cloudinit.reporting.events.instantiated_handler_registry',
                 new_callable=_fake_registry)
     def test_report_finish_event_passes_something_with_as_string_to_handlers(
             self, instantiated_handler_registry):
         event_name, event_description = self._report_finish_event()
         expected_string_representation = ': '.join(
-            ['finish', event_name, reporting.status.SUCCESS,
+            ['finish', event_name, events.status.SUCCESS,
              event_description])
         self.assertHandlersPassedObjectWithAsString(
             instantiated_handler_registry.registered_items,
             expected_string_representation)
 
-    @mock.patch('cloudinit.reporting.instantiated_handler_registry',
+    @mock.patch('cloudinit.reporting.events.instantiated_handler_registry',
                 new_callable=_fake_registry)
     def test_reporting_successful_finish_has_sensible_string_repr(
             self, instantiated_handler_registry):
         event_name, event_description = self._report_finish_event(
-            result=reporting.status.SUCCESS)
+            result=events.status.SUCCESS)
         expected_string_representation = ': '.join(
-            ['finish', event_name, reporting.status.SUCCESS,
+            ['finish', event_name, events.status.SUCCESS,
              event_description])
         self.assertHandlersPassedObjectWithAsString(
             instantiated_handler_registry.registered_items,
             expected_string_representation)
 
-    @mock.patch('cloudinit.reporting.instantiated_handler_registry',
+    @mock.patch('cloudinit.reporting.events.instantiated_handler_registry',
                 new_callable=_fake_registry)
     def test_reporting_unsuccessful_finish_has_sensible_string_repr(
             self, instantiated_handler_registry):
         event_name, event_description = self._report_finish_event(
-            result=reporting.status.FAIL)
+            result=events.status.FAIL)
         expected_string_representation = ': '.join(
-            ['finish', event_name, reporting.status.FAIL, event_description])
+            ['finish', event_name, events.status.FAIL, event_description])
         self.assertHandlersPassedObjectWithAsString(
             instantiated_handler_registry.registered_items,
             expected_string_representation)
@@ -91,14 +92,14 @@ class TestReportingEvent(TestCase):
 
     def test_as_string(self):
         event_type, name, description = 'test_type', 'test_name', 'test_desc'
-        event = reporting.ReportingEvent(event_type, name, description)
+        event = events.ReportingEvent(event_type, name, description)
         expected_string_representation = ': '.join(
             [event_type, name, description])
         self.assertEqual(expected_string_representation, event.as_string())
 
     def test_as_dict(self):
         event_type, name, desc = 'test_type', 'test_name', 'test_desc'
-        event = reporting.ReportingEvent(event_type, name, desc)
+        event = events.ReportingEvent(event_type, name, desc)
         self.assertEqual(
             {'event_type': event_type, 'name': name, 'description': desc},
             event.as_dict())
@@ -106,9 +107,9 @@ class TestReportingEvent(TestCase):
 
 class TestFinishReportingEvent(TestCase):
     def test_as_has_result(self):
-        result = reporting.status.SUCCESS
+        result = events.status.SUCCESS
         name, desc = 'test_name', 'test_desc'
-        event = reporting.FinishReportingEvent(name, desc, result)
+        event = events.FinishReportingEvent(name, desc, result)
         ret = event.as_dict()
         self.assertTrue('result' in ret)
         self.assertEqual(ret['result'], result)
@@ -126,7 +127,7 @@ class TestLogHandler(TestCase):
     @mock.patch.object(reporting.handlers.logging, 'getLogger')
     def test_appropriate_logger_used(self, getLogger):
         event_type, event_name = 'test_type', 'test_name'
-        event = reporting.ReportingEvent(event_type, event_name, 'description')
+        event = events.ReportingEvent(event_type, event_name, 'description')
         reporting.handlers.LogHandler().publish_event(event)
         self.assertEqual(
             [mock.call(
@@ -135,13 +136,13 @@ class TestLogHandler(TestCase):
 
     @mock.patch.object(reporting.handlers.logging, 'getLogger')
     def test_single_log_message_at_info_published(self, getLogger):
-        event = reporting.ReportingEvent('type', 'name', 'description')
+        event = events.ReportingEvent('type', 'name', 'description')
         reporting.handlers.LogHandler().publish_event(event)
         self.assertEqual(1, getLogger.return_value.log.call_count)
 
     @mock.patch.object(reporting.handlers.logging, 'getLogger')
     def test_log_message_uses_event_as_string(self, getLogger):
-        event = reporting.ReportingEvent('type', 'name', 'description')
+        event = events.ReportingEvent('type', 'name', 'description')
         reporting.handlers.LogHandler(level="INFO").publish_event(event)
         self.assertIn(event.as_string(),
                       getLogger.return_value.log.call_args[0][1])
@@ -232,49 +233,49 @@ class TestReportingConfiguration(TestCase):
 
 
 class TestReportingEventStack(TestCase):
-    @mock.patch('cloudinit.reporting.report_finish_event')
-    @mock.patch('cloudinit.reporting.report_start_event')
+    @mock.patch('cloudinit.reporting.events.report_finish_event')
+    @mock.patch('cloudinit.reporting.events.report_start_event')
     def test_start_and_finish_success(self, report_start, report_finish):
-        with reporting.ReportEventStack(name="myname", description="mydesc"):
+        with events.ReportEventStack(name="myname", description="mydesc"):
             pass
         self.assertEqual(
             [mock.call('myname', 'mydesc')], report_start.call_args_list)
         self.assertEqual(
-            [mock.call('myname', 'mydesc', reporting.status.SUCCESS)],
+            [mock.call('myname', 'mydesc', events.status.SUCCESS)],
             report_finish.call_args_list)
 
-    @mock.patch('cloudinit.reporting.report_finish_event')
-    @mock.patch('cloudinit.reporting.report_start_event')
+    @mock.patch('cloudinit.reporting.events.report_finish_event')
+    @mock.patch('cloudinit.reporting.events.report_start_event')
     def test_finish_exception_defaults_fail(self, report_start, report_finish):
         name = "myname"
         desc = "mydesc"
         try:
-            with reporting.ReportEventStack(name, description=desc):
+            with events.ReportEventStack(name, description=desc):
                 raise ValueError("This didnt work")
         except ValueError:
             pass
         self.assertEqual([mock.call(name, desc)], report_start.call_args_list)
         self.assertEqual(
-            [mock.call(name, desc, reporting.status.FAIL)],
+            [mock.call(name, desc, events.status.FAIL)],
             report_finish.call_args_list)
 
-    @mock.patch('cloudinit.reporting.report_finish_event')
-    @mock.patch('cloudinit.reporting.report_start_event')
+    @mock.patch('cloudinit.reporting.events.report_finish_event')
+    @mock.patch('cloudinit.reporting.events.report_start_event')
     def test_result_on_exception_used(self, report_start, report_finish):
         name = "myname"
         desc = "mydesc"
         try:
-            with reporting.ReportEventStack(
-                    name, desc, result_on_exception=reporting.status.WARN):
+            with events.ReportEventStack(
+                    name, desc, result_on_exception=events.status.WARN):
                 raise ValueError("This didnt work")
         except ValueError:
             pass
         self.assertEqual([mock.call(name, desc)], report_start.call_args_list)
         self.assertEqual(
-            [mock.call(name, desc, reporting.status.WARN)],
+            [mock.call(name, desc, events.status.WARN)],
             report_finish.call_args_list)
 
-    @mock.patch('cloudinit.reporting.report_start_event')
+    @mock.patch('cloudinit.reporting.events.report_start_event')
     def test_child_fullname_respects_parent(self, report_start):
         parent_name = "topname"
         c1_name = "c1name"
@@ -282,59 +283,59 @@ class TestReportingEventStack(TestCase):
         c2_expected_fullname = '/'.join([parent_name, c1_name, c2_name])
         c1_expected_fullname = '/'.join([parent_name, c1_name])
 
-        parent = reporting.ReportEventStack(parent_name, "topdesc")
-        c1 = reporting.ReportEventStack(c1_name, "c1desc", parent=parent)
-        c2 = reporting.ReportEventStack(c2_name, "c2desc", parent=c1)
+        parent = events.ReportEventStack(parent_name, "topdesc")
+        c1 = events.ReportEventStack(c1_name, "c1desc", parent=parent)
+        c2 = events.ReportEventStack(c2_name, "c2desc", parent=c1)
         with c1:
             report_start.assert_called_with(c1_expected_fullname, "c1desc")
             with c2:
                 report_start.assert_called_with(c2_expected_fullname, "c2desc")
 
-    @mock.patch('cloudinit.reporting.report_finish_event')
-    @mock.patch('cloudinit.reporting.report_start_event')
+    @mock.patch('cloudinit.reporting.events.report_finish_event')
+    @mock.patch('cloudinit.reporting.events.report_start_event')
     def test_child_result_bubbles_up(self, report_start, report_finish):
-        parent = reporting.ReportEventStack("topname", "topdesc")
-        child = reporting.ReportEventStack("c_name", "c_desc", parent=parent)
+        parent = events.ReportEventStack("topname", "topdesc")
+        child = events.ReportEventStack("c_name", "c_desc", parent=parent)
         with parent:
             with child:
-                child.result = reporting.status.WARN
+                child.result = events.status.WARN
 
         report_finish.assert_called_with(
-            "topname", "topdesc", reporting.status.WARN)
+            "topname", "topdesc", events.status.WARN)
 
-    @mock.patch('cloudinit.reporting.report_finish_event')
+    @mock.patch('cloudinit.reporting.events.report_finish_event')
     def test_message_used_in_finish(self, report_finish):
-        with reporting.ReportEventStack("myname", "mydesc",
-                                        message="mymessage"):
+        with events.ReportEventStack("myname", "mydesc",
+                                     message="mymessage"):
             pass
         self.assertEqual(
-            [mock.call("myname", "mymessage", reporting.status.SUCCESS)],
+            [mock.call("myname", "mymessage", events.status.SUCCESS)],
             report_finish.call_args_list)
 
-    @mock.patch('cloudinit.reporting.report_finish_event')
+    @mock.patch('cloudinit.reporting.events.report_finish_event')
     def test_message_updatable(self, report_finish):
-        with reporting.ReportEventStack("myname", "mydesc") as c:
+        with events.ReportEventStack("myname", "mydesc") as c:
             c.message = "all good"
         self.assertEqual(
-            [mock.call("myname", "all good", reporting.status.SUCCESS)],
+            [mock.call("myname", "all good", events.status.SUCCESS)],
             report_finish.call_args_list)
 
-    @mock.patch('cloudinit.reporting.report_start_event')
-    @mock.patch('cloudinit.reporting.report_finish_event')
+    @mock.patch('cloudinit.reporting.events.report_start_event')
+    @mock.patch('cloudinit.reporting.events.report_finish_event')
     def test_reporting_disabled_does_not_report_events(
             self, report_start, report_finish):
-        with reporting.ReportEventStack("a", "b", reporting_enabled=False):
+        with events.ReportEventStack("a", "b", reporting_enabled=False):
             pass
         self.assertEqual(report_start.call_count, 0)
         self.assertEqual(report_finish.call_count, 0)
 
-    @mock.patch('cloudinit.reporting.report_start_event')
-    @mock.patch('cloudinit.reporting.report_finish_event')
+    @mock.patch('cloudinit.reporting.events.report_start_event')
+    @mock.patch('cloudinit.reporting.events.report_finish_event')
     def test_reporting_child_default_to_parent(
             self, report_start, report_finish):
-        parent = reporting.ReportEventStack(
+        parent = events.ReportEventStack(
             "pname", "pdesc", reporting_enabled=False)
-        child = reporting.ReportEventStack("cname", "cdesc", parent=parent)
+        child = events.ReportEventStack("cname", "cdesc", parent=parent)
         with parent:
             with child:
                 pass
@@ -343,17 +344,17 @@ class TestReportingEventStack(TestCase):
         self.assertEqual(report_finish.call_count, 0)
 
     def test_reporting_event_has_sane_repr(self):
-        myrep = reporting.ReportEventStack("fooname", "foodesc",
-                                           reporting_enabled=True).__repr__()
+        myrep = events.ReportEventStack("fooname", "foodesc",
+                                        reporting_enabled=True).__repr__()
         self.assertIn("fooname", myrep)
         self.assertIn("foodesc", myrep)
         self.assertIn("True", myrep)
 
     def test_set_invalid_result_raises_value_error(self):
-        f = reporting.ReportEventStack("myname", "mydesc")
+        f = events.ReportEventStack("myname", "mydesc")
         self.assertRaises(ValueError, setattr, f, "result", "BOGUS")
 
 
 class TestStatusAccess(TestCase):
     def test_invalid_status_access_raises_value_error(self):
-        self.assertRaises(AttributeError, getattr, reporting.status, "BOGUS")
+        self.assertRaises(AttributeError, getattr, events.status, "BOGUS")