Add test coverage for periodic tasks

Add test coverage for methods that are periodic tasks for two reasons:

- Test it in general
- Reduce test coverage reporting dispersion, where periodic tasks often have
different coverage with each subsequent run.

Change-Id: I539ac140aa4f89650c093350063e37f3afa46922
Partial-Bug: #1477547

manila/tests/test_manager.py

@@ -15,6 +15,7 @@
 
 """Test of Base Manager for Manila."""
 
+import ddt
 import mock
 from oslo_utils import importutils
 
@@ -22,13 +23,17 @@ from manila import manager
 from manila import test
 
 
+@ddt.ddt
 class ManagerTestCase(test.TestCase):
 
-    @mock.patch.object(importutils, 'import_module', mock.Mock())
+    def setUp(self):
+        super(self.__class__, self).setUp()
+        self.host = 'host'
+        self.db_driver = 'fake_driver'
+        self.mock_object(importutils, 'import_module')
+
     def test_verify_manager_instance(self):
-        host = 'fake_host'
-        db_driver = 'fake_driver'
-        fake_manager = manager.Manager(host, db_driver)
+        fake_manager = manager.Manager(self.host, self.db_driver)
         self.assertTrue(hasattr(fake_manager, '_periodic_tasks'))
         self.assertTrue(hasattr(fake_manager, 'additional_endpoints'))
         self.assertTrue(hasattr(fake_manager, 'host'))
@@ -36,33 +41,82 @@ class ManagerTestCase(test.TestCase):
         self.assertTrue(hasattr(fake_manager, 'init_host'))
         self.assertTrue(hasattr(fake_manager, 'service_version'))
         self.assertTrue(hasattr(fake_manager, 'service_config'))
-        self.assertEqual(fake_manager.host, host)
-        importutils.import_module.assert_called_once_with(db_driver)
+        self.assertEqual(fake_manager.host, self.host)
+        importutils.import_module.assert_called_once_with(self.db_driver)
+
+    @ddt.data(True, False)
+    def test_periodic_tasks(self, raise_on_error):
+        fake_manager = manager.Manager(self.host, self.db_driver)
+        fake_context = 'fake_context'
+        self.mock_object(fake_manager, 'run_periodic_tasks')
+
+        fake_manager.periodic_tasks(fake_context, raise_on_error)
+
+        fake_manager.run_periodic_tasks.assert_called_once_with(
+            fake_context, raise_on_error=raise_on_error)
 
 
+@ddt.ddt
 class SchedulerDependentManagerTestCase(test.TestCase):
 
-    @mock.patch.object(importutils, 'import_module', mock.Mock())
+    def setUp(self):
+        super(self.__class__, self).setUp()
+        self.context = 'fake_context'
+        self.host = 'host'
+        self.db_driver = 'fake_driver'
+        self.service_name = 'fake_service_name'
+        self.mock_object(importutils, 'import_module')
+        self.sched_manager = manager.SchedulerDependentManager(
+            self.host, self.db_driver, self.service_name)
+
     def test_verify_scheduler_dependent_manager_instance(self):
-        host = 'fake_host'
-        db_driver = 'fake_driver'
-        service_name = 'fake_service_name'
-        fake_sched_manager = manager.SchedulerDependentManager(
-            host, db_driver, service_name)
-        self.assertTrue(hasattr(fake_sched_manager, '_periodic_tasks'))
-        self.assertTrue(hasattr(fake_sched_manager, 'additional_endpoints'))
-        self.assertTrue(hasattr(fake_sched_manager, 'host'))
-        self.assertTrue(hasattr(fake_sched_manager, 'periodic_tasks'))
-        self.assertTrue(hasattr(fake_sched_manager, 'init_host'))
-        self.assertTrue(hasattr(fake_sched_manager, 'service_version'))
-        self.assertTrue(hasattr(fake_sched_manager, 'service_config'))
-        self.assertTrue(hasattr(fake_sched_manager, 'last_capabilities'))
-        self.assertTrue(hasattr(fake_sched_manager, 'service_name'))
-        self.assertTrue(hasattr(fake_sched_manager, 'scheduler_rpcapi'))
-        self.assertTrue(hasattr(fake_sched_manager,
+        self.assertTrue(hasattr(self.sched_manager, '_periodic_tasks'))
+        self.assertTrue(hasattr(self.sched_manager, 'additional_endpoints'))
+        self.assertTrue(hasattr(self.sched_manager, 'host'))
+        self.assertTrue(hasattr(self.sched_manager, 'periodic_tasks'))
+        self.assertTrue(hasattr(self.sched_manager, 'init_host'))
+        self.assertTrue(hasattr(self.sched_manager, 'service_version'))
+        self.assertTrue(hasattr(self.sched_manager, 'service_config'))
+        self.assertTrue(hasattr(self.sched_manager, 'last_capabilities'))
+        self.assertTrue(hasattr(self.sched_manager, 'service_name'))
+        self.assertTrue(hasattr(self.sched_manager, 'scheduler_rpcapi'))
+        self.assertTrue(hasattr(self.sched_manager,
                                 'update_service_capabilities'))
-        self.assertTrue(hasattr(fake_sched_manager,
+        self.assertTrue(hasattr(self.sched_manager,
                                 '_publish_service_capabilities'))
-        self.assertEqual(fake_sched_manager.host, host)
-        self.assertEqual(fake_sched_manager.service_name, service_name)
-        importutils.import_module.assert_called_once_with(db_driver)
+        self.assertEqual(self.sched_manager.host, self.host)
+        self.assertEqual(self.sched_manager.service_name, self.service_name)
+        importutils.import_module.assert_called_once_with(self.db_driver)
+
+    @ddt.data(None, {}, [], '')
+    def test__publish_service_capabilities_no_update(self, last_capabilities):
+        self.sched_manager.last_capabilities = last_capabilities
+        self.mock_object(
+            self.sched_manager.scheduler_rpcapi, 'update_service_capabilities')
+
+        self.sched_manager._publish_service_capabilities('fake_context')
+
+        self.assertFalse(
+            self.sched_manager.scheduler_rpcapi.update_service_capabilities.
+            called)
+
+    @ddt.data('fake_last_capabilities', {'foo': 'bar'})
+    def test__publish_service_capabilities_with_update(self,
+                                                       last_capabilities):
+        self.sched_manager.last_capabilities = last_capabilities
+        self.mock_object(
+            self.sched_manager.scheduler_rpcapi, 'update_service_capabilities')
+        self.mock_object(manager.LOG, 'debug')
+
+        self.sched_manager._publish_service_capabilities(self.context)
+
+        self.sched_manager.scheduler_rpcapi.update_service_capabilities.\
+            assert_called_once_with(
+                self.context, self.service_name, self.host, last_capabilities)
+        manager.LOG.debug.assert_called_once_with(mock.ANY)
+
+    @ddt.data(None, '', [], {}, {'foo': 'bar'})
+    def test_update_service_capabilities(self, capabilities):
+        self.sched_manager.update_service_capabilities(capabilities)
+
+        self.assertEqual(capabilities, self.sched_manager.last_capabilities)

manila/tests/test_service.py

@@ -21,6 +21,7 @@
 Unit Tests for remote procedure calls using queue
 """
 
+import ddt
 import mock
 from oslo_config import cfg
 
@@ -30,6 +31,7 @@ from manila import exception
 from manila import manager
 from manila import service
 from manila import test
+from manila import utils
 from manila import wsgi
 
 test_service_opts = [
@@ -131,6 +133,7 @@ service_ref = {
 }
 
 
+@ddt.ddt
 class ServiceTestCase(test.TestCase):
     """Test cases for Services."""
 
@@ -140,6 +143,22 @@ class ServiceTestCase(test.TestCase):
                                      topic='fake')
         self.assertTrue(app)
 
+    @ddt.data(True, False)
+    def test_periodic_tasks(self, raise_on_error):
+        serv = service.Service(host, binary, topic, CONF.fake_manager)
+        self.mock_object(
+            context,
+            'get_admin_context',
+            mock.Mock(side_effect=context.get_admin_context))
+        self.mock_object(serv.manager, 'periodic_tasks')
+
+        serv.periodic_tasks(raise_on_error=raise_on_error)
+
+        context.get_admin_context.assert_called_once_with()
+        serv.manager.periodic_tasks.assert_called_once_with(
+            utils.IsAMatcher(context.RequestContext),
+            raise_on_error=raise_on_error)
+
     @mock.patch.object(service.db, 'service_get_by_args',
                        mock.Mock(side_effect=fake_service_get_by_args))
     @mock.patch.object(service.db, 'service_create',