octavia 12.0.0.0rc2__py3-none-any.whl → 13.0.0.0rc1__py3-none-any.whl

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

@@ -123,10 +123,8 @@ class TestDatabaseTasksQuota(base.TestCase):
         with mock.patch('octavia.db.api.'
                         'get_session') as mock_get_session_local:
             mock_session = mock.MagicMock()
-            mock_lock_session = mock.MagicMock()
 
-            mock_get_session_local.side_effect = [mock_session,
-                                                  mock_lock_session]
+            mock_get_session_local.return_value = mock_session
 
             if data_model == data_models.Pool:
                 task.revert(test_object, self.zero_pool_child_count, None)
@@ -136,19 +134,17 @@ class TestDatabaseTasksQuota(base.TestCase):
                 task.revert(test_object, None)
 
             mock_check_quota_met.assert_called_once_with(
-                mock_session, mock_lock_session, data_model,
+                mock_session, mock_session, data_model,
                 project_id)
 
-            mock_lock_session.commit.assert_called_once_with()
+            mock_session.commit.assert_called_once_with()
 
         # revert with rollback
         with mock.patch('octavia.db.api.'
                         'get_session') as mock_get_session_local:
             mock_session = mock.MagicMock()
-            mock_lock_session = mock.MagicMock()
 
-            mock_get_session_local.side_effect = [mock_session,
-                                                  mock_lock_session]
+            mock_get_session_local.return_value = mock_session
 
             mock_check_quota_met.side_effect = (
                 exceptions.OctaviaException('fail'))
@@ -160,7 +156,7 @@ class TestDatabaseTasksQuota(base.TestCase):
             else:
                 task.revert(test_object, None)
 
-            mock_lock_session.rollback.assert_called_once_with()
+            mock_session.rollback.assert_called_once_with()
 
         # revert with db exception
         mock_check_quota_met.reset_mock()
@@ -238,27 +234,22 @@ class TestDatabaseTasksQuota(base.TestCase):
         mock_session.reset_mock()
         with mock.patch('octavia.db.api.'
                         'get_session') as mock_get_session_local:
-            mock_lock_session = mock.MagicMock()
-            mock_get_session_local.side_effect = [mock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session]
+            mock_get_session_local.return_value = mock_session
 
             task.revert(project_id, pool_child_count, None)
 
-            calls = [mock.call(mock_session, mock_lock_session,
+            calls = [mock.call(mock_session, mock_session,
                                data_models.Pool, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.HealthMonitor, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.Member, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.Member, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
 
-            self.assertEqual(4, mock_lock_session.commit.call_count)
+            self.assertEqual(4, mock_session.commit.call_count)
 
         # revert with health monitor quota exception
         mock_session.reset_mock()
@@ -266,28 +257,23 @@ class TestDatabaseTasksQuota(base.TestCase):
                                             None]
         with mock.patch('octavia.db.api.'
                         'get_session') as mock_get_session_local:
-            mock_lock_session = mock.MagicMock()
-            mock_get_session_local.side_effect = [mock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session]
+            mock_get_session_local.return_value = mock_session
 
             task.revert(project_id, pool_child_count, None)
 
-            calls = [mock.call(mock_session, mock_lock_session,
+            calls = [mock.call(mock_session, mock_session,
                                data_models.Pool, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.HealthMonitor, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.Member, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.Member, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
 
-            self.assertEqual(3, mock_lock_session.commit.call_count)
-            self.assertEqual(1, mock_lock_session.rollback.call_count)
+            self.assertEqual(3, mock_session.commit.call_count)
+            self.assertEqual(1, mock_session.rollback.call_count)
 
         # revert with member quota exception
         mock_session.reset_mock()
@@ -295,30 +281,25 @@ class TestDatabaseTasksQuota(base.TestCase):
                                             Exception('fail')]
         with mock.patch('octavia.db.api.'
                         'get_session') as mock_get_session_local:
-            mock_lock_session = mock.MagicMock()
-            mock_get_session_local.side_effect = [mock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session]
+            mock_get_session_local.return_value = mock_session
 
             task.revert(project_id, pool_child_count, None)
 
-            calls = [mock.call(mock_session, mock_lock_session,
+            calls = [mock.call(mock_session, mock_session,
                                data_models.Pool, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.HealthMonitor, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.Member, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.Member, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
 
-            self.assertEqual(3, mock_lock_session.commit.call_count)
-            self.assertEqual(1, mock_lock_session.rollback.call_count)
+            self.assertEqual(3, mock_session.commit.call_count)
+            self.assertEqual(1, mock_session.rollback.call_count)
 
-    @mock.patch('octavia.db.api.get_session')
+    @mock.patch('octavia.db.api.session')
     @mock.patch('octavia.db.repositories.PoolRepository.get_children_count')
     def test_count_pool_children_for_quota(self, repo_mock, session_mock):
         project_id = uuidutils.generate_uuid()
@@ -385,24 +366,20 @@ class TestDatabaseTasksQuota(base.TestCase):
         mock_session.reset_mock()
         with mock.patch('octavia.db.api.'
                         'get_session') as mock_get_session_local:
-            mock_lock_session = mock.MagicMock()
-            mock_get_session_local.side_effect = [mock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session]
+            mock_get_session_local.return_value = mock_session
 
             task.revert(test_object, None)
 
-            calls = [mock.call(mock_session, mock_lock_session,
+            calls = [mock.call(mock_session, mock_session,
                                data_models.L7Policy, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.L7Rule, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.L7Rule, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
 
-            self.assertEqual(3, mock_lock_session.commit.call_count)
+            self.assertEqual(3, mock_session.commit.call_count)
 
         # revert with l7rule quota exception
         mock_session.reset_mock()
@@ -410,25 +387,21 @@ class TestDatabaseTasksQuota(base.TestCase):
                                             Exception('fail')]
         with mock.patch('octavia.db.api.'
                         'get_session') as mock_get_session_local:
-            mock_lock_session = mock.MagicMock()
-            mock_get_session_local.side_effect = [mock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session,
-                                                  mock_lock_session]
+            mock_get_session_local.return_value = mock_session
 
             task.revert(test_object, None)
 
-            calls = [mock.call(mock_session, mock_lock_session,
+            calls = [mock.call(mock_session, mock_session,
                                data_models.L7Policy, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.L7Rule, project_id),
-                     mock.call(mock_session, mock_lock_session,
+                     mock.call(mock_session, mock_session,
                                data_models.L7Rule, project_id)]
 
             mock_check_quota_met.assert_has_calls(calls)
 
-            self.assertEqual(2, mock_lock_session.commit.call_count)
-            self.assertEqual(1, mock_lock_session.rollback.call_count)
+            self.assertEqual(2, mock_session.commit.call_count)
+            self.assertEqual(1, mock_session.rollback.call_count)
 
     def test_decrement_l7rule_quota(self):
         project_id = uuidutils.generate_uuid()

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

@@ -185,7 +185,6 @@ class TestNetworkTasks(base.TestCase):
         mock_lb_repo_get.return_value = lb_mock
         mock_driver.get_port.return_value = vrrp_port
         mock_driver.get_subnet.return_value = member_subnet
-        mock_driver.get_network.return_value = mgmt_net
         mock_driver.get_plugged_networks.return_value = [
             mgmt_interface,
             vrrp_interface,
@@ -231,9 +230,6 @@ class TestNetworkTasks(base.TestCase):
 
         mgmt_subnet = data_models.Subnet(
             id=self.mgmt_subnet_id, network_id=self.mgmt_net_id)
-        mgmt_net = data_models.Network(
-            id=self.mgmt_net_id,
-            subnets=[mgmt_subnet.id])
         mgmt_ip_address = mock.MagicMock()
         mgmt_interface = data_models.Interface(
             network_id=self.mgmt_net_id,
@@ -304,7 +300,6 @@ class TestNetworkTasks(base.TestCase):
                 fixed_ips=vrrp_port.fixed_ips)]
         mock_driver.get_port.return_value = vrrp_port
         mock_driver.get_subnet.return_value = vrrp_subnet
-        mock_driver.get_network.return_value = mgmt_net
 
         calc_delta = network_tasks.CalculateDelta()
 
@@ -407,10 +402,6 @@ class TestNetworkTasks(base.TestCase):
         mgmt2_subnet = data_models.Subnet(
             id=mgmt2_subnet_id,
             network_id=mgmt2_net_id)
-        mgmt2_net = data_models.Network(
-            id=mgmt2_net_id,
-            subnets=[mgmt2_subnet.id]
-        )
         mgmt2_interface = data_models.Interface(
             network_id=mgmt2_net_id,
             fixed_ips=[
@@ -419,7 +410,6 @@ class TestNetworkTasks(base.TestCase):
                     subnet_id=mgmt2_subnet_id,
                 )
             ])
-        mock_driver.get_network.return_value = mgmt2_net
         az = {
             constants.MANAGEMENT_NETWORK: mgmt2_net_id,
         }
@@ -439,7 +429,6 @@ class TestNetworkTasks(base.TestCase):
         # Test with one amp and one pool and one member, wrong network plugged
         # Delta should be one network/subnet to add and one to remove
         mock_driver.reset_mock()
-        mock_driver.get_network.return_value = mgmt_net
         member_mock = mock.MagicMock()
         member_mock.subnet_id = member_private_subnet.id
         pool_mock.members = [member_mock]
@@ -1411,7 +1400,7 @@ class TestNetworkTasks(base.TestCase):
         net_task.execute(listener)
         mock_driver.update_vip.assert_called_once_with(lb, for_delete=True)
 
-    @mock.patch('octavia.db.api.get_session', return_value='TEST')
+    @mock.patch('octavia.db.api.get_session')
     @mock.patch('octavia.db.repositories.AmphoraRepository.get')
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
     def test_get_amphora_network_configs_by_id(
@@ -1430,8 +1419,8 @@ class TestNetworkTasks(base.TestCase):
 
         mock_driver.get_network_configs.assert_called_once_with(
             'mock load balancer', amphora='mock amphora')
-        mock_amp_get.assert_called_once_with('TEST', id=AMP_ID)
-        mock_lb_get.assert_called_once_with('TEST', id=LB_ID)
+        mock_amp_get.assert_called_once_with(mock_get_session(), id=AMP_ID)
+        mock_lb_get.assert_called_once_with(mock_get_session(), id=LB_ID)
 
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
     @mock.patch('octavia.db.api.get_session', return_value=_session_mock)

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

@@ -1820,7 +1820,7 @@ class TestControllerWorker(base.TestCase):
             flow_utils.get_failover_amphora_flow,
             mock_amphora.to_dict(), 1, store=expected_stored_params)
 
-    @mock.patch('octavia.controller.worker.v1.flows.amphora_flows.'
+    @mock.patch('octavia.controller.worker.v2.flows.amphora_flows.'
                 'AmphoraFlows.get_failover_amphora_flow')
     def test_failover_amp_missing_amp(self,
                                       mock_get_amp_failover,
@@ -1893,7 +1893,7 @@ class TestControllerWorker(base.TestCase):
                           cw.failover_amphora,
                           AMP_ID, reraise=True)
 
-    @mock.patch('octavia.controller.worker.v1.flows.amphora_flows.'
+    @mock.patch('octavia.controller.worker.v2.flows.amphora_flows.'
                 'AmphoraFlows.get_failover_amphora_flow')
     def test_failover_amp_no_lb(self,
                                 mock_get_failover_amp_flow,