Add testcases of instancemonitor

This patch added missing testcases for instancemonitor directory.
And also improved existing testcases for them.

Change-Id: I5cf815a418d885a52e7f8dcb14607e49e2a9f5bc

masakarimonitors/tests/unit/instancemonitor/fakes.py

@@ -1,39 +0,0 @@
-# Copyright(c) 2016 Nippon Telegraph and Telephone Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-class FakeLibvirtOpenReadOnly(object):
-    def domainEventRegisterAny(self, dom, eventID, cb, opaque):
-        return 1
-
-    def setKeepAlive(self, interval, count):
-        return None
-
-    def isAlive(self):
-        return 0
-
-    def domainEventDeregisterAny(self, cid):
-        return None
-
-    def close(self):
-        raise EnvironmentError("Test Exception.")
-
-
-class FakeConnection(object):
-    def __init__(self):
-        class Ha(object):
-            def create_notification(self, type, hostname, generated_time,
-                                    payload):
-                return {}
-        self.ha = Ha()

masakarimonitors/tests/unit/instancemonitor/libvirt_handler/test_callback.py

@@ -13,15 +13,16 @@
 # limitations under the License.
 
 import mock
+import socket
 import testtools
+import uuid
 
 import eventlet
-from openstack import connection
-from openstack import profile
 from oslo_utils import timeutils
 
+from masakarimonitors.ha import masakari
 from masakarimonitors.instancemonitor.libvirt_handler import callback
-from masakarimonitors.tests.unit.instancemonitor import fakes
+from masakarimonitors.objects import event_constants as ec
 
 eventlet.monkey_patch(os=False)
 
@@ -31,38 +32,36 @@ class TestCallback(testtools.TestCase):
     def setUp(self):
         super(TestCallback, self).setUp()
 
-    @mock.patch.object(connection, 'Connection')
+    @mock.patch.object(masakari.SendNotification, 'send_notification')
-    @mock.patch.object(profile.Profile, 'set_interface')
+    def test_libvirt_event_callback(self, mock_send_notification):
-    @mock.patch.object(profile.Profile, 'set_version')
+
-    @mock.patch.object(profile.Profile, 'set_region')
+        mock_send_notification.return_value = None
-    @mock.patch.object(profile.Profile, 'set_name')
-    @mock.patch.object(profile.Profile, '_add_service')
-    def test_vir_event_filter(self,
-                              mock_add_service,
-                              mock_set_name,
-                              mock_set_region,
-                              mock_set_version,
-                              mock_set_interface,
-                              mock_Connection):
 
         obj = callback.Callback()
 
-        mock_add_service.return_value = None
+        event_id = 0
-        mock_set_name.return_value = None
+        details = 5
-        mock_set_region.return_value = None
+        domain_uuid = uuid.uuid4()
-        mock_set_version.return_value = None
+        notice_type = ec.EventConstants.TYPE_VM
-        mock_set_interface.return_value = None
+        hostname = socket.gethostname()
-        mock_Connection.return_value = fakes.FakeConnection()
+        current_time = timeutils.utcnow()
 
-        eventID_val = 0
+        obj.libvirt_event_callback(event_id, details, domain_uuid,
-        detail_val = 5
+            notice_type, hostname, current_time)
-        uuID = 'test_uuid'
+
-        noticeType = 'VM'
+        retry_max = 12
-        hostname = 'masakari-node'
+        retry_interval = 10
-        currentTime = timeutils.utcnow()
+        event = {
-        obj.libvirt_event_callback(eventID_val,
+            'notification': {
-                                   detail_val,
+                'type': notice_type,
-                                   uuID,
+                'hostname': hostname,
-                                   noticeType,
+                'generated_time': current_time,
-                                   hostname,
+                'payload': {
-                                   currentTime)
+                    'event': event_id,
+                    'instance_uuid': domain_uuid,
+                    'vir_domain_event': details
+                }
+            }
+        }
+        mock_send_notification.assert_called_once_with(
+            retry_max, retry_interval, event)

masakarimonitors/tests/unit/instancemonitor/libvirt_handler/test_eventfilter.py

@@ -13,12 +13,20 @@
 # limitations under the License.
 
 import mock
+import socket
 import testtools
+import threading
+import uuid
 
 import eventlet
+from oslo_utils import excutils
+from oslo_utils import timeutils
 
 from masakarimonitors.instancemonitor.libvirt_handler import callback
 from masakarimonitors.instancemonitor.libvirt_handler import eventfilter
+from masakarimonitors.instancemonitor.libvirt_handler \
+    import eventfilter_table as evft
+from masakarimonitors.objects import event_constants as ec
 
 eventlet.monkey_patch(os=False)
 
@@ -28,16 +36,123 @@ class TestEventFilter(testtools.TestCase):
     def setUp(self):
         super(TestEventFilter, self).setUp()
 
+    @mock.patch.object(excutils, 'save_and_reraise_exception')
     @mock.patch.object(callback.Callback, 'libvirt_event_callback')
-    def test_vir_event_filter(self,
+    @mock.patch.object(timeutils, 'utcnow')
-                              mock_libvirt_event_callback):
+    def test_vir_event_filter(self, mock_utcnow, mock_libvirt_event_callback,
+        mock_save_and_reraise_exception):
+
+        current_time = timeutils.utcnow()
+        mock_utcnow.return_value = current_time
+        mock_libvirt_event_callback.return_value = None
+        mock_save_and_reraise_exception.return_value = None
 
         obj = eventfilter.EventFilter()
-
-        mock_libvirt_event_callback.return_value = 0
-
         eventID = 0
         eventType = 5
         detail = 5
-        uuID = 'test_uuid'
+        uuID = uuid.uuid4()
         obj.vir_event_filter(eventID, eventType, detail, uuID)
+
+        mock_libvirt_event_callback.assert_called_once_with(
+            evft.eventID_dic[eventID],
+            evft.detail_dic[eventID][eventType][detail],
+            uuID,
+            ec.EventConstants.TYPE_VM,
+            socket.gethostname(),
+            current_time)
+        mock_save_and_reraise_exception.assert_not_called()
+
+    @mock.patch.object(excutils, 'save_and_reraise_exception')
+    @mock.patch.object(callback.Callback, 'libvirt_event_callback')
+    def test_vir_event_filter_unmatched(self, mock_libvirt_event_callback,
+        mock_save_and_reraise_exception):
+
+        mock_libvirt_event_callback.return_value = None
+        mock_save_and_reraise_exception.return_value = None
+
+        obj = eventfilter.EventFilter()
+        eventID = 0
+        eventType = 5
+        detail = 2
+        uuID = uuid.uuid4()
+        obj.vir_event_filter(eventID, eventType, detail, uuID)
+
+        mock_libvirt_event_callback.assert_not_called()
+        mock_save_and_reraise_exception.assert_not_called()
+
+    @mock.patch.object(excutils, 'save_and_reraise_exception')
+    @mock.patch.object(callback.Callback, 'libvirt_event_callback')
+    def test_vir_event_filter_key_error(self, mock_libvirt_event_callback,
+        mock_save_and_reraise_exception):
+
+        mock_libvirt_event_callback.return_value = None
+        mock_save_and_reraise_exception.return_value = None
+
+        obj = eventfilter.EventFilter()
+        eventID = 0
+        eventType = 0
+        detail = 0
+        uuID = uuid.uuid4()
+        obj.vir_event_filter(eventID, eventType, detail, uuID)
+
+        mock_libvirt_event_callback.assert_not_called()
+        mock_save_and_reraise_exception.assert_not_called()
+
+    @mock.patch.object(excutils, 'save_and_reraise_exception')
+    @mock.patch.object(callback.Callback, 'libvirt_event_callback')
+    @mock.patch.object(threading, 'Thread')
+    def test_vir_event_filter_type_error(self, mock_Thread,
+        mock_libvirt_event_callback, mock_save_and_reraise_exception):
+
+        mock_Thread.side_effect = TypeError("Threading exception.")
+        mock_libvirt_event_callback.return_value = None
+        mock_save_and_reraise_exception.return_value = None
+
+        obj = eventfilter.EventFilter()
+        eventID = 0
+        eventType = 5
+        detail = 5
+        uuID = uuid.uuid4()
+        obj.vir_event_filter(eventID, eventType, detail, uuID)
+
+        mock_libvirt_event_callback.assert_not_called()
+        mock_save_and_reraise_exception.assert_not_called()
+
+    @mock.patch.object(excutils, 'save_and_reraise_exception')
+    @mock.patch.object(callback.Callback, 'libvirt_event_callback')
+    @mock.patch.object(threading, 'Thread')
+    def test_vir_event_filter_index_error(self, mock_Thread,
+        mock_libvirt_event_callback, mock_save_and_reraise_exception):
+
+        mock_Thread.side_effect = IndexError("Threading exception.")
+        mock_libvirt_event_callback.return_value = None
+        mock_save_and_reraise_exception.return_value = None
+
+        obj = eventfilter.EventFilter()
+        eventID = 0
+        eventType = 5
+        detail = 5
+        uuID = uuid.uuid4()
+        obj.vir_event_filter(eventID, eventType, detail, uuID)
+
+        mock_libvirt_event_callback.assert_not_called()
+        mock_save_and_reraise_exception.assert_not_called()
+
+    @mock.patch.object(callback.Callback, 'libvirt_event_callback')
+    @mock.patch.object(threading, 'Thread')
+    def test_vir_event_filter_other_exception(self, mock_Thread,
+        mock_libvirt_event_callback):
+
+        mock_Thread.side_effect = NameError("Threading exception.")
+        mock_libvirt_event_callback.return_value = None
+
+        obj = eventfilter.EventFilter()
+        eventID = 0
+        eventType = 5
+        detail = 5
+        uuID = uuid.uuid4()
+        self.assertRaises(NameError, obj.vir_event_filter, eventID, eventType,
+            detail, uuID)
+
+        mock_libvirt_event_callback.assert_not_called()

masakarimonitors/tests/unit/instancemonitor/test_instance.py

@@ -15,12 +15,14 @@
 import libvirt
 import mock
 import testtools
+import threading
+import time
+import uuid
 
 import eventlet
 
 from masakarimonitors.instancemonitor import instance
 from masakarimonitors.instancemonitor.libvirt_handler import eventfilter
-from masakarimonitors.tests.unit.instancemonitor import fakes
 
 eventlet.monkey_patch(os=False)
 
@@ -30,25 +32,221 @@ class TestInstancemonitorManager(testtools.TestCase):
     def setUp(self):
         super(TestInstancemonitorManager, self).setUp()
 
-    @mock.patch.object(libvirt, 'openReadOnly')
+    def _make_callback_params(self):
-    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+        mock_conn = mock.Mock()
-    @mock.patch.object(instance.InstancemonitorManager,
+        mock_dom = mock.Mock()
-                       '_vir_event_loop_native_start')
+        test_uuid = uuid.uuid4()
-    def test_main(self,
+        mock_dom.UUIDString.return_value = test_uuid
-                  mock_vir_event_loop_native_start,
+        mock_opaque = mock.Mock()
-                  mock_vir_event_filter,
+
-                  mock_openReadOnly):
+        return mock_conn, mock_dom, mock_opaque, test_uuid
+
+    @mock.patch.object(libvirt, 'virEventRunDefaultImpl')
+    def test_vir_event_loop_native_run(self, mock_virEventRunDefaultImpl):
+        mock_virEventRunDefaultImpl.side_effect = Exception("Test exception.")
 
         obj = instance.InstancemonitorManager()
-
-        mock_vir_event_loop_native_start.return_value = None
-        mock_vir_event_filter.return_value = None
-        mock_openReadOnly.return_value = fakes.FakeLibvirtOpenReadOnly()
-
         exception_flag = False
         try:
-            obj.main()
+            obj._vir_event_loop_native_run()
-        except EnvironmentError:
+        except Exception:
             exception_flag = True
 
         self.assertTrue(exception_flag)
+        mock_virEventRunDefaultImpl.assert_called_once()
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_callback(self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_callback(mock_conn, mock_dom, 0, 1, mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_LIFECYCLE, 0, 1, test_uuid)
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_reboot_callback(self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_reboot_callback(mock_conn, mock_dom, mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_REBOOT, -1, -1, test_uuid)
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_rtc_change_callback(self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+        utcoffset = ""
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_rtc_change_callback(
+            mock_conn, mock_dom, utcoffset, mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_RTC_CHANGE, -1, -1, test_uuid)
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_watchdog_callback(self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+        action = 0
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_watchdog_callback(
+            mock_conn, mock_dom, action, mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_WATCHDOG, action, -1, test_uuid)
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_io_error_callback(self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+        srcpath = ""
+        devalias = ""
+        action = 0
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_io_error_callback(
+            mock_conn, mock_dom, srcpath, devalias, action, mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_IO_ERROR, action, -1, test_uuid)
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_graphics_callback(self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+        phase = 0
+        localAddr = ""
+        remoteAddr = ""
+        authScheme = ""
+        subject = ""
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_graphics_callback(
+            mock_conn, mock_dom, phase, localAddr, remoteAddr, authScheme,
+            subject, mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_GRAPHICS, -1, phase, test_uuid)
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_disk_change_callback(
+        self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+        oldSrcPath = ""
+        newSrcPath = ""
+        devAlias = ""
+        reason = ""
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_disk_change_callback(
+            mock_conn, mock_dom, oldSrcPath, newSrcPath, devAlias, reason,
+            mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_DISK_CHANGE, -1, -1, test_uuid)
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_io_error_reason_callback(
+        self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+        srcPath = ""
+        devAlias = ""
+        action = ""
+        reason = ""
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_io_error_reason_callback(
+            mock_conn, mock_dom, srcPath, devAlias, action, reason,
+            mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON, -1, -1, test_uuid)
+
+    @mock.patch.object(eventfilter.EventFilter, 'vir_event_filter')
+    def test_my_domain_event_generic_callback(self, mock_vir_event_filter):
+        mock_vir_event_filter.return_value = None
+        mock_conn, mock_dom, mock_opaque, test_uuid = \
+            self._make_callback_params()
+
+        obj = instance.InstancemonitorManager()
+        obj._my_domain_event_generic_callback(
+            mock_conn, mock_dom, mock_opaque)
+
+        mock_vir_event_filter.assert_called_once_with(
+            libvirt.VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, -1, -1, test_uuid)
+
+    def test_err_handler(self):
+        obj = instance.InstancemonitorManager()
+        obj._err_handler("Test context.", ('err0.', 'err1', 'err2'))
+
+    def test_stop(self):
+        obj = instance.InstancemonitorManager()
+        obj.stop()
+        self.assertFalse(obj.running)
+
+    @mock.patch.object(time, 'sleep')
+    @mock.patch.object(eventlet.greenthread, 'sleep')
+    @mock.patch.object(libvirt, 'openReadOnly')
+    @mock.patch.object(threading, 'Thread')
+    @mock.patch.object(libvirt, 'virEventRegisterDefaultImpl')
+    def test_main(self,
+                  mock_virEventRegisterDefaultImpl,
+                  mock_Thread,
+                  mock_openReadOnly,
+                  mock_greenthread_sleep,
+                  mock_time_sleep):
+
+        mock_virEventRegisterDefaultImpl.return_value = None
+        mock_event_loop_thread = mock.Mock(return_value=None)
+        mock_Thread.return_value = mock_event_loop_thread
+        mock_vc = mock.Mock()
+        mock_openReadOnly.return_value = mock_vc
+        mock_vc.domainEventRegisterAny.side_effect = \
+            [0, 0, 0, 0, 0, 0, 0, 0, 0]
+        mock_vc.setKeepAlive.return_value = None
+        mock_vc.isAlive.side_effect = [1, 0]
+        mock_vc.domainEventDeregisterAny.side_effect = \
+            [None, None, None, None, None, None, None, None,
+             Exception("Test exception.")]
+        mock_vc.close.return_value = None
+        mock_greenthread_sleep.return_value = None
+        mock_time_sleep.side_effect = Exception("Test exception.")
+
+        obj = instance.InstancemonitorManager()
+        exception_flag = False
+        try:
+            obj.main()
+        except Exception:
+            exception_flag = True
+
+        handlers_count = 9
+        self.assertTrue(exception_flag)
+        mock_virEventRegisterDefaultImpl.assert_called_once()
+        mock_event_loop_thread.setDaemon.assert_called_once_with(True)
+        mock_event_loop_thread.start.assert_called_once()
+        mock_openReadOnly.assert_called_once_with("qemu:///system")
+        self.assertEqual(
+            handlers_count, mock_vc.domainEventRegisterAny.call_count)
+        mock_vc.setKeepAlive.assert_called_once_with(5, 3)
+        self.assertEqual(2, mock_vc.isAlive.call_count)
+        self.assertEqual(
+            handlers_count, mock_vc.domainEventDeregisterAny.call_count)
+        mock_vc.close.assert_called_once()