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

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

@@ -31,6 +31,9 @@ from octavia.tests.common import sample_certs
 from octavia.tests.common import sample_data_models
 from octavia.tests.functional.db import base
 
+from oslo_log import log as logging
+LOG = logging.getLogger(__name__)
+
 CONF = cfg.CONF
 
 
@@ -267,18 +270,252 @@ class DriverAgentTest(base.OctaviaDBTestBase):
         l7rule2_dict = copy.deepcopy(self.sample_data.test_l7rule2_dict)
         self.repos.l7rule.create(self.session, **l7rule2_dict)
 
+        self.session.commit()
+
         self.provider_lb_dict = copy.deepcopy(
             self.sample_data.provider_loadbalancer_tree_dict)
         self.provider_lb_dict[lib_consts.POOLS] = [self.provider_pool_dict]
         self.provider_lb_dict[
             lib_consts.LISTENERS] = [self.provider_listener_dict]
 
+    def _compare_load_balancer_dicts(self,
+                                     provider_lb_dict,
+                                     result_dict):
+        for key in (lib_consts.LOADBALANCER_ID,
+                    lib_consts.NAME,
+                    lib_consts.DESCRIPTION,
+                    lib_consts.PROJECT_ID,
+                    lib_consts.ADMIN_STATE_UP,
+                    lib_consts.VIP_ADDRESS,
+                    lib_consts.VIP_NETWORK_ID,
+                    lib_consts.VIP_SUBNET_ID,
+                    lib_consts.VIP_PORT_ID,
+                    lib_consts.VIP_QOS_POLICY_ID,
+                    lib_consts.FLAVOR,
+                    lib_consts.AVAILABILITY_ZONE,
+                    lib_consts.ADDITIONAL_VIPS):
+            self.assertEqual(provider_lb_dict.get(key),
+                             result_dict.get(key))
+
+        provider_listener_dicts = provider_lb_dict[lib_consts.LISTENERS]
+        result_listener_dicts = result_dict[lib_consts.LISTENERS]
+
+        self.assertEqual(len(provider_listener_dicts),
+                         len(result_listener_dicts))
+
+        for listener_dicts in zip(provider_listener_dicts,
+                                  result_listener_dicts):
+            provider_listener_dict = listener_dicts[0]
+            result_listener_dict = listener_dicts[1]
+            self._compare_listener_dicts(provider_listener_dict,
+                                         result_listener_dict)
+
+        self.assertEqual(len(provider_lb_dict[lib_consts.POOLS]),
+                         len(result_dict[lib_consts.POOLS]))
+
+        for pool_dicts in zip(provider_lb_dict[lib_consts.POOLS],
+                              result_dict[lib_consts.POOLS]):
+            provider_pool_dict = pool_dicts[0]
+            result_pool_dict = pool_dicts[1]
+            self._compare_pool_dicts(provider_pool_dict,
+                                     result_pool_dict)
+
+    def _compare_listener_dicts(self,
+                                provider_listener_dict,
+                                result_listener_dict):
+        for key in (lib_consts.LISTENER_ID,
+                    lib_consts.LOADBALANCER_ID,
+                    lib_consts.NAME,
+                    lib_consts.DESCRIPTION,
+                    lib_consts.PROJECT_ID,
+                    lib_consts.ADMIN_STATE_UP,
+                    lib_consts.PROTOCOL,
+                    lib_consts.PROTOCOL_PORT,
+                    lib_consts.CONNECTION_LIMIT,
+                    lib_consts.DEFAULT_POOL_ID,
+                    lib_consts.TIMEOUT_CLIENT_DATA,
+                    lib_consts.TIMEOUT_MEMBER_CONNECT,
+                    lib_consts.TIMEOUT_MEMBER_DATA,
+                    lib_consts.TIMEOUT_TCP_INSPECT,
+                    lib_consts.INSERT_HEADERS,
+                    lib_consts.ALLOWED_CIDRS,
+                    lib_consts.DEFAULT_TLS_CONTAINER_REF,
+                    lib_consts.DEFAULT_TLS_CONTAINER_DATA,
+                    lib_consts.SNI_CONTAINER_REFS,
+                    lib_consts.SNI_CONTAINER_DATA,
+                    lib_consts.CLIENT_CA_TLS_CONTAINER_REF,
+                    lib_consts.CLIENT_CA_TLS_CONTAINER_DATA,
+                    lib_consts.CLIENT_AUTHENTICATION,
+                    lib_consts.CLIENT_CRL_CONTAINER_REF,
+                    lib_consts.CLIENT_CRL_CONTAINER_DATA,
+                    lib_consts.TLS_CIPHERS,
+                    lib_consts.TLS_VERSIONS):
+            self.assertEqual(provider_listener_dict.get(key),
+                             result_listener_dict.get(key))
+
+        provider_l7policy_dicts = provider_listener_dict.get(
+            lib_consts.L7POLICIES)
+        result_l7policy_dicts = result_listener_dict.get(
+            lib_consts.L7POLICIES)
+
+        self.assertEqual(len(provider_l7policy_dicts),
+                         len(result_l7policy_dicts))
+
+        for l7policy_dicts in zip(provider_l7policy_dicts,
+                                  result_l7policy_dicts):
+            provider_l7policy_dict = l7policy_dicts[0]
+            result_l7policy_dict = l7policy_dicts[1]
+            self._compare_l7policy_dicts(provider_l7policy_dict,
+                                         result_l7policy_dict)
+
+    def _compare_l7policy_dicts(self,
+                                provider_l7policy_dict,
+                                result_l7policy_dict):
+        for key in (lib_consts.L7POLICY_ID,
+                    lib_consts.LISTENER_ID,
+                    lib_consts.NAME,
+                    lib_consts.DESCRIPTION,
+                    lib_consts.PROJECT_ID,
+                    lib_consts.ADMIN_STATE_UP,
+                    lib_consts.ACTION,
+                    lib_consts.POSITION,
+                    lib_consts.REDIRECT_POOL_ID,
+                    lib_consts.REDIRECT_URL,
+                    lib_consts.REDIRECT_PREFIX,
+                    lib_consts.REDIRECT_HTTP_CODE):
+            self.assertEqual(provider_l7policy_dict.get(key),
+                             result_l7policy_dict.get(key))
+
+        provider_l7rule_dicts = provider_l7policy_dict.get(lib_consts.L7RULES)
+        result_l7rule_dicts = result_l7policy_dict.get(lib_consts.L7RULES)
+
+        if provider_l7rule_dicts or result_l7rule_dicts:
+            self.assertIsNotNone(provider_l7rule_dicts)
+            self.assertIsNotNone(result_l7rule_dicts)
+
+            self.assertEqual(len(provider_l7rule_dicts),
+                             len(result_l7rule_dicts))
+
+            for l7rule_dicts in zip(provider_l7rule_dicts,
+                                    result_l7rule_dicts):
+                provider_l7rule_dict = l7rule_dicts[0]
+                result_l7rule_dict = l7rule_dicts[1]
+                self._compare_l7rule_dicts(provider_l7rule_dict,
+                                           result_l7rule_dict)
+
+    def _compare_l7rule_dicts(self,
+                              provider_l7rule_dict,
+                              result_l7rule_dict):
+        for key in (lib_consts.L7RULE_ID,
+                    lib_consts.L7POLICY_ID,
+                    lib_consts.LISTENER_ID,
+                    lib_consts.NAME,
+                    lib_consts.DESCRIPTION,
+                    lib_consts.PROJECT_ID,
+                    lib_consts.ADMIN_STATE_UP,
+                    lib_consts.TYPE,
+                    lib_consts.COMPARE_TYPE,
+                    lib_consts.KEY,
+                    lib_consts.VALUE,
+                    lib_consts.INVERT):
+            self.assertEqual(provider_l7rule_dict.get(key),
+                             result_l7rule_dict.get(key))
+
+    def _compare_pool_dicts(self,
+                            provider_pool_dict,
+                            result_pool_dict):
+        for key in (lib_consts.POOL_ID,
+                    lib_consts.NAME,
+                    lib_consts.DESCRIPTION,
+                    lib_consts.PROJECT_ID,
+                    lib_consts.ADMIN_STATE_UP,
+                    lib_consts.LB_ALGORITHM,
+                    lib_consts.LOADBALANCER_ID,
+                    lib_consts.PROTOCOL,
+                    lib_consts.SESSION_PERSISTENCE,
+                    lib_consts.TLS_ENABLED,
+                    lib_consts.TLS_CONTAINER_REF,
+                    lib_consts.TLS_CONTAINER_DATA,
+                    lib_consts.CA_TLS_CONTAINER_REF,
+                    lib_consts.CA_TLS_CONTAINER_DATA,
+                    lib_consts.CRL_CONTAINER_REF,
+                    lib_consts.CRL_CONTAINER_DATA,
+                    lib_consts.TLS_CIPHERS,
+                    lib_consts.TLS_VERSIONS,
+                    lib_consts.ALPN_PROTOCOLS):
+            self.assertEqual(provider_pool_dict.get(key),
+                             result_pool_dict.get(key))
+
+        provider_hm_dict = provider_pool_dict.get(
+            lib_consts.HEALTHMONITOR)
+        result_hm_dict = result_pool_dict.get(
+            lib_consts.HEALTHMONITOR)
+        if provider_hm_dict or result_hm_dict:
+            self._compare_hm_dicts(provider_hm_dict,
+                                   result_hm_dict)
+
+        provider_member_dicts = provider_pool_dict.get(
+            lib_consts.MEMBERS)
+        result_member_dicts = result_pool_dict.get(
+            lib_consts.MEMBERS)
+        self.assertEqual(len(provider_member_dicts),
+                         len(result_member_dicts))
+
+        for member_dicts in zip(provider_member_dicts,
+                                result_member_dicts):
+            provider_member_dict = member_dicts[0]
+            result_member_dict = member_dicts[1]
+            self._compare_member_dicts(provider_member_dict,
+                                       result_member_dict)
+
+    def _compare_hm_dicts(self,
+                          provider_hm_dict,
+                          result_hm_dict):
+        for key in (lib_consts.HEALTHMONITOR_ID,
+                    lib_consts.POOL_ID,
+                    lib_consts.NAME,
+                    lib_consts.DESCRIPTION,
+                    lib_consts.PROJECT_ID,
+                    lib_consts.ADMIN_STATE_UP,
+                    lib_consts.TYPE,
+                    lib_consts.DELAY,
+                    lib_consts.TIMEOUT,
+                    lib_consts.MAX_RETRIES,
+                    lib_consts.MAX_RETRIES_DOWN,
+                    lib_consts.DOMAIN_NAME,
+                    lib_consts.EXPECTED_CODES,
+                    lib_consts.HTTP_METHOD,
+                    lib_consts.HTTP_VERSION,
+                    lib_consts.URL_PATH):
+            self.assertEqual(provider_hm_dict.get(key),
+                             result_hm_dict.get(key))
+
+    def _compare_member_dicts(self,
+                              provider_member_dict,
+                              result_member_dict):
+        for key in (lib_consts.MEMBER_ID,
+                    lib_consts.POOL_ID,
+                    lib_consts.NAME,
+                    lib_consts.DESCRIPTION,
+                    lib_consts.PROJECT_ID,
+                    lib_consts.ADMIN_STATE_UP,
+                    lib_consts.ADDRESS,
+                    lib_consts.PROTOCOL_PORT,
+                    lib_consts.MONITOR_ADDRESS,
+                    lib_consts.MONITOR_PORT,
+                    lib_consts.SUBNET_ID,
+                    lib_consts.WEIGHT,
+                    lib_consts.BACKUP):
+            self.assertEqual(provider_member_dict.get(key),
+                             result_member_dict.get(key))
+
     @mock.patch('octavia_lib.api.drivers.driver_lib.SOCKET_TIMEOUT', 30)
     def test_get_loadbalancer(self):
         result = self.driver_lib.get_loadbalancer(self.sample_data.lb_id)
+        result_dict = result.to_dict(render_unsets=True, recurse=True)
 
-        self.assertEqual(self.provider_lb_dict,
-                         result.to_dict(render_unsets=True, recurse=True))
+        self._compare_load_balancer_dicts(self.provider_lb_dict,
+                                          result_dict)
 
         # Test non-existent load balancer
         result = self.driver_lib.get_loadbalancer('bogus')
@@ -287,10 +524,10 @@ class DriverAgentTest(base.OctaviaDBTestBase):
     @mock.patch('octavia_lib.api.drivers.driver_lib.SOCKET_TIMEOUT', 30)
     def test_get_listener(self):
         result = self.driver_lib.get_listener(self.sample_data.listener1_id)
+        result_dict = result.to_dict(render_unsets=True, recurse=True)
 
-        # We need to recurse here to pick up the SNI data
-        self.assertEqual(self.provider_listener_dict,
-                         result.to_dict(render_unsets=True, recurse=True))
+        self._compare_listener_dicts(self.provider_listener_dict,
+                                     result_dict)
 
         # Test non-existent listener
         result = self.driver_lib.get_listener('bogus')
@@ -299,9 +536,10 @@ class DriverAgentTest(base.OctaviaDBTestBase):
     @mock.patch('octavia_lib.api.drivers.driver_lib.SOCKET_TIMEOUT', 30)
     def test_get_pool(self):
         result = self.driver_lib.get_pool(self.sample_data.pool1_id)
+        result_dict = result.to_dict(render_unsets=True, recurse=True)
 
-        self.assertEqual(self.provider_pool_dict,
-                         result.to_dict(render_unsets=True, recurse=True))
+        self._compare_pool_dicts(self.provider_pool_dict,
+                                 result_dict)
 
         # Test non-existent pool
         result = self.driver_lib.get_pool('bogus')
@@ -310,9 +548,10 @@ class DriverAgentTest(base.OctaviaDBTestBase):
     @mock.patch('octavia_lib.api.drivers.driver_lib.SOCKET_TIMEOUT', 30)
     def test_get_member(self):
         result = self.driver_lib.get_member(self.sample_data.member1_id)
+        result_dict = result.to_dict(render_unsets=True)
 
-        self.assertEqual(self.sample_data.provider_member1_dict,
-                         result.to_dict(render_unsets=True))
+        self._compare_member_dicts(self.sample_data.provider_member1_dict,
+                                   result_dict)
 
         # Test non-existent member
         result = self.driver_lib.get_member('bogus')
@@ -321,9 +560,10 @@ class DriverAgentTest(base.OctaviaDBTestBase):
     @mock.patch('octavia_lib.api.drivers.driver_lib.SOCKET_TIMEOUT', 30)
     def test_get_healthmonitor(self):
         result = self.driver_lib.get_healthmonitor(self.sample_data.hm1_id)
+        result_dict = result.to_dict(render_unsets=True)
 
-        self.assertEqual(self.sample_data.provider_hm1_dict,
-                         result.to_dict(render_unsets=True))
+        self._compare_hm_dicts(self.sample_data.provider_hm1_dict,
+                               result_dict)
 
         # Test non-existent health monitor
         result = self.driver_lib.get_healthmonitor('bogus')
@@ -332,9 +572,11 @@ class DriverAgentTest(base.OctaviaDBTestBase):
     @mock.patch('octavia_lib.api.drivers.driver_lib.SOCKET_TIMEOUT', 30)
     def test_get_l7policy(self):
         result = self.driver_lib.get_l7policy(self.sample_data.l7policy1_id)
+        result_dict = result.to_dict(render_unsets=True, recurse=True)
 
-        self.assertEqual(self.sample_data.provider_l7policy1_dict,
-                         result.to_dict(render_unsets=True, recurse=True))
+        self._compare_l7policy_dicts(
+            self.sample_data.provider_l7policy1_dict,
+            result_dict)
 
         # Test non-existent L7 policy
         result = self.driver_lib.get_l7policy('bogus')
@@ -343,9 +585,11 @@ class DriverAgentTest(base.OctaviaDBTestBase):
     @mock.patch('octavia_lib.api.drivers.driver_lib.SOCKET_TIMEOUT', 30)
     def test_get_l7rule(self):
         result = self.driver_lib.get_l7rule(self.sample_data.l7rule1_id)
+        result_dict = result.to_dict(render_unsets=True)
 
-        self.assertEqual(self.sample_data.provider_l7rule1_dict,
-                         result.to_dict(render_unsets=True))
+        self._compare_l7rule_dicts(
+            self.sample_data.provider_l7rule1_dict,
+            result_dict)
 
         # Test non-existent L7 rule
         result = self.driver_lib.get_l7rule('bogus')
@@ -355,6 +599,7 @@ class DriverAgentTest(base.OctaviaDBTestBase):
         # Add a new member
         member_dict = copy.deepcopy(self.sample_data.test_member2_dict)
         self.repos.member.create(self.session, **member_dict)
+        self.session.commit()
 
         result = self.driver_lib.get_member(member_dict[lib_consts.ID])
         self.assertEqual(self.sample_data.provider_member2_dict,

octavia/tests/functional/api/test_root_controller.py

@@ -45,34 +45,9 @@ class TestRootController(base_db_test.OctaviaDBTestBase):
     def test_api_versions(self):
         versions = self._get_versions_with_config()
         version_ids = tuple(v.get('id') for v in versions)
-        self.assertEqual(27, len(version_ids))
-        self.assertIn('v2.0', version_ids)
-        self.assertIn('v2.1', version_ids)
-        self.assertIn('v2.2', version_ids)
-        self.assertIn('v2.3', version_ids)
-        self.assertIn('v2.4', version_ids)
-        self.assertIn('v2.5', version_ids)
-        self.assertIn('v2.6', version_ids)
-        self.assertIn('v2.7', version_ids)
-        self.assertIn('v2.8', version_ids)
-        self.assertIn('v2.9', version_ids)
-        self.assertIn('v2.10', version_ids)
-        self.assertIn('v2.11', version_ids)
-        self.assertIn('v2.12', version_ids)
-        self.assertIn('v2.13', version_ids)
-        self.assertIn('v2.14', version_ids)
-        self.assertIn('v2.15', version_ids)
-        self.assertIn('v2.16', version_ids)
-        self.assertIn('v2.17', version_ids)
-        self.assertIn('v2.18', version_ids)
-        self.assertIn('v2.19', version_ids)
-        self.assertIn('v2.20', version_ids)
-        self.assertIn('v2.21', version_ids)
-        self.assertIn('v2.22', version_ids)
-        self.assertIn('v2.23', version_ids)
-        self.assertIn('v2.24', version_ids)
-        self.assertIn('v2.25', version_ids)
-        self.assertIn('v2.26', version_ids)
+        expected_versions = (f"v2.{i}" for i in range(28))
+        for version in expected_versions:
+            self.assertIn(version, version_ids)
 
         # Each version should have a 'self' 'href' to the API version URL
         # [{u'rel': u'self', u'href': u'http://localhost/v2'}]

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

@@ -269,7 +269,7 @@ class BaseAPITest(base_db_test.OctaviaDBTestBase):
 
     def create_listener_stats(self, listener_id, amphora_id):
         db_ls = self.listener_stats_repo.create(
-            db_api.get_session(), listener_id=listener_id,
+            self.session, listener_id=listener_id,
             amphora_id=amphora_id, bytes_in=0,
             bytes_out=0, active_connections=0, total_connections=0,
             request_errors=0)
@@ -280,7 +280,7 @@ class BaseAPITest(base_db_test.OctaviaDBTestBase):
                                       active_connections=0,
                                       total_connections=0, request_errors=0):
         db_ls = self.listener_stats_repo.create(
-            db_api.get_session(), listener_id=listener_id,
+            self.session, listener_id=listener_id,
             amphora_id=amphora_id, bytes_in=bytes_in,
             bytes_out=bytes_out, active_connections=active_connections,
             total_connections=total_connections, request_errors=request_errors)
@@ -478,9 +478,11 @@ class BaseAPITest(base_db_test.OctaviaDBTestBase):
     @staticmethod
     def set_object_status(repo, id_, provisioning_status=constants.ACTIVE,
                           operating_status=constants.ONLINE):
-        repo.update(db_api.get_session(), id_,
+        session = db_api.get_session()
+        repo.update(session, id_,
                     provisioning_status=provisioning_status,
                     operating_status=operating_status)
+        session.commit()
 
     def assert_final_listener_statuses(self, lb_id, listener_id, delete=False):
         expected_prov_status = constants.ACTIVE

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

@@ -40,6 +40,7 @@ class TestAmphora(base.BaseAPITest):
         self.project_id = self.lb.get('project_id')
         self.set_lb_status(self.lb_id)
         self.amp_args = {
+            'id': uuidutils.generate_uuid(),
             'load_balancer_id': self.lb_id,
             'compute_id': uuidutils.generate_uuid(),
             'lb_network_ip': '192.168.1.2',
@@ -91,9 +92,11 @@ class TestAmphora(base.BaseAPITest):
                                     'total_connections': 9}
         self.ref_amp_stats = [self.listener1_amp_stats,
                               self.listener2_amp_stats]
+        self.session.commit()
 
     def _create_additional_amp(self):
         amp_args = {
+            'id': uuidutils.generate_uuid(),
             'load_balancer_id': None,
             'compute_id': uuidutils.generate_uuid(),
             'lb_network_ip': '192.168.1.2',
@@ -109,7 +112,8 @@ class TestAmphora(base.BaseAPITest):
             'vrrp_id': 1,
             'vrrp_priority': 100,
         }
-        return self.amphora_repo.create(self.session, **amp_args)
+        with self.session.begin():
+            return self.amphora_repo.create(self.session, **amp_args)
 
     def _assert_amp_equal(self, source, response):
         self.assertEqual(source.pop('load_balancer_id'),
@@ -130,9 +134,11 @@ class TestAmphora(base.BaseAPITest):
     @mock.patch('oslo_messaging.RPCClient.cast')
     def test_delete(self, mock_cast):
         self.amp_args = {
+            'id': uuidutils.generate_uuid(),
             'status': constants.AMPHORA_READY,
         }
-        amp = self.amphora_repo.create(self.session, **self.amp_args)
+        with self.session.begin():
+            amp = self.amphora_repo.create(self.session, **self.amp_args)
 
         self.delete(self.AMPHORA_PATH.format(
             amphora_id=amp.id), status=204)
@@ -154,9 +160,11 @@ class TestAmphora(base.BaseAPITest):
     @mock.patch('oslo_messaging.RPCClient.cast')
     def test_delete_immutable(self, mock_cast):
         self.amp_args = {
+            'id': uuidutils.generate_uuid(),
             'status': constants.AMPHORA_ALLOCATED,
         }
-        amp = self.amphora_repo.create(self.session, **self.amp_args)
+        with self.session.begin():
+            amp = self.amphora_repo.create(self.session, **self.amp_args)
 
         self.delete(self.AMPHORA_PATH.format(
             amphora_id=amp.id), status=409)
@@ -166,9 +174,11 @@ class TestAmphora(base.BaseAPITest):
     @mock.patch('oslo_messaging.RPCClient.cast')
     def test_delete_authorized(self, mock_cast):
         self.amp_args = {
+            'id': uuidutils.generate_uuid(),
             'status': constants.AMPHORA_READY,
         }
-        amp = self.amphora_repo.create(self.session, **self.amp_args)
+        with self.session.begin():
+            amp = self.amphora_repo.create(self.session, **self.amp_args)
 
         self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
         auth_strategy = self.conf.conf.api_settings.get('auth_strategy')
@@ -208,9 +218,11 @@ class TestAmphora(base.BaseAPITest):
     @mock.patch('oslo_messaging.RPCClient.cast')
     def test_delete_not_authorized(self, mock_cast):
         self.amp_args = {
+            'id': uuidutils.generate_uuid(),
             'status': constants.AMPHORA_READY,
         }
-        amp = self.amphora_repo.create(self.session, **self.amp_args)
+        with self.session.begin():
+            amp = self.amphora_repo.create(self.session, **self.amp_args)
 
         self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
         auth_strategy = self.conf.conf.api_settings.get('auth_strategy')
@@ -567,6 +579,7 @@ class TestAmphora(base.BaseAPITest):
         self.lb2_id = self.lb2.get('id')
         self.set_lb_status(self.lb2_id)
         self.amp2_args = {
+            'id': uuidutils.generate_uuid(),
             'load_balancer_id': self.lb2_id,
             'compute_id': uuidutils.generate_uuid(),
             'lb_network_ip': '192.168.1.20',

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

@@ -531,6 +531,7 @@ class TestAvailabilityZoneProfiles(base.BaseAPITest):
     def test_delete_authorized(self):
         azp = self.create_availability_zone_profile(
             'test1', 'noop_driver', '{"compute_zone": "my_az_1"}')
+        self.session.commit()
         self.assertTrue(uuidutils.is_uuid_like(azp.get('id')))
         self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
         auth_strategy = self.conf.conf.api_settings.get('auth_strategy')

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

@@ -1207,9 +1207,9 @@ class TestListener(base.BaseAPITest):
                       "It must be a valid x509 PEM format certificate.",
                       response['faultstring'])
 
-    def _test_create_with_allowed_cidrs(self, allowed_cidrs):
+    def _test_create_with_allowed_cidrs(self, allowed_cidrs, lb_id):
         listener = self.create_listener(constants.PROTOCOL_TCP,
-                                        80, self.lb_id,
+                                        80, lb_id,
                                         allowed_cidrs=allowed_cidrs)
         listener_path = self.LISTENER_PATH.format(
             listener_id=listener['listener']['id'])
@@ -1218,14 +1218,17 @@ class TestListener(base.BaseAPITest):
 
     def test_create_with_allowed_cidrs_ipv4(self):
         allowed_cidrs = ['10.0.1.0/24', '172.16.55.0/25']
-        self._test_create_with_allowed_cidrs(allowed_cidrs)
+        self._test_create_with_allowed_cidrs(allowed_cidrs, self.lb_id)
 
     def test_create_with_allowed_cidrs_ipv6(self):
+        lb_ipv6 = self.create_load_balancer(
+            uuidutils.generate_uuid(),
+            vip_address='2001:db9:a1b:13f0::1',
+        )
+        lb_id = lb_ipv6.get('loadbalancer').get('id')
+        self.set_lb_status(lb_id)
         allowed_cidrs = ['2001:db8:a0b:12f0::/64', '2a02:8071:69e::/64']
-        with mock.patch('octavia.db.repositories.VipRepository.'
-                        'get') as repo_mock:
-            repo_mock.return_value.ip_address = "2001:db9:a1b:13f0::1"
-            self._test_create_with_allowed_cidrs(allowed_cidrs)
+        self._test_create_with_allowed_cidrs(allowed_cidrs, lb_id)
 
     def test_create_with_bad_allowed_cidrs(self):
         allowed_cidrs = [u'10.0.1.0/33', u'172.16.55.1.0/25']
@@ -1251,24 +1254,42 @@ class TestListener(base.BaseAPITest):
         body = self._build_body(lb_listener)
         response = self.post(self.LISTENERS_PATH, body, status=400).json
         self.assertIn("Validation failure: CIDR 2001:db8:a0b:12f0::/64 IP "
-                      "version incompatible with VIP 198.0.2.5 IP version.",
+                      "version incompatible with all VIPs ['198.0.2.5'] IP "
+                      "version.",
                       response['faultstring'])
 
     def test_create_with_incompatible_allowed_cidrs_ipv4(self):
+        lb_ipv6 = self.create_load_balancer(
+            uuidutils.generate_uuid(),
+            vip_address='2001:db9:a1b:13f0::1',
+        )
+        lb_id = lb_ipv6.get('loadbalancer').get('id')
+        self.set_lb_status(lb_id)
         lb_listener = {
             'protocol': constants.PROTOCOL_TCP,
             'protocol_port': 80,
             'project_id': self.project_id,
-            'loadbalancer_id': self.lb_id,
+            'loadbalancer_id': lb_id,
             'allowed_cidrs': ['10.0.1.0/24']}
-        with mock.patch('octavia.db.repositories.VipRepository.'
-                        'get') as repo_mock:
-            repo_mock.return_value.ip_address = "2001:db9:a1b:13f0::1"
-            body = self._build_body(lb_listener)
-            response = self.post(self.LISTENERS_PATH, body, status=400).json
-            self.assertIn("Validation failure: CIDR 10.0.1.0/24 IP version "
-                          "incompatible with VIP 2001:db9:a1b:13f0::1 IP "
-                          "version.", response['faultstring'])
+        body = self._build_body(lb_listener)
+        response = self.post(self.LISTENERS_PATH, body, status=400).json
+        self.assertIn("Validation failure: CIDR 10.0.1.0/24 IP version "
+                      "incompatible with all VIPs "
+                      "['2001:db9:a1b:13f0::1'] IP version.",
+                      response['faultstring'])
+
+    def test_create_with_mixed_version_allowed_cidrs(self):
+        lb_dualstack = self.create_load_balancer(
+            uuidutils.generate_uuid(),
+            additional_vips=[{'subnet_id': uuidutils.generate_uuid(),
+                              'ip_address': '2001:db9:a1b:13f0::1',
+                              }],
+        )
+        lb_id = lb_dualstack.get('loadbalancer').get('id')
+        self.set_lb_status(lb_id)
+        self._test_create_with_allowed_cidrs(['10.0.1.0/24',
+                                              '2001:db9:a1b:13f0::/64'],
+                                             lb_id)
 
     def test_create_with_duplicated_allowed_cidrs(self):
         allowed_cidrs = ['10.0.1.0/24', '10.0.2.0/24', '10.0.2.0/24']
@@ -1873,7 +1894,10 @@ class TestListener(base.BaseAPITest):
             client_ca_tls_container_ref=ca_tls_uuid,
             tls_versions=[lib_consts.TLS_VERSION_1_3],
             tls_ciphers='TLS_AES_256_GCM_SHA384',
-            alpn_protocols=['http/1.0']).get(self.root_tag)
+            alpn_protocols=['http/1.0'],
+            hsts_max_age=20, hsts_include_subdomains=True,
+            hsts_preload=True,
+        ).get(self.root_tag)
         self.set_lb_status(self.lb_id)
         unset_params = {
             'name': None, 'description': None, 'connection_limit': None,
@@ -1883,7 +1907,10 @@ class TestListener(base.BaseAPITest):
             'timeout_tcp_inspect': None, 'client_ca_tls_container_ref': None,
             'client_authentication': None, 'default_pool_id': None,
             'client_crl_container_ref': None, 'tls_versions': None,
-            'tls_ciphers': None, 'alpn_protocols': None}
+            'tls_ciphers': None, 'alpn_protocols': None,
+            'hsts_max_age': None, 'hsts_include_subdomains': None,
+            'hsts_preload': None,
+        }
         body = self._build_body(unset_params)
         listener_path = self.LISTENER_PATH.format(
             listener_id=listener['id'])
@@ -1910,6 +1937,9 @@ class TestListener(base.BaseAPITest):
         self.assertEqual(constants.CIPHERS_OWASP_SUITE_B,
                          api_listener['tls_ciphers'])
         self.assertEqual(['http/1.1'], api_listener['alpn_protocols'])
+        self.assertIsNone(api_listener['hsts_max_age'])
+        self.assertFalse(api_listener['hsts_include_subdomains'])
+        self.assertFalse(api_listener['hsts_preload'])
 
     @mock.patch('octavia.common.tls_utils.cert_parser.load_certificates_data')
     def test_update_with_bad_ca_cert(self, mock_cert_data):
@@ -2811,6 +2841,7 @@ class TestListener(base.BaseAPITest):
             bytes_out=random.randint(1, 9),
             total_connections=random.randint(1, 9),
             request_errors=random.randint(1, 9))
+        self.session.commit()
 
         response = self._getStats(li['id'])
         self.assertEqual(ls['bytes_in'], response['bytes_in'])
@@ -2841,6 +2872,7 @@ class TestListener(base.BaseAPITest):
         self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
         auth_strategy = self.conf.conf.api_settings.get('auth_strategy')
         self.conf.config(group='api_settings', auth_strategy=constants.TESTING)
+        self.session.commit()
 
         with mock.patch.object(octavia.common.context.RequestContext,
                                'project_id',