octavia 13.0.0.0rc1__py3-none-any.whl → 14.0.0__py3-none-any.whl

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

@@ -134,7 +134,7 @@ class TestDatabaseTasksQuota(base.TestCase):
                 task.revert(test_object, None)
 
             mock_check_quota_met.assert_called_once_with(
-                mock_session, mock_session, data_model,
+                mock_session, data_model,
                 project_id)
 
             mock_session.commit.assert_called_once_with()
@@ -238,13 +238,13 @@ class TestDatabaseTasksQuota(base.TestCase):
 
             task.revert(project_id, pool_child_count, None)
 
-            calls = [mock.call(mock_session, mock_session,
+            calls = [mock.call(mock_session,
                                data_models.Pool, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.HealthMonitor, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.Member, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.Member, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
@@ -261,13 +261,13 @@ class TestDatabaseTasksQuota(base.TestCase):
 
             task.revert(project_id, pool_child_count, None)
 
-            calls = [mock.call(mock_session, mock_session,
+            calls = [mock.call(mock_session,
                                data_models.Pool, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.HealthMonitor, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.Member, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.Member, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
@@ -285,13 +285,13 @@ class TestDatabaseTasksQuota(base.TestCase):
 
             task.revert(project_id, pool_child_count, None)
 
-            calls = [mock.call(mock_session, mock_session,
+            calls = [mock.call(mock_session,
                                data_models.Pool, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.HealthMonitor, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.Member, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.Member, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
@@ -370,11 +370,11 @@ class TestDatabaseTasksQuota(base.TestCase):
 
             task.revert(test_object, None)
 
-            calls = [mock.call(mock_session, mock_session,
+            calls = [mock.call(mock_session,
                                data_models.L7Policy, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.L7Rule, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.L7Rule, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
@@ -391,11 +391,11 @@ class TestDatabaseTasksQuota(base.TestCase):
 
             task.revert(test_object, None)
 
-            calls = [mock.call(mock_session, mock_session,
+            calls = [mock.call(mock_session,
                                data_models.L7Policy, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.L7Rule, project_id),
-                     mock.call(mock_session, mock_session,
+                     mock.call(mock_session,
                                data_models.L7Rule, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)

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

@@ -1115,36 +1115,6 @@ class TestNetworkTasks(base.TestCase):
         net.revert(None, None, None)
         mock_driver.unplug_network.assert_not_called()
 
-    @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
-    @mock.patch('octavia.db.api.get_session', return_value=_session_mock)
-    def test_plug_vip(self, mock_get_session, mock_get_lb,
-                      mock_get_net_driver):
-        mock_driver = mock.MagicMock()
-        mock_get_net_driver.return_value = mock_driver
-        LB.amphorae = AMPS_DATA
-        mock_get_lb.return_value = LB
-        LB.amphorae = AMPS_DATA
-        net = network_tasks.PlugVIP()
-        amp = mock.MagicMock()
-        amp.to_dict.return_value = 'vip'
-        mock_driver.plug_vip.return_value = [amp]
-
-        data = net.execute(self.load_balancer_mock)
-        mock_driver.plug_vip.assert_called_once_with(LB, LB.vip)
-        self.assertEqual(["vip"], data)
-
-        # revert
-        net.revert([o_data_models.Amphora().to_dict()],
-                   self.load_balancer_mock)
-        mock_driver.unplug_vip.assert_called_once_with(LB, LB.vip)
-
-        # revert with exception
-        mock_driver.reset_mock()
-        mock_driver.unplug_vip.side_effect = Exception('UnplugVipException')
-        net.revert([o_data_models.Amphora().to_dict()],
-                   self.load_balancer_mock)
-        mock_driver.unplug_vip.assert_called_once_with(LB, LB.vip)
-
     @mock.patch('octavia.controller.worker.task_utils.TaskUtils.'
                 'get_current_loadbalancer_from_db')
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
@@ -1434,18 +1404,6 @@ class TestNetworkTasks(base.TestCase):
         net_task.execute(self.load_balancer_mock)
         mock_driver.get_network_configs.assert_called_once_with(lb)
 
-    @mock.patch('octavia.db.repositories.AmphoraRepository.get')
-    @mock.patch('octavia.db.api.get_session', return_value=mock.MagicMock())
-    def test_failover_preparation_for_amphora(self, mock_session, mock_get,
-                                              mock_get_net_driver):
-        mock_driver = mock.MagicMock()
-        mock_get.return_value = self.db_amphora_mock
-        mock_get_net_driver.return_value = mock_driver
-        failover = network_tasks.FailoverPreparationForAmphora()
-        failover.execute(self.amphora_mock)
-        mock_driver.failover_preparation.assert_called_once_with(
-            self.db_amphora_mock)
-
     def test_retrieve_portids_on_amphora_except_lb_network(
             self, mock_get_net_driver):
         mock_driver = mock.MagicMock()
@@ -1842,3 +1800,108 @@ class TestNetworkTasks(base.TestCase):
         self.assertIsNone(result)
         mock_driver.get_security_group.assert_called_once_with(SG_NAME)
         mock_get_sg_name.assert_called_once_with(LB_ID)
+
+    @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
+    @mock.patch('octavia.db.api.get_session', return_value=_session_mock)
+    def test_create_SRIOV_base_port(self, mock_get_session, mock_lb_repo_get,
+                                    mock_get_net_driver):
+        AMP_ID = uuidutils.generate_uuid()
+        LB_ID = uuidutils.generate_uuid()
+        PORT_ID = uuidutils.generate_uuid()
+        VIP_NETWORK_ID = uuidutils.generate_uuid()
+        VIP_QOS_ID = uuidutils.generate_uuid()
+        VIP_SUBNET_ID = uuidutils.generate_uuid()
+        VIP_IP_ADDRESS = '203.0.113.81'
+        VIP_IP_ADDRESS2 = 'fd08::1'
+        mock_driver = mock.MagicMock()
+        mock_get_net_driver.return_value = mock_driver
+        port_mock = mock.MagicMock()
+        port_mock.id = PORT_ID
+        subnet_dict = {constants.ID: VIP_SUBNET_ID}
+        amphora_dict = {constants.ID: AMP_ID}
+        lb_dict = {constants.LOADBALANCER_ID: LB_ID,
+                   constants.VIP_ADDRESS: VIP_IP_ADDRESS,
+                   constants.VIP_NETWORK_ID: VIP_NETWORK_ID,
+                   constants.VIP_QOS_POLICY_ID: VIP_QOS_ID}
+        addl_vips = [o_data_models.AdditionalVip(
+            ip_address=VIP_IP_ADDRESS2)]
+        lb_mock = mock.MagicMock()
+        lb_mock.additional_vips = addl_vips
+        mock_lb_repo_get.return_value = lb_mock
+
+        mock_driver.create_port.side_effect = [
+            port_mock, exceptions.OctaviaException('boom'),
+            exceptions.OctaviaException('boom'),
+            exceptions.OctaviaException('boom')]
+        mock_driver.delete_port.side_effect = [mock.DEFAULT, Exception('boom')]
+
+        net_task = network_tasks.CreateSRIOVBasePort()
+
+        # Limit the retry attempts for the test run to save time
+        net_task.execute.retry.stop = tenacity.stop_after_attempt(2)
+
+        # Test execute
+        result = net_task.execute(lb_dict, amphora_dict, subnet_dict)
+
+        self.assertEqual(port_mock.to_dict(), result)
+        mock_driver.create_port.assert_called_once_with(
+            VIP_NETWORK_ID, name=constants.AMP_BASE_PORT_PREFIX + AMP_ID,
+            fixed_ips=[{constants.SUBNET_ID: VIP_SUBNET_ID}],
+            secondary_ips=[VIP_IP_ADDRESS2, VIP_IP_ADDRESS],
+            qos_policy_id=VIP_QOS_ID, vnic_type=constants.VNIC_TYPE_DIRECT)
+
+        # Test execute exception
+        mock_driver.reset_mock()
+
+        self.assertRaises(exceptions.OctaviaException, net_task.execute,
+                          lb_dict, amphora_dict, subnet_dict)
+
+        # Test revert when this task failed
+        mock_driver.reset_mock()
+
+        net_task.revert(failure.Failure.from_exception(Exception('boom')),
+                        lb_dict, amphora_dict, subnet_dict)
+
+        mock_driver.delete_port.assert_not_called()
+
+        # Test revert
+        mock_driver.reset_mock()
+
+        # 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, lb_dict, amphora_dict, subnet_dict)
+
+        mock_driver.delete_port.assert_called_once_with(PORT_ID)
+
+        # Test revert exception
+        mock_driver.reset_mock()
+
+        net_task.revert(port_dict, lb_dict, amphora_dict, subnet_dict)
+
+        mock_driver.delete_port.assert_called_once_with(PORT_ID)
+
+    def test_build_amp_data(self, mock_get_net_driver):
+        VIP_ADDRESS = '203.0.113.33'
+        VIP_PORT_ID = uuidutils.generate_uuid()
+        lb_dict = {constants.VIP_ADDRESS: VIP_ADDRESS,
+                   constants.VIP_PORT_ID: VIP_PORT_ID}
+        amphora_dict = {}
+        BASE_PORT_ID = uuidutils.generate_uuid()
+        BASE_PORT_IP = '203.0.113.50'
+        port_data_dict = {
+            constants.ID: BASE_PORT_ID,
+            constants.FIXED_IPS: [{constants.IP_ADDRESS: BASE_PORT_IP}]}
+
+        expected_amp_data = {constants.HA_IP: VIP_ADDRESS,
+                             constants.HA_PORT_ID: VIP_PORT_ID,
+                             constants.VRRP_ID: 1,
+                             constants.VRRP_PORT_ID: BASE_PORT_ID,
+                             constants.VRRP_IP: BASE_PORT_IP}
+
+        net_task = network_tasks.BuildAMPData()
+
+        result = net_task.execute(lb_dict, amphora_dict, port_data_dict)
+
+        self.assertEqual(expected_amp_data, result)

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

@@ -0,0 +1,33 @@
+# Copyright 2024 Red Hat
+#
+# 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 octavia.common import constants
+from octavia.controller.worker.v2.tasks import shim_tasks
+import octavia.tests.unit.base as base
+
+
+class TestShimTasks(base.TestCase):
+
+    def test_amphora_to_amphorae_with_vrrp_ip(self):
+
+        amp_to_amps = shim_tasks.AmphoraToAmphoraeWithVRRPIP()
+
+        base_port = {constants.FIXED_IPS:
+                     [{constants.IP_ADDRESS: '192.0.2.43'}]}
+        amphora = {constants.ID: '123456'}
+        expected_amphora = [{constants.ID: '123456',
+                             constants.VRRP_IP: '192.0.2.43'}]
+
+        self.assertEqual(expected_amphora,
+                         amp_to_amps.execute(amphora, base_port))