octavia 15.0.0__py3-none-any.whl → 16.0.0__py3-none-any.whl

octavia/tests/common/sample_data_models.py

@@ -50,6 +50,9 @@ class SampleDriverDataModels:
         self.pool_ca_container_ref = uuidutils.generate_uuid()
         self.pool_crl_container_ref = uuidutils.generate_uuid()
 
+        self.vip_sg_ids = [uuidutils.generate_uuid(),
+                           uuidutils.generate_uuid()]
+
         self.pool1_id = uuidutils.generate_uuid()
         self.pool2_id = uuidutils.generate_uuid()
 
@@ -145,7 +148,8 @@ class SampleDriverDataModels:
             constants.CREATED_AT: self.created_at,
             constants.UPDATED_AT: self.updated_at,
             lib_consts.MONITOR_ADDRESS: '192.0.2.26',
-            lib_consts.MONITOR_PORT: 81}
+            lib_consts.MONITOR_PORT: 81,
+            lib_consts.VNIC_TYPE: lib_consts.VNIC_TYPE_NORMAL}
 
         self.test_member1_dict.update(self._common_test_dict)
 
@@ -154,6 +158,8 @@ class SampleDriverDataModels:
         self.test_member2_dict[constants.IP_ADDRESS] = '192.0.2.17'
         self.test_member2_dict[lib_consts.MONITOR_ADDRESS] = '192.0.2.27'
         self.test_member2_dict[lib_consts.NAME] = 'member2'
+        self.test_member2_dict[
+            lib_consts.VNIC_TYPE] = lib_consts.VNIC_TYPE_DIRECT
 
         self.test_member3_dict = copy.deepcopy(self.test_member1_dict)
         self.test_member3_dict[lib_consts.ID] = self.member3_id
@@ -182,24 +188,28 @@ class SampleDriverDataModels:
         self.db_pool1_members = [self.db_member1, self.db_member2]
         self.db_pool2_members = [self.db_member3, self.db_member4]
 
-        self.provider_member1_dict = {lib_consts.ADDRESS: '192.0.2.16',
-                                      lib_consts.ADMIN_STATE_UP: True,
-                                      lib_consts.MEMBER_ID: self.member1_id,
-                                      lib_consts.MONITOR_ADDRESS: '192.0.2.26',
-                                      lib_consts.MONITOR_PORT: 81,
-                                      lib_consts.NAME: 'member1',
-                                      lib_consts.POOL_ID: self.pool1_id,
-                                      lib_consts.PROJECT_ID: self.project_id,
-                                      lib_consts.PROTOCOL_PORT: 80,
-                                      lib_consts.SUBNET_ID: self.subnet_id,
-                                      lib_consts.WEIGHT: 0,
-                                      lib_consts.BACKUP: False}
+        self.provider_member1_dict = {
+            lib_consts.ADDRESS: '192.0.2.16',
+            lib_consts.ADMIN_STATE_UP: True,
+            lib_consts.MEMBER_ID: self.member1_id,
+            lib_consts.MONITOR_ADDRESS: '192.0.2.26',
+            lib_consts.MONITOR_PORT: 81,
+            lib_consts.NAME: 'member1',
+            lib_consts.POOL_ID: self.pool1_id,
+            lib_consts.PROJECT_ID: self.project_id,
+            lib_consts.PROTOCOL_PORT: 80,
+            lib_consts.SUBNET_ID: self.subnet_id,
+            lib_consts.WEIGHT: 0,
+            lib_consts.BACKUP: False,
+            lib_consts.VNIC_TYPE: lib_consts.VNIC_TYPE_NORMAL}
 
         self.provider_member2_dict = copy.deepcopy(self.provider_member1_dict)
         self.provider_member2_dict[lib_consts.MEMBER_ID] = self.member2_id
         self.provider_member2_dict[lib_consts.ADDRESS] = '192.0.2.17'
         self.provider_member2_dict[lib_consts.MONITOR_ADDRESS] = '192.0.2.27'
         self.provider_member2_dict[lib_consts.NAME] = 'member2'
+        self.provider_member2_dict[
+            lib_consts.VNIC_TYPE] = lib_consts.VNIC_TYPE_DIRECT
 
         self.provider_member3_dict = copy.deepcopy(self.provider_member1_dict)
         self.provider_member3_dict[lib_consts.MEMBER_ID] = self.member3_id
@@ -600,6 +610,7 @@ class SampleDriverDataModels:
                               constants.PORT_ID: self.port_id,
                               lib_consts.SUBNET_ID: self.subnet_id,
                               constants.QOS_POLICY_ID: self.qos_policy_id,
+                              constants.SG_IDS: self.vip_sg_ids,
                               constants.OCTAVIA_OWNED: None}
 
         self.provider_vip_dict = {
@@ -608,6 +619,7 @@ class SampleDriverDataModels:
             lib_consts.VIP_PORT_ID: self.port_id,
             lib_consts.VIP_SUBNET_ID: self.subnet_id,
             lib_consts.VIP_QOS_POLICY_ID: self.qos_policy_id,
+            lib_consts.VIP_SG_IDS: self.vip_sg_ids,
             constants.OCTAVIA_OWNED: None}
 
         self.test_additional_vip_dict = {
@@ -627,7 +639,8 @@ class SampleDriverDataModels:
             network_id=self.network_id,
             port_id=self.port_id,
             subnet_id=self.subnet_id,
-            qos_policy_id=self.qos_policy_id)
+            qos_policy_id=self.qos_policy_id,
+            sg_ids=self.vip_sg_ids)
 
         self.db_additional_vip = data_models.AdditionalVip(
             ip_address=self.ip_address2,

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

@@ -12,6 +12,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import hashlib
 import os
 import random
 import socket
@@ -22,7 +23,6 @@ from unittest import mock
 import fixtures
 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
 
@@ -740,9 +740,10 @@ class TestServerTestCase(base.TestCase):
             rv = self.centos_app.get('/' + api_server.VERSION +
                                      '/loadbalancer/123/certificates/test.pem')
         self.assertEqual(200, rv.status_code)
-        self.assertEqual(dict(md5sum=md5(octavia_utils.b(CONTENT),
-                                         usedforsecurity=False).hexdigest()),
-                         jsonutils.loads(rv.data.decode('utf-8')))
+        self.assertEqual(
+            dict(md5sum=hashlib.md5(octavia_utils.b(CONTENT),
+                                    usedforsecurity=False).hexdigest()),
+            jsonutils.loads(rv.data.decode('utf-8')))
 
     def test_ubuntu_upload_certificate_md5(self):
         self._test_upload_certificate_md5(consts.UBUNTU)

octavia/tests/functional/api/drivers/driver_agent/test_driver_agent.py

@@ -503,7 +503,8 @@ class DriverAgentTest(base.OctaviaDBTestBase):
                     lib_consts.MONITOR_PORT,
                     lib_consts.SUBNET_ID,
                     lib_consts.WEIGHT,
-                    lib_consts.BACKUP):
+                    lib_consts.BACKUP,
+                    lib_consts.VNIC_TYPE):
             self.assertEqual(provider_member_dict.get(key),
                              result_member_dict.get(key))
 

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

@@ -406,7 +406,7 @@ class TestHealthMonitor(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_global_observer'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,

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

@@ -320,7 +320,7 @@ class TestL7Policy(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_global_observer'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,

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

@@ -202,7 +202,7 @@ class TestListener(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_global_observer'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,

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

@@ -1384,7 +1384,7 @@ class TestLoadBalancer(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_global_observer'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -2054,6 +2054,37 @@ class TestLoadBalancer(base.BaseAPITest):
             self.put(self.LB_PATH.format(lb_id=lb_dict.get('id')),
                      lb_json, status=400)
 
+    def test_update_with_sg_ids(self):
+        project_id = uuidutils.generate_uuid()
+        sg1_id = uuidutils.generate_uuid()
+        sg2_id = uuidutils.generate_uuid()
+        lb = self.create_load_balancer(uuidutils.generate_uuid(),
+                                       name='lb1',
+                                       project_id=project_id,
+                                       vip_sg_ids=[sg1_id, sg2_id])
+        lb_dict = lb.get(self.root_tag)
+        lb_id = lb_dict.get('id')
+        self.assertEqual(sorted([sg1_id, sg2_id]),
+                         sorted(lb_dict['vip_sg_ids']))
+        self.set_lb_status(lb_dict.get('id'))
+
+        lb_json = self._build_body({'vip_sg_ids': [sg2_id]})
+        self.put(self.LB_PATH.format(lb_id=lb_id),
+                 lb_json, status=200)
+        self.set_lb_status(lb_dict.get('id'))
+        response = self.get(self.LB_PATH.format(lb_id=lb_id))
+        lb_dict = response.json.get(self.root_tag)
+        self.assertEqual(sorted([sg2_id]),
+                         sorted(lb_dict['vip_sg_ids']))
+
+        lb_json = self._build_body({'vip_sg_ids': []})
+        lb = self.put(self.LB_PATH.format(lb_id=lb_dict.get('id')),
+                      lb_json, status=200)
+        self.set_lb_status(lb_dict.get('id'))
+        response = self.get(self.LB_PATH.format(lb_id=lb_id))
+        lb_dict = response.json.get(self.root_tag)
+        self.assertEqual(0, len(lb_dict['vip_sg_ids']))
+
     def test_update_bad_lb_id(self):
         path = self.LB_PATH.format(lb_id='SEAN-CONNERY')
         self.put(path, body={}, status=404)
@@ -2503,7 +2534,7 @@ class TestLoadBalancer(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_admin'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -2735,8 +2766,13 @@ class TestLoadBalancerGraph(base.BaseAPITest):
         expected_additional_vips = expected_graph.pop('additional_vips', [])
         observed_additional_vips = observed_graph_copy.pop('additional_vips',
                                                            [])
+        expected_vip_sg_ids = expected_graph.pop('vip_sg_ids', [])
+        observed_vip_sg_ids = observed_graph_copy.pop('vip_sg_ids', [])
         self.assertEqual(expected_graph, observed_graph_copy)
 
+        self.assertEqual(sorted(expected_vip_sg_ids),
+                         sorted(observed_vip_sg_ids))
+
         self.assertEqual(len(expected_pools), len(observed_pools))
 
         self.assertEqual(len(expected_listeners), len(observed_listeners))
@@ -2800,7 +2836,8 @@ class TestLoadBalancerGraph(base.BaseAPITest):
             self.assertIn(observed_add_vip, expected_additional_vips)
 
     def _get_lb_bodies(self, create_listeners, expected_listeners,
-                       create_pools=None, additional_vips=None):
+                       create_pools=None, additional_vips=None,
+                       vip_sg_ids=None, flavor_id=None, sriov=False):
         create_lb = {
             'name': 'lb1',
             'project_id': self._project_id,
@@ -2811,6 +2848,8 @@ class TestLoadBalancerGraph(base.BaseAPITest):
             'listeners': create_listeners,
             'pools': create_pools or []
         }
+        if vip_sg_ids:
+            create_lb['vip_sg_ids'] = vip_sg_ids
         if additional_vips:
             create_lb.update({'additional_vips': additional_vips})
         expected_lb = {
@@ -2830,7 +2869,13 @@ class TestLoadBalancerGraph(base.BaseAPITest):
             'provider': 'noop_driver',
             'tags': [],
             'vip_vnic_type': constants.VNIC_TYPE_NORMAL,
+            'vip_sg_ids': vip_sg_ids or [],
         }
+        if flavor_id:
+            create_lb['flavor_id'] = flavor_id
+            expected_lb['flavor_id'] = flavor_id
+        if sriov:
+            expected_lb['vip_vnic_type'] = constants.VNIC_TYPE_DIRECT
         expected_lb.update(create_lb)
         expected_lb['listeners'] = expected_listeners
         expected_lb['pools'] = create_pools or []
@@ -3003,7 +3048,7 @@ class TestLoadBalancerGraph(base.BaseAPITest):
             expected_pool['healthmonitor'] = expected_hm
         return create_pool, expected_pool
 
-    def _get_member_bodies(self, protocol_port=80):
+    def _get_member_bodies(self, protocol_port=80, sriov=False):
         create_member = {
             'address': '10.0.0.1',
             'protocol_port': protocol_port
@@ -3016,6 +3061,9 @@ class TestLoadBalancerGraph(base.BaseAPITest):
             'project_id': self._project_id,
             'tags': []
         }
+        if sriov:
+            create_member[constants.REQUEST_SRIOV] = True
+            expected_member[constants.VNIC_TYPE] = constants.VNIC_TYPE_DIRECT
         expected_member.update(create_member)
         return create_member, expected_member
 
@@ -3211,6 +3259,16 @@ class TestLoadBalancerGraph(base.BaseAPITest):
         api_lb = response.json.get(self.root_tag)
         self._assert_graphs_equal(expected_lb, api_lb)
 
+    def test_with_sg_ids(self):
+        create_lb, expected_lb = self._get_lb_bodies(
+            [], [], vip_sg_ids=[uuidutils.generate_uuid(),
+                                uuidutils.generate_uuid()])
+
+        body = self._build_body(create_lb)
+        response = self.post(self.LBS_PATH, body)
+        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],
@@ -3220,6 +3278,53 @@ class TestLoadBalancerGraph(base.BaseAPITest):
         api_lb = response.json.get(self.root_tag)
         self._assert_graphs_equal(expected_lb, api_lb)
 
+    def test_with_one_listener_sg_ids(self):
+        create_listener, expected_listener = self._get_listener_bodies()
+        create_lb, expected_lb = self._get_lb_bodies(
+            [create_listener], [expected_listener],
+            vip_sg_ids=[uuidutils.generate_uuid(),
+                        uuidutils.generate_uuid()])
+
+        body = self._build_body(create_lb)
+        response = self.post(self.LBS_PATH, body)
+        api_lb = response.json.get(self.root_tag)
+        self._assert_graphs_equal(expected_lb, api_lb)
+
+    @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_and_sg_ids(self, mock_flavor_dict):
+        create_lb, expected_lb = self._get_lb_bodies(
+            [], [],
+            vip_sg_ids=[uuidutils.generate_uuid(),
+                        uuidutils.generate_uuid()])
+        expected_lb[constants.VIP_VNIC_TYPE] = constants.VNIC_TYPE_DIRECT
+
+        body = self._build_body(create_lb)
+
+        response = self.post(self.LBS_PATH, body, status=400,
+                             expect_errors=True)
+        error_text = response.json.get('faultstring')
+        self.assertIn("VIP Security Groups are not allowed with VNIC "
+                      "direct type", error_text)
+
+    def test_with_one_listener_sg_ids_and_allowed_cidrs(self):
+        allowed_cidrs = ['10.0.1.0/24']
+        create_listener, expected_listener = self._get_listener_bodies(
+            create_allowed_cidrs=allowed_cidrs,
+            expected_allowed_cidrs=allowed_cidrs)
+        create_lb, expected_lb = self._get_lb_bodies(
+            [create_listener], [expected_listener],
+            vip_sg_ids=[uuidutils.generate_uuid(),
+                        uuidutils.generate_uuid()])
+
+        body = self._build_body(create_lb)
+        response = self.post(self.LBS_PATH, body, status=400,
+                             expect_errors=True)
+        error_text = response.json.get('faultstring')
+        self.assertIn("Allowed CIDRs are not allowed when using custom "
+                      "VIP Security Groups", error_text)
+
     def test_with_one_listener_with_default_timeouts(self):
         self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
         self.conf.config(group='haproxy_amphora', timeout_client_data=20)
@@ -3299,6 +3404,47 @@ class TestLoadBalancerGraph(base.BaseAPITest):
         api_lb = response.json.get(self.root_tag)
         self._assert_graphs_equal(expected_lb, api_lb)
 
+    def test_with_one_listener_one_member_sriov(self):
+        flavor_profile = self.create_flavor_profile(
+            'sriov-graph-create', 'noop_driver',
+            f'{{"{constants.ALLOW_MEMBER_SRIOV}": true, '
+            f'"{constants.SRIOV_VIP}": true}}')
+
+        flavor = self.create_flavor('sriov-graph-create', '',
+                                    flavor_profile['id'], True)
+
+        create_member, expected_member = self._get_member_bodies(sriov=True)
+        create_pool, expected_pool = self._get_pool_bodies(
+            create_members=[create_member],
+            expected_members=[expected_member])
+        create_listener, expected_listener = self._get_listener_bodies(
+            create_default_pool_name=create_pool['name'])
+        create_lb, expected_lb = self._get_lb_bodies(
+            create_listeners=[create_listener],
+            expected_listeners=[expected_listener],
+            create_pools=[create_pool], flavor_id=flavor['id'], sriov=True)
+        body = self._build_body(create_lb)
+        response = self.post(self.LBS_PATH, body)
+        api_lb = response.json.get(self.root_tag)
+        self._assert_graphs_equal(expected_lb, api_lb)
+
+    def test_with_one_listener_one_member_sriov_disabled(self):
+        create_member, expected_member = self._get_member_bodies(sriov=True)
+        create_pool, expected_pool = self._get_pool_bodies(
+            create_members=[create_member],
+            expected_members=[expected_member])
+        create_listener, expected_listener = self._get_listener_bodies(
+            create_default_pool_name=create_pool['name'])
+        create_lb, expected_lb = self._get_lb_bodies(
+            create_listeners=[create_listener],
+            expected_listeners=[expected_listener],
+            create_pools=[create_pool])
+        body = self._build_body(create_lb)
+        response = self.post(self.LBS_PATH, body, status=400)
+        error_text = response.json.get('faultstring')
+        self.assertIn('flavor does not allow SR-IOV member ports.',
+                      error_text)
+
     def test_with_one_listener_one_hm(self):
         create_hm, expected_hm = self._get_hm_bodies()
         create_pool, expected_pool = self._get_pool_bodies(

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

@@ -18,6 +18,7 @@ from octavia_lib.api.drivers import data_models as driver_dm
 from oslo_config import cfg
 from oslo_config import fixture as oslo_fixture
 from oslo_utils import uuidutils
+from sqlalchemy.orm import exc as sa_exception
 
 from octavia.api.drivers import utils as driver_utils
 from octavia.common import constants
@@ -623,6 +624,55 @@ class TestMember(base.BaseAPITest):
         self.assertIn('Provider \'bad_driver\' reports error: broken',
                       response.get('faultstring'))
 
+    def test_create_with_sriov(self):
+        flavor_profile = self.create_flavor_profile(
+            'sriov-member-create', 'noop_driver',
+            f'{{"{constants.ALLOW_MEMBER_SRIOV}": true}}')
+
+        flavor = self.create_flavor('sriov-member-create', '',
+                                    flavor_profile['id'], True)
+
+        vip_subnet_id = uuidutils.generate_uuid()
+        lb = self.create_load_balancer(vip_subnet_id, flavor_id=flavor['id'])
+        lb_id = lb.get('loadbalancer').get('id')
+        self.set_lb_status(lb_id)
+
+        listener = self.create_listener(
+            constants.PROTOCOL_HTTP, 80,
+            lb_id=lb_id)
+        listener_id = listener.get('listener').get('id')
+        self.set_lb_status(lb_id)
+
+        pool_with_listener = self.create_pool(
+            lb_id, constants.PROTOCOL_HTTP,
+            constants.LB_ALGORITHM_ROUND_ROBIN, listener_id=listener_id)
+        pool_with_listener_id = pool_with_listener.get('pool').get('id')
+        self.set_lb_status(lb_id)
+
+        api_member = self.create_member(
+            pool_with_listener_id, '192.0.2.1',
+            80, request_sriov=True).get(self.root_tag)
+        self.assertEqual(constants.VNIC_TYPE_DIRECT,
+                         api_member[constants.VNIC_TYPE])
+
+    def test_create_with_sriov_disabled(self):
+        # Test with no flavor enabling SR-IOV members
+        response = self.create_member(
+            self.pool_id, '192.0.2.1',
+            80, request_sriov=True, status=400)
+        self.assertIn('flavor does not allow SR-IOV member ports',
+                      response.get('faultstring'))
+
+    @mock.patch('octavia.db.repositories.FlavorRepository.'
+                'get_flavor_metadata_dict')
+    def test_create_with_sriov_missing_flavor(self, mock_get_flavor):
+        mock_get_flavor.side_effect = sa_exception.NoResultFound()
+        response = self.create_member(
+            self.pool_id, '192.0.2.1',
+            80, request_sriov=True, status=400)
+        self.assertIn('flavor does not allow SR-IOV member ports',
+                      response.get('faultstring'))
+
     @mock.patch('octavia.api.drivers.driver_factory.get_driver')
     @mock.patch('octavia.api.drivers.utils.call_provider')
     def test_full_batch_members(self, mock_provider, mock_get_driver):

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

@@ -340,7 +340,7 @@ class TestPool(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_global_observer'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,

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

@@ -298,7 +298,7 @@ class TestQuotas(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_global_observer'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -345,7 +345,7 @@ class TestQuotas(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_quota_admin'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -485,11 +485,8 @@ class TestQuotas(base.BaseAPITest):
     def test_get_Authorized_observer(self):
         self._test_get_Authorized(['load-balancer_observer', 'reader'])
 
-    def test_get_Authorized_global_observer(self):
-        self._test_get_Authorized(['load-balancer_global_observer'])
-
     def test_get_Authorized_quota_admin(self):
-        self._test_get_Authorized(['load-balancer_quota_admin'])
+        self._test_get_Authorized(['admin'])
 
     def _test_get_Authorized(self, roles):
         project1_id = uuidutils.generate_uuid()
@@ -759,7 +756,7 @@ class TestQuotas(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_quota_admin'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -871,7 +868,7 @@ class TestQuotas(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_quota_admin'],
+                'roles': ['admin'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,

octavia/tests/functional/db/base.py

@@ -14,9 +14,8 @@
 
 import os
 
-from oslo_config import cfg
 from oslo_config import fixture as oslo_fixture
-from oslo_db.sqlalchemy import session as db_session
+from oslo_db.sqlalchemy import enginefacade
 from oslotest import base as test_base
 
 from octavia.common import config
@@ -71,10 +70,11 @@ class OctaviaDBTestBase(test_base.BaseTestCase):
         # don't use the _FACADE singleton. Some tests will use in-memory
         # sqlite, some will use a file backed sqlite.
         if 'sqlite:///' in self.connection_string:
-            facade = db_session.EngineFacade.from_config(cfg.CONF,
-                                                         sqlite_fk=True)
-            engine = facade.get_engine()
-            session = facade.get_session(expire_on_commit=True)
+            facade = enginefacade.transaction_context()
+            facade.configure(sqlite_fk=True, expire_on_commit=True)
+            engine = facade.writer.get_engine()
+            sessionmaker = facade.writer.get_sessionmaker()
+            session = sessionmaker()
             self.facade = facade
         else:
             engine = db_api.get_engine()