octavia 14.0.0.0rc1__py3-none-any.whl → 15.0.0.0rc1__py3-none-any.whl

octavia/tests/unit/common/jinja/logging/test_logging_jinja_cfg.py

@@ -89,7 +89,7 @@ class LoggingJinjaTestCase(base.TestCase):
 
         lj = logging_jinja_cfg.LoggingJinjaTemplater()
         expected_config = (
-            u'*.* stop')
+            '*.* stop')
 
         logging_cfg = lj.build_logging_config()
 

octavia/tests/unit/common/sample_configs/sample_configs_combined.py

@@ -1262,8 +1262,7 @@ def sample_base_expected_config(frontend=None, logging=None, backend=None,
     if peers is None:
         peers = "\n\n"
     if global_opts is None:
-        global_opts = "    maxconn {maxconn}\n\n".format(
-            maxconn=constants.HAPROXY_DEFAULT_MAXCONN)
+        global_opts = f"    maxconn {constants.HAPROXY_DEFAULT_MAXCONN}\n\n"
     if defaults is None:
         defaults = ("defaults\n"
                     "    log global\n"

octavia/tests/unit/common/test_base_taskflow.py

@@ -92,7 +92,7 @@ class TestTaskFlowServiceController(base.TestCase):
     def test_run_poster(self, mock_engines, mockuuid):
         flow_factory = mock.MagicMock()
         flow_factory.__name__ = 'testname'
-        job_name = 'testname-%s' % self._mock_uuid
+        job_name = f'testname-{self._mock_uuid}'
         job_details = {'store': 'test'}
         with mock.patch.object(self.service_controller, '_wait_for_job'
                                ) as wait:

octavia/tests/unit/common/test_decorators.py

@@ -23,13 +23,13 @@ import octavia.tests.unit.base as base
 class TestDecorator(base.TestCase):
 
     @dec.rename_kwargs(a='z')
-    class TestClass(object):
+    class TestClass:
         def __init__(self, x, z=None):
             self.x = x
             self.z = z
 
     @dec.rename_kwargs(a='z')
-    class TestClassDupe(object):
+    class TestClassDupe:
         def __init__(self, x, z=None):
             self.x = x
             self.z = z

octavia/tests/unit/common/test_policy.py

@@ -164,23 +164,20 @@ class PolicyTestCase(base.TestCase):
     def test_check_is_admin_fail(self):
         self.assertFalse(policy.get_enforcer().check_is_admin(self.context))
 
-    # TODO(johnsom) When oslo.policy changes "enforce_new_defaults" to True
-    #               this test will fail as "system_scope:all" will be required.
-    #               This test and the conditional in common/policy.py can then
-    #               be removed in favor of test_check_is_admin_new_defaults().
     def test_check_is_admin(self):
         self.context = context.RequestContext('admin', project_id='fake',
                                               roles=['AdMiN'])
 
         self.assertTrue(policy.get_enforcer().check_is_admin(self.context))
 
-    def test_check_is_admin_new_defaults(self):
+    def test_check_is_admin_with_system_scope_token(self):
         conf = oslo_fixture.Config(config.cfg.CONF)
         conf.config(group="oslo_policy", enforce_new_defaults=True)
+        conf.config(group="oslo_policy", enforce_scope=True)
         self.context = context.RequestContext('admin', roles=['AdMiN'],
                                               system_scope='all')
 
-        self.assertTrue(policy.get_enforcer().check_is_admin(self.context))
+        self.assertFalse(policy.get_enforcer().check_is_admin(self.context))
 
     def test_get_enforcer(self):
         self.assertTrue(isinstance(policy.get_no_context_enforcer(),

octavia/tests/unit/common/tls_utils/test_cert_parser.py

@@ -246,7 +246,10 @@ class TestTLSParseUtils(base.TestCase):
 
     def test_get_cert_expiration(self):
         exp_date = cert_parser.get_cert_expiration(sample_certs.X509_EXPIRED)
-        self.assertEqual(datetime.datetime(2016, 9, 25, 18, 1, 54), exp_date)
+        self.assertEqual(
+            datetime.datetime(2016, 9, 25, 18, 1, 54,
+                              tzinfo=datetime.timezone.utc),
+            exp_date)
 
         # test the exception
         self.assertRaises(exceptions.UnreadableCert,

octavia/tests/unit/controller/worker/v2/flows/test_listener_flows.py

@@ -44,15 +44,14 @@ class TestListenerFlows(base.TestCase):
 
         self.assertIn(constants.LISTENERS, listener_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, listener_flow.requires)
-        self.assertIn(constants.AMPHORAE_STATUS, listener_flow.requires)
 
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
                       listener_flow.provides)
         self.assertIn(constants.AMPHORAE, listener_flow.provides)
         self.assertIn(constants.AMPHORA_FIREWALL_RULES, listener_flow.provides)
 
-        self.assertEqual(3, len(listener_flow.requires))
-        self.assertEqual(3, len(listener_flow.provides))
+        self.assertEqual(2, len(listener_flow.requires))
+        self.assertEqual(4, len(listener_flow.provides))
 
     def test_get_delete_listener_flow(self, mock_get_net_driver):
         flavor_dict = {
@@ -66,15 +65,14 @@ class TestListenerFlows(base.TestCase):
         self.assertIn(constants.LISTENER, listener_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, listener_flow.requires)
         self.assertIn(constants.PROJECT_ID, listener_flow.requires)
-        self.assertIn(constants.AMPHORAE_STATUS, listener_flow.requires)
 
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
                       listener_flow.provides)
         self.assertIn(constants.AMPHORAE, listener_flow.provides)
         self.assertIn(constants.AMPHORA_FIREWALL_RULES, listener_flow.provides)
 
-        self.assertEqual(4, len(listener_flow.requires))
-        self.assertEqual(3, len(listener_flow.provides))
+        self.assertEqual(3, len(listener_flow.requires))
+        self.assertEqual(4, len(listener_flow.provides))
 
     def test_get_delete_listener_internal_flow(self, mock_get_net_driver):
         flavor_dict = {
@@ -88,15 +86,14 @@ class TestListenerFlows(base.TestCase):
 
         self.assertIn(constants.LOADBALANCER_ID, listener_flow.requires)
         self.assertIn(constants.PROJECT_ID, listener_flow.requires)
-        self.assertIn(constants.AMPHORAE_STATUS, listener_flow.requires)
 
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
                       listener_flow.provides)
         self.assertIn(constants.AMPHORAE, listener_flow.provides)
         self.assertIn(constants.AMPHORA_FIREWALL_RULES, listener_flow.provides)
 
-        self.assertEqual(3, len(listener_flow.requires))
-        self.assertEqual(3, len(listener_flow.provides))
+        self.assertEqual(2, len(listener_flow.requires))
+        self.assertEqual(4, len(listener_flow.provides))
 
     def test_get_update_listener_flow(self, mock_get_net_driver):
         flavor_dict = {
@@ -112,15 +109,14 @@ class TestListenerFlows(base.TestCase):
         self.assertIn(constants.UPDATE_DICT, listener_flow.requires)
         self.assertIn(constants.LISTENERS, listener_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, listener_flow.requires)
-        self.assertIn(constants.AMPHORAE_STATUS, listener_flow.requires)
 
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
                       listener_flow.provides)
         self.assertIn(constants.AMPHORAE, listener_flow.provides)
         self.assertIn(constants.AMPHORA_FIREWALL_RULES, listener_flow.provides)
 
-        self.assertEqual(5, len(listener_flow.requires))
-        self.assertEqual(3, len(listener_flow.provides))
+        self.assertEqual(4, len(listener_flow.requires))
+        self.assertEqual(4, len(listener_flow.provides))
 
     def test_get_create_all_listeners_flow(self, mock_get_net_driver):
         flavor_dict = {
@@ -131,12 +127,11 @@ class TestListenerFlows(base.TestCase):
         self.assertIsInstance(listeners_flow, flow.Flow)
         self.assertIn(constants.LOADBALANCER, listeners_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, listeners_flow.requires)
-        self.assertIn(constants.AMPHORAE_STATUS, listeners_flow.requires)
         self.assertIn(constants.LOADBALANCER, listeners_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
                       listeners_flow.provides)
         self.assertIn(constants.AMPHORAE, listeners_flow.provides)
         self.assertIn(constants.AMPHORA_FIREWALL_RULES,
                       listeners_flow.provides)
-        self.assertEqual(3, len(listeners_flow.requires))
-        self.assertEqual(5, len(listeners_flow.provides))
+        self.assertEqual(2, len(listeners_flow.requires))
+        self.assertEqual(6, len(listeners_flow.provides))

octavia/tests/unit/controller/worker/v2/flows/test_load_balancer_flows.py

@@ -344,7 +344,6 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.FLAVOR, failover_flow.requires)
         self.assertIn(constants.LOADBALANCER, failover_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, failover_flow.requires)
-        self.assertIn(constants.AMPHORAE_STATUS, failover_flow.requires)
 
         self.assertIn(constants.UPDATED_PORTS, failover_flow.provides)
         self.assertIn(constants.AMPHORA, failover_flow.provides)
@@ -364,9 +363,9 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.SUBNET, failover_flow.provides)
         self.assertIn(constants.NEW_AMPHORAE, failover_flow.provides)
 
-        self.assertEqual(7, len(failover_flow.requires),
+        self.assertEqual(6, len(failover_flow.requires),
                          failover_flow.requires)
-        self.assertEqual(16, len(failover_flow.provides),
+        self.assertEqual(17, len(failover_flow.provides),
                          failover_flow.provides)
 
     @mock.patch('octavia.common.rpc.NOTIFIER',
@@ -424,7 +423,6 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.FLAVOR, failover_flow.requires)
         self.assertIn(constants.LOADBALANCER, failover_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, failover_flow.requires)
-        self.assertIn(constants.AMPHORAE_STATUS, failover_flow.requires)
 
         self.assertIn(constants.UPDATED_PORTS, failover_flow.provides)
         self.assertIn(constants.AMPHORA, failover_flow.provides)
@@ -445,9 +443,9 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.SUBNET, failover_flow.provides)
         self.assertIn(constants.NEW_AMPHORAE, failover_flow.provides)
 
-        self.assertEqual(7, len(failover_flow.requires),
+        self.assertEqual(6, len(failover_flow.requires),
                          failover_flow.requires)
-        self.assertEqual(16, len(failover_flow.provides),
+        self.assertEqual(17, len(failover_flow.provides),
                          failover_flow.provides)
 
     @mock.patch('octavia.common.rpc.NOTIFIER',

octavia/tests/unit/controller/worker/v2/tasks/test_network_tasks.py

@@ -1670,7 +1670,11 @@ class TestNetworkTasks(base.TestCase):
         # Test revert
         mock_driver.reset_mock()
 
-        net_task.revert([port_mock], vip_dict, VIP_SG_ID, AMP_ID,
+        # The execute path generates a port dict, so this will be the result
+        # passed into the revert method by Taskflow
+        port_dict = {constants.ID: PORT_ID}
+
+        net_task.revert(port_dict, vip_dict, VIP_SG_ID, AMP_ID,
                         additional_vips)
 
         mock_driver.delete_port.assert_called_once_with(PORT_ID)
@@ -1678,7 +1682,7 @@ class TestNetworkTasks(base.TestCase):
         # Test revert exception
         mock_driver.reset_mock()
 
-        net_task.revert([port_mock], vip_dict, VIP_SG_ID, AMP_ID,
+        net_task.revert(port_dict, vip_dict, VIP_SG_ID, AMP_ID,
                         additional_vips)
 
         mock_driver.delete_port.assert_called_once_with(PORT_ID)

octavia/tests/unit/controller/worker/v2/tasks/test_retry_tasks.py

@@ -22,7 +22,7 @@ import octavia.tests.unit.base as base
 class TestRetryTasks(base.TestCase):
 
     def setUp(self):
-        super(TestRetryTasks, self).setUp()
+        super().setUp()
 
     @mock.patch('time.sleep')
     def test_sleeping_retry_times_controller(self, mock_sleep):

octavia/tests/unit/controller/worker/v2/test_controller_worker.py

@@ -27,7 +27,7 @@ from octavia.controller.worker.v2 import controller_worker
 from octavia.controller.worker.v2.flows import flow_utils
 import octavia.tests.unit.base as base
 
-
+TLS_CERT_ID = uuidutils.generate_uuid()
 AMP_ID = uuidutils.generate_uuid()
 LB_ID = uuidutils.generate_uuid()
 LISTENER_ID = uuidutils.generate_uuid()
@@ -804,6 +804,61 @@ class TestControllerWorker(base.TestCase):
                        })
          )
 
+    @mock.patch(
+        "octavia.common.tls_utils.cert_parser.load_certificates_data",
+        side_effect=RuntimeError
+    )
+    def test_delete_load_balancer_with_cascade_tls_unavailable(
+            self,
+            mock_load_tls_cert,
+            mock_api_get_session,
+            mock_dyn_log_listener,
+            mock_taskflow_load,
+            mock_pool_repo_get,
+            mock_member_repo_get,
+            mock_l7rule_repo_get,
+            mock_l7policy_repo_get,
+            mock_listener_repo_get,
+            mock_lb_repo_get,
+            mock_health_mon_repo_get,
+            mock_amp_repo_get
+    ):
+        _flow_mock.reset_mock()
+
+        _listener_mock.tls_certificate_id = TLS_CERT_ID
+        _listener_mock.to_dict.return_value[
+            constants.TLS_CERTIFICATE_ID] = TLS_CERT_ID
+
+        cw = controller_worker.ControllerWorker()
+        cw.delete_load_balancer(_load_balancer_mock, cascade=True)
+
+        mock_lb_repo_get.assert_called_once_with(
+            _db_session,
+            id=LB_ID)
+
+        # Check load_certificates_data called and error is raised
+        # Error must be ignored because it is not critical for current flow
+        mock_load_tls_cert.assert_called_once()
+
+        listener_list = [{constants.LISTENER_ID: LISTENER_ID,
+                          constants.LOADBALANCER_ID: LB_ID,
+                          constants.PROJECT_ID: PROJECT_ID,
+                          "default_tls_container_ref": TLS_CERT_ID}]
+
+        (cw.services_controller.run_poster.
+            assert_called_once_with(
+                flow_utils.get_cascade_delete_load_balancer_flow,
+                _load_balancer_mock, listener_list, [],
+                store={constants.LOADBALANCER: _load_balancer_mock,
+                       constants.LOADBALANCER_ID: LB_ID,
+                       constants.SERVER_GROUP_ID:
+                           _db_load_balancer_mock.server_group_id,
+                       constants.PROJECT_ID: _db_load_balancer_mock.project_id,
+                       })
+         )
+
+        _listener_mock.reset_mock()
+
     @mock.patch('octavia.db.repositories.ListenerRepository.get_all',
                 return_value=([_listener_mock], None))
     def test_update_load_balancer(self,

octavia/tests/unit/controller/worker/v2/test_taskflow_jobboard_driver.py

@@ -0,0 +1,348 @@
+# Copyright 2024 NTT DATA Group 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.
+#
+from unittest import mock
+
+from oslo_config import cfg
+
+from octavia.controller.worker.v2 import taskflow_jobboard_driver
+import octavia.tests.unit.base as base
+
+
+class TestRedisTaskFlowDriver(base.TestCase):
+
+    @mock.patch('octavia.controller.worker.v2.taskflow_jobboard_driver.'
+                'job_backends')
+    def test_job_board_default(self, mock_job_backends):
+        driver = taskflow_jobboard_driver.RedisTaskFlowDriver(mock.Mock())
+        driver.job_board(None)
+        mock_job_backends.backend.assert_called_once_with(
+            'octavia_jobboard',
+            {
+                'board': 'redis',
+                'host': '127.0.0.1',
+                'port': 6379,
+                'namespace': 'octavia_jobboard',
+                'sentinel': None,
+                'sentinel_fallbacks': [],
+                'ssl': False,
+                'ssl_keyfile': None,
+                'ssl_certfile': None,
+                'ssl_ca_certs': None,
+                'ssl_cert_reqs': 'required',
+                'sentinel_kwargs': {
+                    'ssl': False,
+                    'ssl_keyfile': None,
+                    'ssl_certfile': None,
+                    'ssl_ca_certs': None,
+                    'ssl_cert_reqs': 'required',
+                }
+            },
+            persistence=None
+        )
+
+    @mock.patch('octavia.controller.worker.v2.taskflow_jobboard_driver.'
+                'job_backends')
+    def test_job_board_password(self, mock_job_backends):
+        driver = taskflow_jobboard_driver.RedisTaskFlowDriver(mock.Mock())
+        cfg.CONF.set_override('jobboard_backend_password', 'redispass',
+                              group='task_flow')
+        driver.job_board(None)
+        mock_job_backends.backend.assert_called_once_with(
+            'octavia_jobboard',
+            {
+                'board': 'redis',
+                'host': '127.0.0.1',
+                'port': 6379,
+                'namespace': 'octavia_jobboard',
+                'password': 'redispass',
+                'sentinel': None,
+                'sentinel_fallbacks': [],
+                'ssl': False,
+                'ssl_keyfile': None,
+                'ssl_certfile': None,
+                'ssl_ca_certs': None,
+                'ssl_cert_reqs': 'required',
+                'sentinel_kwargs': {
+                    'ssl': False,
+                    'ssl_keyfile': None,
+                    'ssl_certfile': None,
+                    'ssl_ca_certs': None,
+                    'ssl_cert_reqs': 'required',
+                }
+            },
+            persistence=None
+        )
+
+    @mock.patch('octavia.controller.worker.v2.taskflow_jobboard_driver.'
+                'job_backends')
+    def test_job_board_username(self, mock_job_backends):
+        driver = taskflow_jobboard_driver.RedisTaskFlowDriver(mock.Mock())
+        cfg.CONF.set_override('jobboard_backend_password', 'redispass',
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_username', 'redisuser',
+                              group='task_flow')
+        driver.job_board(None)
+        mock_job_backends.backend.assert_called_once_with(
+            'octavia_jobboard',
+            {
+                'board': 'redis',
+                'host': '127.0.0.1',
+                'port': 6379,
+                'namespace': 'octavia_jobboard',
+                'username': 'redisuser',
+                'password': 'redispass',
+                'sentinel': None,
+                'sentinel_fallbacks': [],
+                'ssl': False,
+                'ssl_keyfile': None,
+                'ssl_certfile': None,
+                'ssl_ca_certs': None,
+                'ssl_cert_reqs': 'required',
+                'sentinel_kwargs': {
+                    'ssl': False,
+                    'ssl_keyfile': None,
+                    'ssl_certfile': None,
+                    'ssl_ca_certs': None,
+                    'ssl_cert_reqs': 'required',
+                }
+            },
+            persistence=None
+        )
+
+    @mock.patch('octavia.controller.worker.v2.taskflow_jobboard_driver.'
+                'job_backends')
+    def test_job_board_ssl(self, mock_job_backends):
+        driver = taskflow_jobboard_driver.RedisTaskFlowDriver(mock.Mock())
+        cfg.CONF.set_override(
+            'jobboard_redis_backend_ssl_options',
+            {
+                'ssl': True,
+                'ssl_keyfile': 'rediskey',
+                'ssl_certfile': 'rediscert',
+                'ssl_ca_certs': 'redisca',
+                'ssl_cert_reqs': 'required'
+            },
+            group='task_flow')
+        driver.job_board(None)
+        mock_job_backends.backend.assert_called_once_with(
+            'octavia_jobboard',
+            {
+                'board': 'redis',
+                'host': '127.0.0.1',
+                'port': 6379,
+                'namespace': 'octavia_jobboard',
+                'sentinel': None,
+                'sentinel_fallbacks': [],
+                'ssl': True,
+                'ssl_keyfile': 'rediskey',
+                'ssl_certfile': 'rediscert',
+                'ssl_ca_certs': 'redisca',
+                'ssl_cert_reqs': 'required',
+                'sentinel_kwargs': {
+                    'ssl': False,
+                    'ssl_keyfile': None,
+                    'ssl_certfile': None,
+                    'ssl_ca_certs': None,
+                    'ssl_cert_reqs': 'required',
+                }
+            },
+            persistence=None
+        )
+
+    @mock.patch('octavia.controller.worker.v2.taskflow_jobboard_driver.'
+                'job_backends')
+    def test_job_board_sentinel(self, mock_job_backends):
+        driver = taskflow_jobboard_driver.RedisTaskFlowDriver(mock.Mock())
+        cfg.CONF.set_override('jobboard_redis_sentinel', 'mymaster',
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_hosts',
+                              ['host1', 'host2', 'host3'],
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_port', 26379,
+                              group='task_flow')
+        driver.job_board(None)
+        mock_job_backends.backend.assert_called_once_with(
+            'octavia_jobboard',
+            {
+                'board': 'redis',
+                'host': 'host1',
+                'port': 26379,
+                'namespace': 'octavia_jobboard',
+                'sentinel': 'mymaster',
+                'sentinel_fallbacks': ['host2:26379', 'host3:26379'],
+                'ssl': False,
+                'ssl_keyfile': None,
+                'ssl_certfile': None,
+                'ssl_ca_certs': None,
+                'ssl_cert_reqs': 'required',
+                'sentinel_kwargs': {
+                    'ssl': False,
+                    'ssl_keyfile': None,
+                    'ssl_certfile': None,
+                    'ssl_ca_certs': None,
+                    'ssl_cert_reqs': 'required',
+                }
+            },
+            persistence=None
+        )
+
+    @mock.patch('octavia.controller.worker.v2.taskflow_jobboard_driver.'
+                'job_backends')
+    def test_job_board_sentinel_password(self, mock_job_backends):
+        driver = taskflow_jobboard_driver.RedisTaskFlowDriver(mock.Mock())
+        cfg.CONF.set_override('jobboard_redis_sentinel', 'mymaster',
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_hosts',
+                              ['host1', 'host2', 'host3'],
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_port', 26379,
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_password', 'redispass',
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_redis_sentinel_password',
+                              'sentinelpass', group='task_flow')
+        driver.job_board(None)
+        mock_job_backends.backend.assert_called_once_with(
+            'octavia_jobboard',
+            {
+                'board': 'redis',
+                'host': 'host1',
+                'port': 26379,
+                'namespace': 'octavia_jobboard',
+                'password': 'redispass',
+                'sentinel': 'mymaster',
+                'sentinel_fallbacks': ['host2:26379', 'host3:26379'],
+                'ssl': False,
+                'ssl_keyfile': None,
+                'ssl_certfile': None,
+                'ssl_ca_certs': None,
+                'ssl_cert_reqs': 'required',
+                'sentinel_kwargs': {
+                    'password': 'sentinelpass',
+                    'ssl': False,
+                    'ssl_keyfile': None,
+                    'ssl_certfile': None,
+                    'ssl_ca_certs': None,
+                    'ssl_cert_reqs': 'required',
+                }
+            },
+            persistence=None
+        )
+
+    @mock.patch('octavia.controller.worker.v2.taskflow_jobboard_driver.'
+                'job_backends')
+    def test_job_board_sentinel_username(self, mock_job_backends):
+        driver = taskflow_jobboard_driver.RedisTaskFlowDriver(mock.Mock())
+        cfg.CONF.set_override('jobboard_redis_sentinel', 'mymaster',
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_hosts',
+                              ['host1', 'host2', 'host3'],
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_port', 26379,
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_username', 'redisuser',
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_password', 'redispass',
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_redis_sentinel_username',
+                              'sentineluser', group='task_flow')
+        cfg.CONF.set_override('jobboard_redis_sentinel_password',
+                              'sentinelpass', group='task_flow')
+        driver.job_board(None)
+        mock_job_backends.backend.assert_called_once_with(
+            'octavia_jobboard',
+            {
+                'board': 'redis',
+                'host': 'host1',
+                'port': 26379,
+                'namespace': 'octavia_jobboard',
+                'username': 'redisuser',
+                'password': 'redispass',
+                'sentinel': 'mymaster',
+                'sentinel_fallbacks': ['host2:26379', 'host3:26379'],
+                'ssl': False,
+                'ssl_keyfile': None,
+                'ssl_certfile': None,
+                'ssl_ca_certs': None,
+                'ssl_cert_reqs': 'required',
+                'sentinel_kwargs': {
+                    'username': 'sentineluser',
+                    'password': 'sentinelpass',
+                    'ssl': False,
+                    'ssl_keyfile': None,
+                    'ssl_certfile': None,
+                    'ssl_ca_certs': None,
+                    'ssl_cert_reqs': 'required',
+                }
+            },
+            persistence=None
+        )
+
+    @mock.patch('octavia.controller.worker.v2.taskflow_jobboard_driver.'
+                'job_backends')
+    def test_job_board_sentinel_ssl(self, mock_job_backends):
+        driver = taskflow_jobboard_driver.RedisTaskFlowDriver(mock.Mock())
+        cfg.CONF.set_override('jobboard_redis_sentinel', 'mymaster',
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_hosts',
+                              ['host1', 'host2', 'host3'],
+                              group='task_flow')
+        cfg.CONF.set_override('jobboard_backend_port', 26379,
+                              group='task_flow')
+        cfg.CONF.set_override(
+            'jobboard_redis_backend_ssl_options',
+            {
+                'ssl': True,
+                'ssl_keyfile': 'rediskey',
+                'ssl_certfile': 'rediscert',
+                'ssl_ca_certs': 'redisca',
+                'ssl_cert_reqs': 'required'
+            },
+            group='task_flow')
+        cfg.CONF.set_override(
+            'jobboard_redis_sentinel_ssl_options',
+            {
+                'ssl': True,
+                'ssl_keyfile': 'sentinelkey',
+                'ssl_certfile': 'sentinelcert',
+                'ssl_ca_certs': 'sentinelca',
+                'ssl_cert_reqs': 'required'
+            },
+            group='task_flow')
+        driver.job_board(None)
+        mock_job_backends.backend.assert_called_once_with(
+            'octavia_jobboard',
+            {
+                'board': 'redis',
+                'host': 'host1',
+                'port': 26379,
+                'namespace': 'octavia_jobboard',
+                'sentinel': 'mymaster',
+                'sentinel_fallbacks': ['host2:26379', 'host3:26379'],
+                'ssl': True,
+                'ssl_keyfile': 'rediskey',
+                'ssl_certfile': 'rediscert',
+                'ssl_ca_certs': 'redisca',
+                'ssl_cert_reqs': 'required',
+                'sentinel_kwargs': {
+                    'ssl': True,
+                    'ssl_keyfile': 'sentinelkey',
+                    'ssl_certfile': 'sentinelcert',
+                    'ssl_ca_certs': 'sentinelca',
+                    'ssl_cert_reqs': 'required'
+                }
+            },
+            persistence=None
+        )