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

octavia/tests/functional/amphorae/backend/agent/api_server/test_server.py

@@ -24,6 +24,7 @@ from oslo_config import fixture as oslo_fixture
 from oslo_serialization import jsonutils
 from oslo_utils.secretutils import md5
 from oslo_utils import uuidutils
+import webob
 
 from octavia.amphorae.backends.agent import api_server
 from octavia.amphorae.backends.agent.api_server import certificate_update
@@ -3055,3 +3056,39 @@ class TestServerTestCase(base.TestCase):
         self.assertEqual(200, rv.status_code)
         self.assertEqual(expected_dict,
                          jsonutils.loads(rv.data.decode('utf-8')))
+
+    @mock.patch('octavia.amphorae.backends.utils.nftable_utils.'
+                'load_nftables_file')
+    @mock.patch('octavia.amphorae.backends.utils.nftable_utils.'
+                'write_nftable_vip_rules_file')
+    @mock.patch('octavia.amphorae.backends.agent.api_server.amphora_info.'
+                'AmphoraInfo.get_interface')
+    def test_set_interface_rules(self, mock_get_int, mock_write_rules,
+                                 mock_load_rules):
+        mock_get_int.side_effect = [
+            webob.Response(status=400),
+            webob.Response(status=200, json={'interface': 'fake1'}),
+            webob.Response(status=200, json={'interface': 'fake1'})]
+
+        # Test can't find interface
+        rv = self.ubuntu_app.put('/' + api_server.VERSION +
+                                 '/interface/192.0.2.10/rules', data='fake')
+        self.assertEqual(400, rv.status_code)
+        mock_write_rules.assert_not_called()
+
+        # Test schema validation failure
+        rv = self.ubuntu_app.put('/' + api_server.VERSION +
+                                 '/interface/192.0.2.10/rules', data='fake')
+        self.assertEqual('400 Bad Request', rv.status)
+
+        # Test successful path
+        rules_json = ('[{"protocol":"TCP","cidr":"192.0.2.0/24","port":8080},'
+                      '{"protocol":"UDP","cidr":null,"port":80}]')
+        rv = self.ubuntu_app.put('/' + api_server.VERSION +
+                                 '/interface/192.0.2.10/rules',
+                                 data=rules_json,
+                                 content_type='application/json')
+        self.assertEqual('200 OK', rv.status)
+        mock_write_rules.assert_called_once_with('fake1',
+                                                 jsonutils.loads(rules_json))
+        mock_load_rules.assert_called_once()

octavia/tests/functional/api/test_healthcheck.py

@@ -111,7 +111,7 @@ class TestHealthCheck(base_db_test.OctaviaDBTestBase):
         self.assertEqual(200, response.status_code)
         self.assertEqual('OK', response.text)
 
-    # Note: For whatever reason, detailed=True text has no additonal info
+    # Note: For whatever reason, detailed=True text has no additional info
     def test_healthcheck_get_text_detailed(self):
         self.conf.config(group='healthcheck', detailed=True)
         response = self._get(self._get_enabled_app(), '/healthcheck')
@@ -275,7 +275,7 @@ class TestHealthCheck(base_db_test.OctaviaDBTestBase):
         self.assertIn('boom', response.text)
         self.assertIn('Garbage collector', response.text)
 
-    # Note: For whatever reason, detailed=True text has no additonal info
+    # Note: For whatever reason, detailed=True text has no additional info
     @mock.patch('octavia.db.api.get_session')
     def test_healthcheck_get_text_detailed_failed(self, mock_get_session):
         self.conf.config(group='healthcheck', detailed=True)

octavia/tests/functional/api/v2/base.py

@@ -140,7 +140,7 @@ class BaseAPITest(base_db_test.OctaviaDBTestBase):
         self.addCleanup(reset_pecan)
 
     def start_quota_mock(self, object_type):
-        def mock_quota(session, lock_session, _class, project_id, count=1):
+        def mock_quota(session, _class, project_id, count=1):
             return _class == object_type
         check_quota_met_true_mock = mock.patch(
             'octavia.db.repositories.Repositories.check_quota_met',

octavia/tests/functional/api/v2/test_listener.py

@@ -1044,6 +1044,51 @@ class TestListener(base.BaseAPITest):
         self.assertEqual(constants.CLIENT_AUTH_NONE,
                          listener_api.get('client_authentication'))
 
+    def test_create_tls_with_no_subject_no_alt_names(self):
+        tls_cert_mock = mock.MagicMock()
+        tls_cert_mock.get_certificate.return_value = (
+            sample_certs.NOCN_NOSUBALT_CRT)
+        self.cert_manager_mock().get_cert.return_value = tls_cert_mock
+
+        lb_listener = {'name': 'listener1-no-subject-no-alt-names',
+                       'default_pool_id': None,
+                       'description': 'desc1',
+                       'admin_state_up': False,
+                       'protocol': constants.PROTOCOL_TERMINATED_HTTPS,
+                       'protocol_port': 80, 'connection_limit': 10,
+                       'default_tls_container_ref': uuidutils.generate_uuid(),
+                       'insert_headers': {},
+                       'project_id': self.project_id,
+                       'loadbalancer_id': self.lb_id,
+                       'tags': ['test_tag']}
+        body = self._build_body(lb_listener)
+        response = self.post(self.LISTENERS_PATH, body, status=400)
+        self.assertIn("No CN or DNSName", response)
+
+    def test_create_tls_with_no_subject_with_alt_names(self):
+        tls_cert_mock = mock.MagicMock()
+        tls_cert_mock.get_certificate.return_value = (
+            sample_certs.NOCN_SUBALT_CRT)
+        tls_cert_mock.get_private_key.return_value = (
+            sample_certs.NOCN_SUBALT_KEY)
+        tls_cert_mock.get_private_key_passphrase.return_value = None
+        self.cert_manager_mock().get_cert.return_value = tls_cert_mock
+
+        lb_listener = {'name': 'listener1-no-subject',
+                       'default_pool_id': None,
+                       'description': 'desc1',
+                       'admin_state_up': False,
+                       'protocol': constants.PROTOCOL_TERMINATED_HTTPS,
+                       'protocol_port': 80, 'connection_limit': 10,
+                       'default_tls_container_ref': uuidutils.generate_uuid(),
+                       'insert_headers': {},
+                       'project_id': self.project_id,
+                       'loadbalancer_id': self.lb_id,
+                       'tags': ['test_tag']}
+        body = self._build_body(lb_listener)
+        response = self.post(self.LISTENERS_PATH, body, status=201)
+        self.assertIn("PENDING_CREATE", response)
+
     def test_create_with_ca_cert_and_option(self):
         self.cert_manager_mock().get_secret.return_value = (
             sample_certs.X509_CA_CERT)

octavia/tests/functional/api/v2/test_load_balancer.py

@@ -2829,6 +2829,7 @@ class TestLoadBalancerGraph(base.BaseAPITest):
             'flavor_id': None,
             'provider': 'noop_driver',
             'tags': [],
+            'vip_vnic_type': constants.VNIC_TYPE_NORMAL,
         }
         expected_lb.update(create_lb)
         expected_lb['listeners'] = expected_listeners
@@ -3194,6 +3195,22 @@ class TestLoadBalancerGraph(base.BaseAPITest):
         self.assertIn('All VIP subnets must belong to the same network.',
                       error_text)
 
+    @mock.patch('octavia.api.v2.controllers.load_balancer.'
+                'LoadBalancersController._apply_flavor_to_lb_dict',
+                return_value={constants.SRIOV_VIP: True})
+    def test_with_vip_vnic_type_direct(self, mock_flavor_dict):
+        create_lb, expected_lb = self._get_lb_bodies(
+            [], [])
+        expected_lb[constants.VIP_VNIC_TYPE] = constants.VNIC_TYPE_DIRECT
+
+        body = self._build_body(create_lb)
+
+        response = self.post(self.LBS_PATH, body)
+        self._assert_graphs_equal(expected_lb, response.json['loadbalancer'])
+
+        api_lb = response.json.get(self.root_tag)
+        self._assert_graphs_equal(expected_lb, api_lb)
+
     def test_with_one_listener(self):
         create_listener, expected_listener = self._get_listener_bodies()
         create_lb, expected_lb = self._get_lb_bodies([create_listener],

octavia/tests/functional/db/base.py

@@ -30,6 +30,8 @@ from octavia.tests import fixtures as oc_fixtures
 
 class OctaviaDBTestBase(test_base.BaseTestCase):
 
+    facade = None
+
     def setUp(self, connection_string='sqlite://'):
         super().setUp()
 
@@ -73,11 +75,18 @@ class OctaviaDBTestBase(test_base.BaseTestCase):
                                                          sqlite_fk=True)
             engine = facade.get_engine()
             session = facade.get_session(expire_on_commit=True)
+            self.facade = facade
         else:
             engine = db_api.get_engine()
             session = db_api.get_session()
         return engine, session
 
+    def get_session(self):
+        if 'sqlite:///' in self.connection_string:
+            return self.facade.get_session(expire_on_commit=True)
+        else:
+            return db_api.get_session()
+
     def _seed_lookup_tables(self, session):
         self._seed_lookup_table(
             session, constants.SUPPORTED_PROVISIONING_STATUSES,

octavia/tests/functional/db/test_models.py

@@ -622,7 +622,8 @@ class VipModelTest(base.OctaviaDBTestBase, ModelTestMixin):
         self.assertEqual(f"Vip(ip_address=None, "
                          f"load_balancer_id={obj.load_balancer_id!r}, "
                          f"network_id=None, octavia_owned=None, port_id=None, "
-                         f"qos_policy_id=None, subnet_id=None)", str(obj))
+                         f"qos_policy_id=None, subnet_id=None, "
+                         f"vnic_type=None)", str(obj))
 
     def test_update(self):
         vip = self.create_vip(self.session, self.load_balancer.id)