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

octavia/tests/unit/api/drivers/test_utils.py

@@ -16,6 +16,7 @@ from unittest import mock
 
 from octavia_lib.api.drivers import data_models as driver_dm
 from octavia_lib.api.drivers import exceptions as lib_exceptions
+from oslo_utils import uuidutils
 
 from octavia.api.drivers import utils
 from octavia.common import constants
@@ -109,6 +110,7 @@ class TestUtils(base.TestCase):
                                       listener_certs, listener_certs,
                                       listener_certs]
         mock_get_flavor.return_value = {'shaved_ice': 'cherry'}
+        sg_id = uuidutils.generate_uuid()
         test_lb_dict = {'name': 'lb1',
                         'project_id': self.sample_data.project_id,
                         'vip_subnet_id': self.sample_data.subnet_id,
@@ -116,6 +118,7 @@ class TestUtils(base.TestCase):
                         'vip_address': self.sample_data.ip_address,
                         'vip_network_id': self.sample_data.network_id,
                         'vip_qos_policy_id': self.sample_data.qos_policy_id,
+                        'vip_sg_ids': [sg_id],
                         'id': self.sample_data.lb_id,
                         'listeners': [],
                         'pools': [],
@@ -136,6 +139,7 @@ class TestUtils(base.TestCase):
             'vip_port_id': self.sample_data.port_id,
             'vip_qos_policy_id': self.sample_data.qos_policy_id,
             'vip_network_id': self.sample_data.network_id,
+            'vip_sg_ids': [sg_id],
             'pools': self.sample_data.provider_pools,
             'flavor': {'shaved_ice': 'cherry'},
             'name': 'lb1'}
@@ -143,7 +147,8 @@ class TestUtils(base.TestCase):
                               network_id=self.sample_data.network_id,
                               port_id=self.sample_data.port_id,
                               subnet_id=self.sample_data.subnet_id,
-                              qos_policy_id=self.sample_data.qos_policy_id)
+                              qos_policy_id=self.sample_data.qos_policy_id,
+                              sg_ids=[sg_id])
 
         provider_lb_dict = utils.lb_dict_to_provider_dict(
             test_lb_dict, vip=vip, db_pools=self.sample_data.test_db_pools,

octavia/tests/unit/certificates/generator/test_local.py

@@ -158,7 +158,7 @@ class TestLocalGenerator(local_csr.BaseLocalCSRTestCase):
 
     def test_generate_cert_key_pair(self):
         cn = 'testCN'
-        bit_length = 512
+        bit_length = 1024
 
         # Attempt to generate a cert/key pair
         cert_object = self.cert_generator.generate_cert_key_pair(

octavia/tests/unit/common/test_base_taskflow.py

@@ -130,12 +130,13 @@ class TestTaskFlowServiceController(base.TestCase):
         job1.wait.assert_called_once()
         job2.wait.assert_called_once()
 
-    @mock.patch('octavia.common.base_taskflow.RedisDynamicLoggingConductor')
+    @mock.patch('octavia.common.base_taskflow.'
+                'ExtendExpiryDynamicLoggingConductor')
     @mock.patch('octavia.common.base_taskflow.DynamicLoggingConductor')
     @mock.patch('concurrent.futures.ThreadPoolExecutor')
-    def test_run_conductor(self, mock_threadpoolexec, dynamiccond, rediscond):
+    def test_run_conductor(self, mock_threadpoolexec, dynamiccond, expirycond):
         self.service_controller.run_conductor("test")
-        rediscond.assert_called_once_with(
+        expirycond.assert_called_once_with(
             "test", self.jobboard_mock.__enter__(),
             persistence=self.persistence_mock.__enter__(),
             engine='parallel',

octavia/tests/unit/compute/drivers/noop_driver/test_driver.py

@@ -11,6 +11,7 @@
 # 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_utils import uuidutils
 
@@ -28,7 +29,14 @@ class TestNoopComputeDriver(base.TestCase):
 
     def setUp(self):
         super().setUp()
-        self.driver = driver.NoopComputeDriver()
+        self.mock_engine = mock.MagicMock()
+        with mock.patch('octavia.compute.drivers.noop_driver.driver.'
+                        'create_engine') as mock_create_engine:
+            mock_create_engine.return_value = self.mock_engine
+            self.driver = driver.NoopComputeDriver()
+            mock_create_engine.assert_called_once_with(
+                'sqlite:////tmp/octavia-network-noop.db',
+                isolation_level='SERIALIZABLE')
 
         self.name = "amphora_name"
         self.amphora_flavor = "m1.tiny"
@@ -107,7 +115,15 @@ class TestNoopComputeDriver(base.TestCase):
                          self.driver.driver.computeconfig[
                              self.server_group_id])
 
-    def test_attach_network_or_port(self):
+    @mock.patch('octavia.compute.drivers.noop_driver.driver.update')
+    def test_attach_network_or_port(self, mock_update):
+        update_mock = mock.MagicMock()
+        mock_update.return_value = update_mock
+        connect_mock = mock.MagicMock()
+        connection_mock = mock.MagicMock()
+        self.mock_engine.connect.return_value = connect_mock
+        connect_mock.__enter__.return_value = connection_mock
+
         self.driver.attach_network_or_port(self.amphora_id, self.network_id,
                                            self.ip_address, self.port_id)
         self.assertEqual((self.amphora_id, self.network_id, self.ip_address,
@@ -116,6 +132,16 @@ class TestNoopComputeDriver(base.TestCase):
                              self.amphora_id, self.network_id,
                              self.ip_address, self.port_id)])
 
+        self.mock_engine.connect.assert_called_once()
+        interfaces_table = self.driver.driver.interfaces_table
+        connection_mock.assert_has_calls([
+            mock.call.execute(
+                update_mock.where(
+                    interfaces_table.c.port_id == self.port_id).values(
+                        compute_id=self.amphora_id)),
+            mock.call.commit()])
+        connect_mock.__enter__.assert_called_once()
+
     def test_detach_port(self):
         self.driver.detach_port(self.amphora_id, self.port_id)
         self.assertEqual((self.amphora_id, self.port_id,

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

@@ -18,6 +18,7 @@ from oslo_config import cfg
 from oslo_config import fixture as oslo_fixture
 from oslo_utils import uuidutils
 from taskflow.patterns import linear_flow as flow
+from taskflow.patterns import unordered_flow
 
 from octavia.common import constants
 from octavia.common import exceptions
@@ -197,8 +198,9 @@ class TestLoadBalancerFlows(base.TestCase):
 
         self.assertIn(constants.LOADBALANCER, lb_flow.requires)
         self.assertIn(constants.UPDATE_DICT, lb_flow.requires)
+        self.assertIn(constants.VIP_SG_ID, lb_flow.provides)
 
-        self.assertEqual(0, len(lb_flow.provides))
+        self.assertEqual(1, len(lb_flow.provides))
         self.assertEqual(3, len(lb_flow.requires))
 
     @mock.patch('octavia.common.rpc.NOTIFIER',
@@ -543,3 +545,27 @@ class TestLoadBalancerFlows(base.TestCase):
 
         self._test_get_failover_LB_flow_no_amps_act_stdby([amphora_dict,
                                                            amphora2_dict])
+
+    @mock.patch('octavia.db.repositories.AmphoraMemberPortRepository.'
+                'get_port_ids')
+    @mock.patch('octavia.db.repositories.AmphoraRepository.'
+                'get_amphorae_ids_on_lb')
+    @mock.patch('octavia.db.api.get_session', return_value=mock.MagicMock())
+    def test_get_delete_member_ports_subflow(self,
+                                             mock_session,
+                                             mock_amps_on_lb,
+                                             mock_get_port_ids,
+                                             mock_get_net_driver):
+        lb_id = uuidutils.generate_uuid()
+        amps = ['fake_amp1', 'fake_amp2']
+        port1 = uuidutils.generate_uuid()
+        port2 = uuidutils.generate_uuid()
+        ports = [port1, port2]
+
+        mock_amps_on_lb.return_value = amps
+        mock_get_port_ids.return_value = ports
+
+        delete_flow = self.LBFlow.get_delete_member_ports_subflow(lb_id)
+
+        self.assertIsInstance(delete_flow, unordered_flow.Flow)
+        self.assertEqual(8, len(delete_flow))

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

@@ -184,7 +184,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,
@@ -210,23 +212,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,

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

@@ -334,6 +334,7 @@ class TestNetworkTasks(base.TestCase):
         mock_driver.reset_mock()
         member_mock = mock.MagicMock()
         member_mock.subnet_id = member_private_subnet.id
+        member_mock.vnic_type = constants.VNIC_TYPE_NORMAL
         member2_mock = mock.MagicMock()
         member2_mock.subnet_id = member_private_subnet2.id
         pool_mock.members = [member_mock]
@@ -351,7 +352,8 @@ class TestNetworkTasks(base.TestCase):
                     network_id=3,
                     fixed_ips=[
                         data_models.FixedIP(
-                            subnet_id=member_private_subnet.id)])],
+                            subnet_id=member_private_subnet.id)],
+                    vnic_type=constants.VNIC_TYPE_NORMAL)],
             delete_nics=[],
             add_subnets=[{
                 'subnet_id': member_private_subnet.id,
@@ -431,6 +433,7 @@ class TestNetworkTasks(base.TestCase):
         mock_driver.reset_mock()
         member_mock = mock.MagicMock()
         member_mock.subnet_id = member_private_subnet.id
+        member_mock.vnic_type = constants.VNIC_TYPE_NORMAL
         pool_mock.members = [member_mock]
         az = {
             constants.COMPUTE_ZONE: 'foo'
@@ -451,7 +454,8 @@ class TestNetworkTasks(base.TestCase):
             add_nics=[data_models.Interface(
                 network_id=member_private_net.id,
                 fixed_ips=[data_models.FixedIP(
-                    subnet_id=member_private_subnet.id)])],
+                    subnet_id=member_private_subnet.id)],
+                vnic_type=constants.VNIC_TYPE_NORMAL)],
             delete_nics=[data_models.Interface(network_id='bad_net')],
             add_subnets=[{
                 'subnet_id': member_private_subnet.id,
@@ -611,63 +615,6 @@ class TestNetworkTasks(base.TestCase):
         mock_driver.get_plugged_networks.assert_called_once_with(
             COMPUTE_ID)
 
-    def test_plug_networks(self, mock_get_net_driver):
-        mock_driver = mock.MagicMock()
-        mock_get_net_driver.return_value = mock_driver
-
-        def _interface(network_id):
-            return [data_models.Interface(network_id=network_id)]
-
-        net = network_tasks.PlugNetworks()
-
-        net.execute(self.amphora_mock, None)
-        self.assertFalse(mock_driver.plug_network.called)
-
-        delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
-                                  compute_id=self.db_amphora_mock.compute_id,
-                                  add_nics=[],
-                                  delete_nics=[]).to_dict(recurse=True)
-        net.execute(self.amphora_mock, delta)
-        self.assertFalse(mock_driver.plug_network.called)
-
-        delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
-                                  compute_id=self.db_amphora_mock.compute_id,
-                                  add_nics=_interface(1),
-                                  delete_nics=[]).to_dict(recurse=True)
-        net.execute(self.amphora_mock, delta)
-        mock_driver.plug_network.assert_called_once_with(COMPUTE_ID, 1)
-
-        # revert
-        net.revert(self.amphora_mock, None)
-        self.assertFalse(mock_driver.unplug_network.called)
-
-        delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
-                                  compute_id=self.db_amphora_mock.compute_id,
-                                  add_nics=[],
-                                  delete_nics=[]).to_dict(recurse=True)
-        net.revert(self.amphora_mock, delta)
-        self.assertFalse(mock_driver.unplug_network.called)
-
-        delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
-                                  compute_id=self.db_amphora_mock.compute_id,
-                                  add_nics=_interface(1),
-                                  delete_nics=[]).to_dict(recurse=True)
-        net.revert(self.amphora_mock, delta)
-        mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
-
-        mock_driver.reset_mock()
-        mock_driver.unplug_network.side_effect = net_base.NetworkNotFound
-        net.revert(self.amphora_mock, delta)  # No exception
-        mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
-
-        mock_driver.reset_mock()
-        mock_driver.unplug_network.side_effect = TestException('test')
-        self.assertRaises(TestException,
-                          net.revert,
-                          self.amphora_mock,
-                          delta)
-        mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
-
     def test_unplug_networks(self, mock_get_net_driver):
         mock_driver = mock.MagicMock()
         mock_get_net_driver.return_value = mock_driver
@@ -755,6 +702,7 @@ class TestNetworkTasks(base.TestCase):
         nic1.fixed_ips = [data_models.FixedIP(
             subnet_id=uuidutils.generate_uuid())]
         nic1.network_id = uuidutils.generate_uuid()
+        nic1.nic_type = constants.VNIC_TYPE_NORMAL
         nic2 = data_models.Interface()
         nic2.fixed_ips = [data_models.FixedIP(
             subnet_id=uuidutils.generate_uuid())]
@@ -779,8 +727,18 @@ class TestNetworkTasks(base.TestCase):
                                   delete_subnets=[]
                                   ).to_dict(recurse=True)
 
-        mock_net_driver.plug_network.return_value = interface1
-        mock_net_driver.get_port.return_value = port1
+        mock_net_driver.plug_port.side_effect = [
+            interface1,
+            exceptions.NotFound(resource='Instance', id='1'),
+            exceptions.NotFound(resource='Boom', id='1'),
+            Exception("boom")]
+        mock_net_driver.create_port.side_effect = [
+            port1,
+            port1,
+            exceptions.NotFound(resource='Network', id='1'),
+            port1,
+            port1]
+
         fixed_port1 = mock.MagicMock()
         fixed_port1.network_id = port1.network_id
         fixed_port1.fixed_ips = [fixed_ip]
@@ -795,20 +753,34 @@ class TestNetworkTasks(base.TestCase):
         result = handle_net_delta_obj.execute(self.amphora_mock,
                                               delta)
 
-        mock_net_driver.plug_network.assert_called_once_with(
-            self.db_amphora_mock.compute_id, nic1.network_id)
-        mock_net_driver.unplug_fixed_ip.assert_called_once_with(
-            port_id=interface1.port_id, subnet_id=fixed_ip2.subnet_id)
-        mock_net_driver.get_port.assert_called_once_with(interface1.port_id)
+        mock_net_driver.plug_port.assert_called_once_with(
+            self.db_amphora_mock, port1)
         mock_net_driver.get_network.assert_called_once_with(port1.network_id)
-        mock_net_driver.get_subnet.assert_called_once_with(fixed_ip.subnet_id)
+        mock_net_driver.get_subnet.assert_has_calls(
+            [mock.call(fixed_ip.subnet_id), mock.call(fixed_ip2.subnet_id)])
 
-        self.assertEqual({self.db_amphora_mock.id: [fixed_port1.to_dict()]},
+        self.assertEqual({self.db_amphora_mock.id: [port1.to_dict()]},
                          result)
 
         mock_net_driver.unplug_network.assert_called_with(
             self.db_amphora_mock.compute_id, nic2.network_id)
 
+        self.assertRaises(net_base.AmphoraNotFound,
+                          handle_net_delta_obj.execute, self.amphora_mock,
+                          delta)
+
+        self.assertRaises(net_base.NetworkNotFound,
+                          handle_net_delta_obj.execute, self.amphora_mock,
+                          delta)
+
+        self.assertRaises(net_base.PlugNetworkException,
+                          handle_net_delta_obj.execute, self.amphora_mock,
+                          delta)
+
+        self.assertRaises(net_base.PlugNetworkException,
+                          handle_net_delta_obj.execute, self.amphora_mock,
+                          delta)
+
         # Revert
         delta2 = data_models.Delta(amphora_id=self.db_amphora_mock.id,
                                    compute_id=self.db_amphora_mock.compute_id,
@@ -857,12 +829,13 @@ class TestNetworkTasks(base.TestCase):
                 port_id=port_id,
                 fixed_ips=[
                     data_models.FixedIP(
-                        subnet_id=subnet_id)])
+                        subnet_id=subnet_id)],
+                vnic_type=constants.VNIC_TYPE_NORMAL)
 
         net = network_tasks.HandleNetworkDeltas()
 
         net.execute({}, self.load_balancer_mock)
-        self.assertFalse(mock_driver.plug_network.called)
+        self.assertFalse(mock_driver.create_port.called)
 
         delta = data_models.Delta(amphora_id=self.db_amphora_mock.id,
                                   compute_id=self.db_amphora_mock.compute_id,
@@ -871,7 +844,7 @@ class TestNetworkTasks(base.TestCase):
                                   add_subnets=[],
                                   delete_subnets=[]).to_dict(recurse=True)
         net.execute({self.db_amphora_mock.id: delta}, self.load_balancer_mock)
-        self.assertFalse(mock_driver.plug_network.called)
+        self.assertFalse(mock_driver.create_port.called)
 
         # Adding a subnet on a new network
         port = data_models.Port(
@@ -879,7 +852,7 @@ class TestNetworkTasks(base.TestCase):
             network_id=network1,
             fixed_ips=[
                 data_models.FixedIP(subnet_id=subnet1)])
-        mock_driver.get_port.return_value = port
+        mock_driver.create_port.return_value = port
         mock_driver.plug_fixed_ip.return_value = port
         mock_driver.get_network.return_value = data_models.Network(
             id=network1)
@@ -900,8 +873,8 @@ class TestNetworkTasks(base.TestCase):
                                   delete_subnets=[]).to_dict(recurse=True)
         updated_ports = net.execute({self.db_amphora_mock.id: delta},
                                     self.load_balancer_mock)
-        mock_driver.plug_network.assert_called_once_with(
-            self.db_amphora_mock.compute_id, network1)
+        mock_driver.plug_port.assert_called_once_with(
+            self.db_amphora_mock, port)
         mock_driver.unplug_network.assert_not_called()
 
         self.assertEqual(1, len(updated_ports))
@@ -949,7 +922,6 @@ class TestNetworkTasks(base.TestCase):
                                   delete_subnets=[]).to_dict(recurse=True)
         updated_ports = net.execute({self.db_amphora_mock.id: delta},
                                     self.load_balancer_mock)
-        mock_driver.plug_network.assert_not_called()
         mock_driver.unplug_network.assert_not_called()
         mock_driver.get_port.assert_not_called()
         mock_driver.plug_fixed_ip.assert_called_once_with(port_id=port1,
@@ -989,7 +961,6 @@ class TestNetworkTasks(base.TestCase):
         updated_ports = net.execute({self.db_amphora_mock.id: delta},
                                     self.load_balancer_mock)
         mock_driver.delete_port.assert_not_called()
-        mock_driver.plug_network.assert_not_called()
         mock_driver.plug_fixed_ip.assert_not_called()
         mock_driver.unplug_fixed_ip.assert_called_once_with(
             port_id=port1, subnet_id=subnet1)
@@ -1014,7 +985,6 @@ class TestNetworkTasks(base.TestCase):
         net.execute({self.db_amphora_mock.id: delta},
                     self.load_balancer_mock)
         mock_driver.delete_port.assert_not_called()
-        mock_driver.plug_network.assert_not_called()
         mock_driver.plug_fixed_ip.assert_not_called()
         mock_driver.unplug_fixed_ip.assert_not_called()
 
@@ -1043,7 +1013,6 @@ class TestNetworkTasks(base.TestCase):
         updated_ports = net.execute({self.db_amphora_mock.id: delta},
                                     self.load_balancer_mock)
         mock_driver.delete_port.assert_called_once_with(port1)
-        mock_driver.plug_network.assert_not_called()
         mock_driver.plug_fixed_ip.assert_not_called()
         self.assertEqual(1, len(updated_ports))
         self.assertEqual(0, len(updated_ports[self.db_amphora_mock.id]))
@@ -1526,6 +1495,57 @@ class TestNetworkTasks(base.TestCase):
         mock_driver.unplug_aap_port.assert_called_once_with(
             LB.vip, self.db_amphora_mock, mockSubnet)
 
+    @mock.patch('octavia.db.repositories.AmphoraRepository.get')
+    @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
+    @mock.patch('octavia.db.api.get_session', return_value=_session_mock)
+    def test_revert_plug_vip_amphora_subnet_not_found(
+            self, mock_session, mock_lb_get, mock_get, mock_get_net_driver):
+        mock_driver = mock.MagicMock()
+        mock_lb_get.return_value = LB
+        mock_get.return_value = self.db_amphora_mock
+        mock_get_net_driver.return_value = mock_driver
+        net = network_tasks.PlugVIPAmphora()
+        amphora = {constants.ID: AMPHORA_ID,
+                   constants.LB_NETWORK_IP: IP_ADDRESS}
+        subnet = {constants.ID: SUBNET_ID}
+        err_msg = 'Subnet not found'
+        mock_driver.get_subnet.side_effect = net_base.SubnetNotFound(err_msg)
+        result = AMPS_DATA[0].to_dict()
+        net.revert(result, self.load_balancer_mock, amphora, subnet)
+        mock_driver.unplug_aap_port.assert_not_called()
+        network_tasks.LOG.error.assert_called_once_with(
+            'Failed to unplug AAP port for load balancer: %s. '
+            'Resources may still be in use for VRRP port: %s. '
+            'Due to error: %s',
+            self.load_balancer_mock[constants.LOADBALANCER_ID],
+            result[constants.VRRP_PORT_ID], err_msg
+        )
+
+    @mock.patch('octavia.db.repositories.AmphoraRepository.get')
+    @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
+    @mock.patch('octavia.db.api.get_session', return_value=_session_mock)
+    def test_revert_plug_vip_amphora_raise_db_error(
+            self, mock_session, mock_lb_get, mock_get, mock_get_net_driver):
+        mock_driver = mock.MagicMock()
+        mock_lb_get.return_value = LB
+        err_msg = 'Some Error'
+        mock_get.side_effect = Exception(err_msg)
+        net = network_tasks.PlugVIPAmphora()
+        amphora = {constants.ID: AMPHORA_ID,
+                   constants.LB_NETWORK_IP: IP_ADDRESS}
+        subnet = {constants.ID: SUBNET_ID}
+        result = AMPS_DATA[0].to_dict()
+        net.revert(result, self.load_balancer_mock, amphora, subnet)
+        mock_driver.unplug_aap_port.assert_not_called()
+        mock_lb_get.assert_not_called()
+        network_tasks.LOG.error.assert_called_once_with(
+            'Failed to unplug AAP port for load balancer: %s. '
+            'Resources may still be in use for VRRP port: %s. '
+            'Due to error: %s',
+            self.load_balancer_mock[constants.LOADBALANCER_ID],
+            result[constants.VRRP_PORT_ID], err_msg
+        )
+
     @mock.patch('octavia.controller.worker.v2.tasks.network_tasks.DeletePort.'
                 'update_progress')
     def test_delete_port(self, mock_update_progress, mock_get_net_driver):
@@ -1626,7 +1646,8 @@ class TestNetworkTasks(base.TestCase):
         vip_dict = {constants.IP_ADDRESS: VIP_IP_ADDRESS,
                     constants.NETWORK_ID: VIP_NETWORK_ID,
                     constants.QOS_POLICY_ID: VIP_QOS_ID,
-                    constants.SUBNET_ID: VIP_SUBNET_ID}
+                    constants.SUBNET_ID: VIP_SUBNET_ID,
+                    constants.SG_IDS: []}
         port_mock = mock.MagicMock()
         port_mock.id = PORT_ID
         additional_vips = [{constants.IP_ADDRESS: VIP_IP_ADDRESS2}]

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

@@ -33,6 +33,7 @@ class TestRedisTaskFlowDriver(base.TestCase):
                 'board': 'redis',
                 'host': '127.0.0.1',
                 'port': 6379,
+                'db': 0,
                 'namespace': 'octavia_jobboard',
                 'sentinel': None,
                 'sentinel_fallbacks': [],
@@ -65,6 +66,7 @@ class TestRedisTaskFlowDriver(base.TestCase):
                 'board': 'redis',
                 'host': '127.0.0.1',
                 'port': 6379,
+                'db': 0,
                 'namespace': 'octavia_jobboard',
                 'password': 'redispass',
                 'sentinel': None,
@@ -100,6 +102,7 @@ class TestRedisTaskFlowDriver(base.TestCase):
                 'board': 'redis',
                 'host': '127.0.0.1',
                 'port': 6379,
+                'db': 0,
                 'namespace': 'octavia_jobboard',
                 'username': 'redisuser',
                 'password': 'redispass',
@@ -142,6 +145,7 @@ class TestRedisTaskFlowDriver(base.TestCase):
                 'board': 'redis',
                 'host': '127.0.0.1',
                 'port': 6379,
+                'db': 0,
                 'namespace': 'octavia_jobboard',
                 'sentinel': None,
                 'sentinel_fallbacks': [],
@@ -179,6 +183,7 @@ class TestRedisTaskFlowDriver(base.TestCase):
                 'board': 'redis',
                 'host': 'host1',
                 'port': 26379,
+                'db': 0,
                 'namespace': 'octavia_jobboard',
                 'sentinel': 'mymaster',
                 'sentinel_fallbacks': ['host2:26379', 'host3:26379'],
@@ -220,6 +225,7 @@ class TestRedisTaskFlowDriver(base.TestCase):
                 'board': 'redis',
                 'host': 'host1',
                 'port': 26379,
+                'db': 0,
                 'namespace': 'octavia_jobboard',
                 'password': 'redispass',
                 'sentinel': 'mymaster',
@@ -267,6 +273,7 @@ class TestRedisTaskFlowDriver(base.TestCase):
                 'board': 'redis',
                 'host': 'host1',
                 'port': 26379,
+                'db': 0,
                 'namespace': 'octavia_jobboard',
                 'username': 'redisuser',
                 'password': 'redispass',
@@ -328,6 +335,7 @@ class TestRedisTaskFlowDriver(base.TestCase):
                 'board': 'redis',
                 'host': 'host1',
                 'port': 26379,
+                'db': 0,
                 'namespace': 'octavia_jobboard',
                 'sentinel': 'mymaster',
                 'sentinel_fallbacks': ['host2:26379', 'host3:26379'],