octavia 13.0.0__py3-none-any.whl → 13.0.1__py3-none-any.whl

octavia/tests/unit/controller/worker/test_task_utils.py

@@ -14,6 +14,7 @@
 from unittest import mock
 
 from oslo_utils import uuidutils
+import tenacity
 
 from octavia.common import constants
 from octavia.controller.worker import task_utils as task_utilities
@@ -183,7 +184,13 @@ class TestTaskUtils(base.TestCase):
 
     @mock.patch('octavia.db.api.session')
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.update')
+    @mock.patch('tenacity.nap.time')
+    # mock LOG so we don't fill the console with log messages from
+    # tenacity.retry
+    @mock.patch('octavia.controller.worker.task_utils.LOG')
     def test_mark_loadbalancer_prov_status_active(self,
+                                                  mock_LOG,
+                                                  mock_time,
                                                   mock_lb_repo_update,
                                                   mock_get_session):
 
@@ -202,14 +209,42 @@ class TestTaskUtils(base.TestCase):
         mock_lb_repo_update.reset_mock()
         mock_get_session.side_effect = Exception('fail')
 
-        self.task_utils.mark_loadbalancer_prov_status_active(
+        self.assertRaises(
+            tenacity.RetryError,
+            self.task_utils.mark_loadbalancer_prov_status_active,
             self.LOADBALANCER_ID)
 
         self.assertFalse(mock_lb_repo_update.called)
 
+        # Exceptions then happy path
+        mock_get_session.reset_mock(side_effect=True)
+        mock_lb_repo_update.reset_mock()
+
+        mock_session = mock_get_session()
+        mock_session_context = mock_session.begin().__enter__()
+        mock_get_session.side_effect = [
+            Exception('fail'),
+            Exception('fail'),
+            Exception('fail'),
+            mock_session]
+
+        self.task_utils.mark_loadbalancer_prov_status_active(
+            self.LOADBALANCER_ID)
+
+        mock_lb_repo_update.assert_called_once_with(
+            mock_session_context,
+            id=self.LOADBALANCER_ID,
+            provisioning_status=constants.ACTIVE)
+
     @mock.patch('octavia.db.api.session')
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.update')
+    @mock.patch('tenacity.nap.time')
+    # mock LOG so we don't fill the console with log messages from
+    # tenacity.retry
+    @mock.patch('octavia.controller.worker.task_utils.LOG')
     def test_mark_loadbalancer_prov_status_error(self,
+                                                 mock_LOG,
+                                                 mock_time,
                                                  mock_lb_repo_update,
                                                  mock_get_session):
 
@@ -228,10 +263,31 @@ class TestTaskUtils(base.TestCase):
         mock_lb_repo_update.reset_mock()
         mock_get_session.side_effect = Exception('fail')
 
+        self.assertRaises(tenacity.RetryError,
+                          self.task_utils.mark_loadbalancer_prov_status_error,
+                          self.LOADBALANCER_ID)
+
+        self.assertFalse(mock_lb_repo_update.called)
+
+        # Exceptions then happy path
+        mock_get_session.reset_mock(side_effect=True)
+        mock_lb_repo_update.reset_mock()
+
+        mock_session = mock_get_session()
+        mock_session_context = mock_session.begin().__enter__()
+        mock_get_session.side_effect = [
+            Exception('fail'),
+            Exception('fail'),
+            Exception('fail'),
+            mock_session]
+
         self.task_utils.mark_loadbalancer_prov_status_error(
             self.LOADBALANCER_ID)
 
-        self.assertFalse(mock_lb_repo_update.called)
+        mock_lb_repo_update.assert_called_once_with(
+            mock_session_context,
+            id=self.LOADBALANCER_ID,
+            provisioning_status=constants.ERROR)
 
     @mock.patch('octavia.db.api.session')
     @mock.patch('octavia.db.repositories.MemberRepository.update')

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

@@ -286,6 +286,7 @@ class TestAmphoraFlows(base.TestCase):
         self.assertIn(constants.AMPHORA, amp_flow.provides)
         self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
         self.assertIn(constants.AMPHORAE, amp_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, amp_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, amp_flow.provides)
         self.assertIn(constants.BASE_PORT, amp_flow.provides)
         self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@@ -296,7 +297,7 @@ class TestAmphoraFlows(base.TestCase):
         self.assertIn(constants.VIP_SG_ID, amp_flow.provides)
 
         self.assertEqual(8, len(amp_flow.requires))
-        self.assertEqual(13, len(amp_flow.provides))
+        self.assertEqual(14, len(amp_flow.provides))
 
     def test_get_failover_flow_standalone(self, mock_get_net_driver):
         failed_amphora = data_models.Amphora(
@@ -320,6 +321,7 @@ class TestAmphoraFlows(base.TestCase):
         self.assertIn(constants.AMPHORA, amp_flow.provides)
         self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
         self.assertIn(constants.AMPHORAE, amp_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, amp_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, amp_flow.provides)
         self.assertIn(constants.BASE_PORT, amp_flow.provides)
         self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@@ -330,7 +332,7 @@ class TestAmphoraFlows(base.TestCase):
         self.assertIn(constants.VIP_SG_ID, amp_flow.provides)
 
         self.assertEqual(8, len(amp_flow.requires))
-        self.assertEqual(12, len(amp_flow.provides))
+        self.assertEqual(13, len(amp_flow.provides))
 
     def test_get_failover_flow_bogus_role(self, mock_get_net_driver):
         failed_amphora = data_models.Amphora(id=uuidutils.generate_uuid(),
@@ -366,14 +368,33 @@ class TestAmphoraFlows(base.TestCase):
 
         self.assertIsInstance(vrrp_subflow, flow.Flow)
 
+        self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, vrrp_subflow.provides)
+        self.assertIn(constants.AMP_VRRP_INT, vrrp_subflow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, vrrp_subflow.provides)
+
+        self.assertIn(constants.LOADBALANCER_ID, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORAE, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORA_ID, vrrp_subflow.requires)
+
+        self.assertEqual(3, len(vrrp_subflow.provides))
+        self.assertEqual(3, len(vrrp_subflow.requires))
+
+    def test_get_vrrp_subflow_dont_get_status(self, mock_get_net_driver):
+        vrrp_subflow = self.AmpFlow.get_vrrp_subflow('123',
+                                                     get_amphorae_status=False)
+
+        self.assertIsInstance(vrrp_subflow, flow.Flow)
+
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, vrrp_subflow.provides)
         self.assertIn(constants.AMP_VRRP_INT, vrrp_subflow.provides)
 
         self.assertIn(constants.LOADBALANCER_ID, vrrp_subflow.requires)
         self.assertIn(constants.AMPHORAE, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORA_ID, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, vrrp_subflow.requires)
 
         self.assertEqual(2, len(vrrp_subflow.provides))
-        self.assertEqual(2, len(vrrp_subflow.requires))
+        self.assertEqual(4, len(vrrp_subflow.requires))
 
     def test_get_vrrp_subflow_dont_create_vrrp_group(
             self, mock_get_net_driver):
@@ -384,12 +405,14 @@ class TestAmphoraFlows(base.TestCase):
 
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, vrrp_subflow.provides)
         self.assertIn(constants.AMP_VRRP_INT, vrrp_subflow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, vrrp_subflow.provides)
 
         self.assertIn(constants.LOADBALANCER_ID, vrrp_subflow.requires)
         self.assertIn(constants.AMPHORAE, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORA_ID, vrrp_subflow.requires)
 
-        self.assertEqual(2, len(vrrp_subflow.provides))
-        self.assertEqual(2, len(vrrp_subflow.requires))
+        self.assertEqual(3, len(vrrp_subflow.provides))
+        self.assertEqual(3, len(vrrp_subflow.requires))
 
     def test_update_amphora_config_flow(self, mock_get_net_driver):
 

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

@@ -199,14 +199,16 @@ class TestLoadBalancerFlows(base.TestCase):
 
         self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
         self.assertIn(constants.UPDATE_DICT, amp_flow.requires)
+        self.assertIn(constants.AMPHORA_ID, amp_flow.requires)
 
         self.assertIn(constants.AMPHORAE, amp_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, amp_flow.provides)
         self.assertIn(constants.AMP_VRRP_INT, amp_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, amp_flow.provides)
         self.assertIn(constants.LOADBALANCER, amp_flow.provides)
 
-        self.assertEqual(2, len(amp_flow.requires), amp_flow.requires)
-        self.assertEqual(4, len(amp_flow.provides), amp_flow.provides)
+        self.assertEqual(3, len(amp_flow.requires), amp_flow.requires)
+        self.assertEqual(5, len(amp_flow.provides), amp_flow.provides)
 
         amp_flow = self.LBFlow.get_post_lb_amp_association_flow(
             '123', constants.TOPOLOGY_ACTIVE_STANDBY)
@@ -215,14 +217,16 @@ class TestLoadBalancerFlows(base.TestCase):
 
         self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
         self.assertIn(constants.UPDATE_DICT, amp_flow.requires)
+        self.assertIn(constants.AMPHORA_ID, amp_flow.requires)
 
         self.assertIn(constants.AMPHORAE, amp_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, amp_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, amp_flow.provides)
         self.assertIn(constants.AMP_VRRP_INT, amp_flow.provides)
         self.assertIn(constants.LOADBALANCER, amp_flow.provides)
 
-        self.assertEqual(2, len(amp_flow.requires), amp_flow.requires)
-        self.assertEqual(4, len(amp_flow.provides), amp_flow.provides)
+        self.assertEqual(3, len(amp_flow.requires), amp_flow.requires)
+        self.assertEqual(5, len(amp_flow.provides), amp_flow.provides)
 
     @mock.patch('octavia.common.rpc.NOTIFIER',
                 new_callable=MockNOTIFIER)
@@ -285,6 +289,7 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.AMPHORA_ID, create_flow.provides)
         self.assertIn(constants.AMPHORA_NETWORK_CONFIG, create_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, create_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, create_flow.provides)
         self.assertIn(constants.COMPUTE_ID, create_flow.provides)
         self.assertIn(constants.COMPUTE_OBJ, create_flow.provides)
         self.assertIn(constants.DELTAS, create_flow.provides)
@@ -296,7 +301,7 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.ADDITIONAL_VIPS, create_flow.provides)
 
         self.assertEqual(6, len(create_flow.requires), create_flow.requires)
-        self.assertEqual(17, len(create_flow.provides),
+        self.assertEqual(18, len(create_flow.provides),
                          create_flow.provides)
 
     def _test_get_failover_LB_flow_single(self, amphorae):

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

@@ -132,21 +132,54 @@ class TestAmphoraDriverTasks(base.TestCase):
 
         mock_amphora_repo_get.return_value = _db_amphora_mock
         mock_lb_get.return_value = _db_load_balancer_mock
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
+
         amp_list_update_obj = amphora_driver_tasks.AmphoraIndexListenerUpdate()
         amp_list_update_obj.execute(_LB_mock, 0, [_amphora_mock],
+                                    amphorae_status,
+                                    _amphora_mock[constants.ID],
                                     self.timeout_dict)
 
         mock_driver.update_amphora_listeners.assert_called_once_with(
             _db_load_balancer_mock, _db_amphora_mock, self.timeout_dict)
 
+        # Unreachable amp
+        mock_driver.reset_mock()
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        amp_list_update_obj.execute(_LB_mock, 0, [_amphora_mock],
+                                    amphorae_status,
+                                    _amphora_mock[constants.ID],
+                                    self.timeout_dict)
+        mock_driver.update_amphora_listeners.assert_not_called()
+
+        # Test exception
         mock_driver.update_amphora_listeners.side_effect = Exception('boom')
 
-        amp_list_update_obj.execute(_LB_mock, 0,
-                                    [_amphora_mock], self.timeout_dict)
+        amp_list_update_obj.execute(_LB_mock, 0, [_amphora_mock], {},
+                                    _amphora_mock[constants.ID],
+                                    self.timeout_dict)
 
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, AMP_ID, status=constants.ERROR)
 
+        # Test exception, secondary amp
+        mock_amphora_repo_update.reset_mock()
+        mock_driver.update_amphora_listeners.side_effect = Exception('boom')
+
+        amp_list_update_obj.execute(_LB_mock, 0, [_amphora_mock], {},
+                                    '1234',
+                                    self.timeout_dict)
+
+        mock_amphora_repo_update.assert_not_called()
+
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
     @mock.patch('octavia.db.api.session')
     def test_listeners_update(self,
@@ -198,39 +231,70 @@ class TestAmphoraDriverTasks(base.TestCase):
             mock_driver, mock_generate_uuid, mock_log, mock_get_session,
             mock_listener_repo_get, mock_listener_repo_update,
             mock_amphora_repo_get, mock_amphora_repo_update):
-        amphora_mock = mock.MagicMock()
         listeners_reload_obj = (
             amphora_driver_tasks.AmphoraIndexListenersReload())
         mock_lb = mock.MagicMock()
         mock_listener = mock.MagicMock()
         mock_listener.id = '12345'
-        mock_amphora_repo_get.return_value = amphora_mock
+        mock_amphora_repo_get.return_value = _amphora_mock
         mock_lb_repo_get.return_value = mock_lb
         mock_driver.reload.side_effect = [mock.DEFAULT, Exception('boom')]
 
         # Test no listeners
         mock_lb.listeners = None
-        listeners_reload_obj.execute(mock_lb, 0, None)
+        listeners_reload_obj.execute(mock_lb, 0, None, {},
+                                     _amphora_mock[constants.ID])
         mock_driver.reload.assert_not_called()
 
         # Test with listeners
-        mock_driver.start.reset_mock()
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
+        mock_driver.reload.reset_mock()
         mock_lb.listeners = [mock_listener]
-        listeners_reload_obj.execute(mock_lb, 0, [amphora_mock],
+        listeners_reload_obj.execute(mock_lb, 0, [_amphora_mock],
+                                     amphorae_status,
+                                     _amphora_mock[constants.ID],
                                      timeout_dict=self.timeout_dict)
-        mock_driver.reload.assert_called_once_with(mock_lb, amphora_mock,
+        mock_driver.reload.assert_called_once_with(mock_lb, _amphora_mock,
                                                    self.timeout_dict)
 
+        # Unreachable amp
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        mock_driver.reload.reset_mock()
+        listeners_reload_obj.execute(mock_lb, 0, [_amphora_mock],
+                                     amphorae_status,
+                                     _amphora_mock[constants.ID],
+                                     timeout_dict=self.timeout_dict)
+        mock_driver.reload.assert_not_called()
+
         # Test with reload exception
         mock_driver.reload.reset_mock()
-        listeners_reload_obj.execute(mock_lb, 0, [amphora_mock],
+        listeners_reload_obj.execute(mock_lb, 0, [_amphora_mock], {},
+                                     _amphora_mock[constants.ID],
                                      timeout_dict=self.timeout_dict)
-        mock_driver.reload.assert_called_once_with(mock_lb, amphora_mock,
+        mock_driver.reload.assert_called_once_with(mock_lb, _amphora_mock,
                                                    self.timeout_dict)
         mock_amphora_repo_update.assert_called_once_with(
-            _session_mock, amphora_mock[constants.ID],
+            _session_mock, _amphora_mock[constants.ID],
             status=constants.ERROR)
 
+        # Test with reload exception, secondary amp
+        mock_driver.reload.reset_mock()
+        mock_amphora_repo_update.reset_mock()
+        listeners_reload_obj.execute(mock_lb, 0, [_amphora_mock], {},
+                                     '1234',
+                                     timeout_dict=self.timeout_dict)
+        mock_driver.reload.assert_called_once_with(mock_lb, _amphora_mock,
+                                                   self.timeout_dict)
+        mock_amphora_repo_update.assert_not_called()
+
     @mock.patch('octavia.controller.worker.task_utils.TaskUtils.'
                 'mark_listener_prov_status_error')
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
@@ -827,6 +891,11 @@ class TestAmphoraDriverTasks(base.TestCase):
         FAKE_INTERFACE = 'fake0'
         mock_driver.get_interface_from_ip.side_effect = [FAKE_INTERFACE,
                                                          Exception('boom')]
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
 
         timeout_dict = {constants.CONN_MAX_RETRIES: CONN_MAX_RETRIES,
                         constants.CONN_RETRY_INTERVAL: CONN_RETRY_INTERVAL}
@@ -834,20 +903,39 @@ class TestAmphoraDriverTasks(base.TestCase):
         amphora_update_vrrp_interface_obj = (
             amphora_driver_tasks.AmphoraIndexUpdateVRRPInterface())
         amphora_update_vrrp_interface_obj.execute(
-            0, [_amphora_mock], timeout_dict)
+            0, [_amphora_mock], amphorae_status, _amphora_mock[constants.ID],
+            timeout_dict)
         mock_driver.get_interface_from_ip.assert_called_once_with(
             _db_amphora_mock, _db_amphora_mock.vrrp_ip,
             timeout_dict=timeout_dict)
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, _db_amphora_mock.id, vrrp_interface=FAKE_INTERFACE)
 
+        # Unreachable amp
+        mock_driver.reset_mock()
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        amphora_update_vrrp_interface_obj.execute(
+            0, [_amphora_mock], amphorae_status, _amphora_mock[constants.ID],
+            timeout_dict)
+        mock_driver.get_interface_from_ip.assert_not_called()
+
         # Test with an exception
         mock_amphora_repo_update.reset_mock()
         amphora_update_vrrp_interface_obj.execute(
-            0, [_amphora_mock], timeout_dict)
+            0, [_amphora_mock], {}, _amphora_mock[constants.ID], timeout_dict)
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, _db_amphora_mock.id, status=constants.ERROR)
 
+        # Test with an exception, secondary amp
+        mock_amphora_repo_update.reset_mock()
+        amphora_update_vrrp_interface_obj.execute(
+            0, [_amphora_mock], {}, '1234', timeout_dict)
+        mock_amphora_repo_update.assert_not_called()
+
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
     def test_amphora_vrrp_update(self,
                                  mock_lb_get,
@@ -895,23 +983,52 @@ class TestAmphoraDriverTasks(base.TestCase):
                                                     Exception('boom')]
         mock_lb_get.return_value = _db_load_balancer_mock
         mock_amphora_repo_get.return_value = _db_amphora_mock
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
+
         amphora_vrrp_update_obj = (
             amphora_driver_tasks.AmphoraIndexVRRPUpdate())
 
         amphora_vrrp_update_obj.execute(LB_ID, amphorae_network_config,
-                                        0, [_amphora_mock], 'fakeint0',
+                                        0, [_amphora_mock], amphorae_status,
+                                        'fakeint0',
+                                        _amphora_mock[constants.ID],
                                         timeout_dict=self.timeout_dict)
         mock_driver.update_vrrp_conf.assert_called_once_with(
             _db_load_balancer_mock, amphorae_network_config, _db_amphora_mock,
             self.timeout_dict)
 
+        # Unreachable amp
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        mock_amphora_repo_update.reset_mock()
+        mock_driver.update_vrrp_conf.reset_mock()
+        amphora_vrrp_update_obj.execute(LB_ID, amphorae_network_config,
+                                        0, [_amphora_mock], amphorae_status,
+                                        None, _amphora_mock[constants.ID])
+        mock_driver.update_vrrp_conf.assert_not_called()
+
         # Test with an exception
         mock_amphora_repo_update.reset_mock()
         amphora_vrrp_update_obj.execute(LB_ID, amphorae_network_config,
-                                        0, [_amphora_mock], 'fakeint0')
+                                        0, [_amphora_mock], {}, 'fakeint0',
+                                        _amphora_mock[constants.ID])
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, _db_amphora_mock.id, status=constants.ERROR)
 
+        # Test with an exception, secondary amp
+        mock_amphora_repo_update.reset_mock()
+        amphora_vrrp_update_obj.execute(LB_ID, amphorae_network_config,
+                                        0, [_amphora_mock], {}, 'fakeint0',
+                                        '1234')
+        mock_amphora_repo_update.assert_not_called()
+
     def test_amphora_vrrp_start(self,
                                 mock_driver,
                                 mock_generate_uuid,
@@ -939,25 +1056,54 @@ class TestAmphoraDriverTasks(base.TestCase):
                                       mock_amphora_repo_get,
                                       mock_amphora_repo_update):
         mock_amphora_repo_get.return_value = _db_amphora_mock
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
+
         amphora_vrrp_start_obj = (
             amphora_driver_tasks.AmphoraIndexVRRPStart())
         mock_driver.start_vrrp_service.side_effect = [mock.DEFAULT,
                                                       Exception('boom')]
 
-        amphora_vrrp_start_obj.execute(0, [_amphora_mock],
+        amphora_vrrp_start_obj.execute(0, [_amphora_mock], amphorae_status,
+                                       _amphora_mock[constants.ID],
                                        timeout_dict=self.timeout_dict)
         mock_driver.start_vrrp_service.assert_called_once_with(
             _db_amphora_mock, self.timeout_dict)
 
+        # Unreachable amp
+        mock_driver.start_vrrp_service.reset_mock()
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        amphora_vrrp_start_obj.execute(0, [_amphora_mock], amphorae_status,
+                                       _amphora_mock[constants.ID],
+                                       timeout_dict=self.timeout_dict)
+        mock_driver.start_vrrp_service.assert_not_called()
+
         # Test with a start exception
         mock_driver.start_vrrp_service.reset_mock()
-        amphora_vrrp_start_obj.execute(0, [_amphora_mock],
+        amphora_vrrp_start_obj.execute(0, [_amphora_mock], {},
+                                       _amphora_mock[constants.ID],
                                        timeout_dict=self.timeout_dict)
         mock_driver.start_vrrp_service.assert_called_once_with(
             _db_amphora_mock, self.timeout_dict)
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, _db_amphora_mock.id, status=constants.ERROR)
 
+        # Test with a start exception, secondary amp
+        mock_driver.start_vrrp_service.reset_mock()
+        mock_amphora_repo_update.reset_mock()
+        amphora_vrrp_start_obj.execute(0, [_amphora_mock], {}, '1234',
+                                       timeout_dict=self.timeout_dict)
+        mock_driver.start_vrrp_service.assert_called_once_with(
+            _db_amphora_mock, self.timeout_dict)
+        mock_amphora_repo_update.assert_not_called()
+
     def test_amphora_compute_connectivity_wait(self,
                                                mock_driver,
                                                mock_generate_uuid,
@@ -1029,3 +1175,74 @@ class TestAmphoraDriverTasks(base.TestCase):
         self.assertRaises(driver_except.TimeOutException,
                           amp_config_update_obj.execute,
                           _amphora_mock, flavor)
+
+    def test_amphorae_get_connectivity_status(self,
+                                              mock_driver,
+                                              mock_generate_uuid,
+                                              mock_log,
+                                              mock_get_session,
+                                              mock_listener_repo_get,
+                                              mock_listener_repo_update,
+                                              mock_amphora_repo_get,
+                                              mock_amphora_repo_update):
+        amphora1_mock = mock.MagicMock()
+        amphora1_mock[constants.ID] = 'id1'
+        amphora2_mock = mock.MagicMock()
+        amphora2_mock[constants.ID] = 'id2'
+        db_amphora1_mock = mock.Mock()
+        db_amphora2_mock = mock.Mock()
+
+        amp_get_connectivity_status = (
+            amphora_driver_tasks.AmphoraeGetConnectivityStatus())
+
+        # All amphorae reachable
+        mock_amphora_repo_get.side_effect = [
+            db_amphora1_mock,
+            db_amphora2_mock]
+        mock_driver.check.return_value = None
+
+        ret = amp_get_connectivity_status.execute(
+            [amphora1_mock, amphora2_mock],
+            amphora1_mock[constants.ID],
+            timeout_dict=self.timeout_dict)
+        mock_driver.check.assert_has_calls(
+            [mock.call(db_amphora1_mock, timeout_dict=self.timeout_dict),
+             mock.call(db_amphora2_mock, timeout_dict=self.timeout_dict)])
+        self.assertFalse(
+            ret[amphora1_mock[constants.ID]][constants.UNREACHABLE])
+        self.assertFalse(
+            ret[amphora2_mock[constants.ID]][constants.UNREACHABLE])
+
+        # amphora1 unreachable
+        mock_driver.check.reset_mock()
+        mock_amphora_repo_get.side_effect = [
+            db_amphora1_mock,
+            db_amphora2_mock]
+        mock_driver.check.side_effect = [
+            driver_except.TimeOutException, None]
+        self.assertRaises(driver_except.TimeOutException,
+                          amp_get_connectivity_status.execute,
+                          [amphora1_mock, amphora2_mock],
+                          amphora1_mock[constants.ID],
+                          timeout_dict=self.timeout_dict)
+        mock_driver.check.assert_called_with(
+            db_amphora1_mock, timeout_dict=self.timeout_dict)
+
+        # amphora2 unreachable
+        mock_driver.check.reset_mock()
+        mock_amphora_repo_get.side_effect = [
+            db_amphora1_mock,
+            db_amphora2_mock]
+        mock_driver.check.side_effect = [
+            None, driver_except.TimeOutException]
+        ret = amp_get_connectivity_status.execute(
+            [amphora1_mock, amphora2_mock],
+            amphora1_mock[constants.ID],
+            timeout_dict=self.timeout_dict)
+        mock_driver.check.assert_has_calls(
+            [mock.call(db_amphora1_mock, timeout_dict=self.timeout_dict),
+             mock.call(db_amphora2_mock, timeout_dict=self.timeout_dict)])
+        self.assertFalse(
+            ret[amphora1_mock[constants.ID]][constants.UNREACHABLE])
+        self.assertTrue(
+            ret[amphora2_mock[constants.ID]][constants.UNREACHABLE])

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

@@ -181,7 +181,9 @@ class TestDatabaseTasks(base.TestCase):
 
     @mock.patch('octavia.db.repositories.AmphoraRepository.create',
                 return_value=_db_amphora_mock)
+    @mock.patch('octavia.db.repositories.AmphoraHealthRepository.delete')
     def test_create_amphora_in_db(self,
+                                  mock_amphora_health_repo_delete,
                                   mock_create,
                                   mock_generate_uuid,
                                   mock_LOG,
@@ -207,23 +209,43 @@ class TestDatabaseTasks(base.TestCase):
 
         # Test the revert
         create_amp_in_db.revert(_tf_failure_mock)
-        self.assertFalse(mock_amphora_repo_delete.called)
+        mock_amphora_repo_delete.assert_not_called()
+        mock_amphora_health_repo_delete.assert_not_called()
 
+        amp_id = 'AMP'
         mock_amphora_repo_delete.reset_mock()
-        create_amp_in_db.revert(result='AMP')
+        mock_amphora_health_repo_delete.reset_mock()
+        create_amp_in_db.revert(result=amp_id)
         self.assertTrue(mock_amphora_repo_delete.called)
+        self.assertTrue(mock_amphora_health_repo_delete.called)
         mock_amphora_repo_delete.assert_called_once_with(
             mock_session,
-            id='AMP')
+            id=amp_id)
+        mock_amphora_health_repo_delete.assert_called_once_with(
+            mock_session,
+            amphora_id=amp_id)
+        mock_LOG.error.assert_not_called()
+        mock_LOG.debug.assert_not_called()
 
         # Test revert with exception
         mock_amphora_repo_delete.reset_mock()
-        mock_amphora_repo_delete.side_effect = Exception('fail')
-        create_amp_in_db.revert(result='AMP')
+        mock_amphora_health_repo_delete.reset_mock()
+        err1_msg, err2_msg = ('fail', 'fail2')
+        mock_amphora_repo_delete.side_effect = Exception(err1_msg)
+        mock_amphora_health_repo_delete.side_effect = Exception(err2_msg)
+        create_amp_in_db.revert(result=amp_id)
         self.assertTrue(mock_amphora_repo_delete.called)
+        self.assertTrue(mock_amphora_health_repo_delete.called)
         mock_amphora_repo_delete.assert_called_once_with(
             mock_session,
-            id='AMP')
+            id=amp_id)
+        mock_amphora_health_repo_delete.assert_called_once_with(
+            mock_session,
+            amphora_id=amp_id)
+        mock_LOG.error.assert_called_once_with(
+            "Failed to delete amphora %(amp)s "
+            "in the database due to: "
+            "%(except)s", {'amp': amp_id, 'except': err1_msg})
 
     @mock.patch('octavia.db.repositories.ListenerRepository.delete')
     def test_delete_listener_in_db(self,