Merge "Added additional worker unit test coverage"

designate/tests/unit/workers/test_base_task.py

@@ -13,17 +13,28 @@
 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 # License for the specific language governing permissions and limitations
 # under the License.mport threading
+from oslo_config import cfg
+from oslo_config import fixture as cfg_fixture
 import oslotest.base
 from unittest import mock
 
+from designate.central import rpcapi as central_rpcapi
 from designate import exceptions
 from designate import objects
+import designate.quota.base
+from designate import rpc
+from designate import storage
+from designate.worker import rpcapi as worker_rpcapi
 from designate.worker.tasks import base
 
 
+CONF = cfg.CONF
+
+
 class TestTask(oslotest.base.BaseTestCase):
     def setUp(self):
         super(TestTask, self).setUp()
+        self.useFixture(cfg_fixture.Config(CONF))
         self.context = mock.Mock()
         self.task = base.Task(None)
         self.storage = self.task._storage = mock.Mock()
@@ -31,8 +42,38 @@ class TestTask(oslotest.base.BaseTestCase):
     def test_constructor(self):
         self.assertTrue(self.task)
 
-    def test_call(self):
-        self.assertRaises(NotImplementedError, self.task)
+    @mock.patch.object(storage, 'get_storage', mock.Mock())
+    def test_quota(self):
+        self.assertIsInstance(self.task.quota, designate.quota.base.Quota)
+
+    @mock.patch.object(rpc, 'get_client', mock.Mock())
+    def test_central_api(self):
+        self.assertIsInstance(self.task.central_api, central_rpcapi.CentralAPI)
+
+    @mock.patch.object(rpc, 'get_client', mock.Mock())
+    def test_worker_api(self):
+        self.assertIsNone(self.task._worker_api)
+        self.assertIsInstance(self.task.worker_api, worker_rpcapi.WorkerAPI)
+        self.assertIsNotNone(self.task._worker_api)
+        self.assertIsInstance(self.task.worker_api, worker_rpcapi.WorkerAPI)
+
+    def test_compare_threshold_at_50_percentage(self):
+        CONF.set_override('threshold_percentage', 50, 'service:worker')
+
+        self.assertFalse(self.task.compare_threshold(0, 0))
+        self.assertTrue(self.task.compare_threshold(3, 3))
+        self.assertFalse(self.task.compare_threshold(1, 3))
+        self.assertFalse(self.task.compare_threshold(2, 5))
+        self.assertTrue(self.task.compare_threshold(4, 5))
+
+    def test_compare_threshold_at_100_percentage(self):
+        CONF.set_override('threshold_percentage', 100, 'service:worker')
+
+        self.assertFalse(self.task.compare_threshold(0, 0))
+        self.assertTrue(self.task.compare_threshold(3, 3))
+        self.assertFalse(self.task.compare_threshold(1, 3))
+        self.assertFalse(self.task.compare_threshold(2, 5))
+        self.assertFalse(self.task.compare_threshold(4, 5))
 
     def test_current_action_is_valid(self):
         self.storage.get_zone = mock.Mock(
@@ -116,3 +157,6 @@ class TestTask(oslotest.base.BaseTestCase):
             self.task.is_current_action_valid(
                 self.context, 'UPDATE', objects.Zone(action='UPDATE'))
         )
+
+    def test_call(self):
+        self.assertRaises(NotImplementedError, self.task)

designate/tests/unit/workers/test_processing.py

@@ -15,18 +15,30 @@
 # under the License.mport threading
 from unittest import mock
 
+from oslo_config import cfg
+from oslo_config import fixture as cfg_fixture
+
 from designate import exceptions
 from designate.tests import fixtures
 from designate.tests import TestCase
 from designate.worker import processing
 
 
+CONF = cfg.CONF
+
+
 class TestProcessingExecutor(TestCase):
     def setUp(self):
         super(TestProcessingExecutor, self).setUp()
         self.stdlog = fixtures.StandardLogging()
+        self.useFixture(cfg_fixture.Config(CONF))
         self.useFixture(self.stdlog)
 
+    def test_default_executor(self):
+        CONF.set_override('threads', 100, 'service:worker')
+        executor = processing.default_executor()
+        self.assertEqual(100, executor._max_workers)
+
     def test_execute_multiple_tasks(self):
         def t1():
             return 1

designate/tests/unit/workers/test_service.py

@@ -21,9 +21,11 @@ import oslo_messaging as messaging
 import oslotest.base
 
 from designate import backend
+from designate.central import rpcapi as central_rpcapi
 from designate import exceptions
 from designate import objects
 import designate.service
+from designate import storage
 import designate.tests
 from designate.tests import fixtures
 from designate.worker import processing
@@ -67,12 +69,19 @@ class TestService(oslotest.base.BaseTestCase):
         self.assertEqual('worker', self.service.service_name)
 
     def test_central_api(self):
-        self.service._central_api = 'foo'
-        self.assertEqual(self.service.central_api, 'foo')
+        self.assertIsNone(self.service._central_api)
+        self.assertIsInstance(self.service.central_api,
+                              central_rpcapi.CentralAPI)
+        self.assertIsNotNone(self.service._central_api)
+        self.assertIsInstance(self.service.central_api,
+                              central_rpcapi.CentralAPI)
 
+    @mock.patch.object(storage, 'get_storage', mock.Mock())
     def test_storage(self):
-        self.service._storage = 'foo'
-        self.assertEqual(self.service.storage, 'foo')
+        self.assertIsNone(self.service._storage)
+        self.assertIsInstance(self.service.storage, mock.Mock)
+        self.assertIsNotNone(self.service._storage)
+        self.assertIsInstance(self.service.storage, mock.Mock)
 
     @mock.patch.object(backend, 'get_backend', mock.Mock())
     def test_setup_target_backends(self):

designate/tests/unit/workers/test_task_config.py

@@ -0,0 +1,70 @@
+# 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.mport threading
+from oslo_config import cfg
+from oslo_config import fixture as cfg_fixture
+import oslotest.base
+
+from designate.worker.tasks import base
+
+CONF = cfg.CONF
+
+
+class TestTaskConfig(oslotest.base.BaseTestCase):
+    def setUp(self):
+        super(TestTaskConfig, self).setUp()
+        self.useFixture(cfg_fixture.Config(CONF))
+        self.task_config = base.TaskConfig()
+
+    def test_load_config(self):
+        self.assertIsInstance(
+            self.task_config.config, cfg.ConfigOpts.GroupAttr
+        )
+
+    def test_threshold_percentage(self):
+        CONF.set_override('threshold_percentage', 51, 'service:worker')
+
+        self.assertIsNone(self.task_config._threshold_percentage)
+        self.assertEqual(51, self.task_config.threshold_percentage)
+        self.assertIsNotNone(self.task_config._threshold_percentage)
+        self.assertEqual(51, self.task_config.threshold_percentage)
+
+    def test_timeout(self):
+        CONF.set_override('poll_timeout', 52, 'service:worker')
+
+        self.assertIsNone(self.task_config._timeout)
+        self.assertEqual(52, self.task_config.timeout)
+        self.assertIsNotNone(self.task_config._timeout)
+        self.assertEqual(52, self.task_config.timeout)
+
+    def test_retry_interval(self):
+        CONF.set_override('poll_retry_interval', 53, 'service:worker')
+        self.assertEqual(53, self.task_config.retry_interval)
+
+    def test_max_retries(self):
+        CONF.set_override('poll_max_retries', 54, 'service:worker')
+        self.assertEqual(54, self.task_config.max_retries)
+
+    def test_delay(self):
+        CONF.set_override('poll_delay', 55, 'service:worker')
+        self.assertEqual(55, self.task_config.delay)
+
+    def test_max_prop_time(self):
+        CONF.set_override('threshold_percentage', 100, 'service:worker')
+        CONF.set_override('poll_timeout', 10, 'service:worker')
+        CONF.set_override('poll_retry_interval', 10, 'service:worker')
+        CONF.set_override('poll_max_retries', 10, 'service:worker')
+        CONF.set_override('poll_delay', 3, 'service:worker')
+
+        self.assertIsNone(self.task_config._max_prop_time)
+        self.assertEqual(203, self.task_config.max_prop_time)
+        self.assertIsNotNone(self.task_config._max_prop_time)
+        self.assertEqual(203, self.task_config.max_prop_time)

designate/worker/processing.py

@@ -26,16 +26,10 @@ CONF = cfg.CONF
 
 
 def default_executor():
-    thread_count = 5
-    try:
-        thread_count = CONF['service:worker'].threads
-    except Exception:
-        pass
-
     # TODO(mugsie): if (when) we move away from eventlet this may have to
     # revert back to ThreadPoolExecutor - this is changing due to
     # https://bugs.launchpad.net/bugs/1782647 (eventlet + py37 issues)
-    return futurist.GreenThreadPoolExecutor(thread_count)
+    return futurist.GreenThreadPoolExecutor(CONF['service:worker'].threads)
 
 
 class Executor(object):