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

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

@@ -2657,6 +2657,10 @@ class TestLoadBalancer(base.BaseAPITest):
             prov='bad_driver', user_msg='broken')
         self.delete(self.LB_PATH.format(lb_id=api_lb.get('id')), status=501)
 
+        response = self.get(self.LB_PATH.format(
+            lb_id=api_lb.get('id'))).json.get(self.root_tag)
+        self.assertEqual(constants.ACTIVE, response['provisioning_status'])
+
     @mock.patch('octavia.api.drivers.utils.call_provider')
     def test_create_with_provider_unsupport_option(self, mock_provider):
         mock_provider.side_effect = exceptions.ProviderUnsupportedOptionError(
@@ -2879,7 +2883,10 @@ class TestLoadBalancerGraph(base.BaseAPITest):
             'allowed_cidrs': None,
             'tls_ciphers': None,
             'tls_versions': None,
-            'alpn_protocols': None
+            'alpn_protocols': None,
+            'hsts_include_subdomains': False,
+            'hsts_max_age': None,
+            'hsts_preload': False,
         }
         if create_sni_containers:
             create_listener['sni_container_refs'] = create_sni_containers
@@ -4045,6 +4052,7 @@ class TestLoadBalancerGraph(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(lb['id'])
         self.assertEqual(ls['bytes_in'], response['bytes_in'])
@@ -4072,6 +4080,7 @@ class TestLoadBalancerGraph(base.BaseAPITest):
             bytes_out=random.randint(1, 9),
             total_connections=random.randint(1, 9),
             request_errors=random.randint(1, 9))
+        self.session.commit()
 
         auth_strategy = self.conf.conf.api_settings.get('auth_strategy')
         self.conf.config(group='api_settings', auth_strategy=constants.TESTING)

octavia/tests/functional/db/base.py

@@ -25,11 +25,17 @@ from octavia.db import api as db_api
 from octavia.db import base_models
 from octavia.db import models
 
+from octavia.tests import fixtures as oc_fixtures
+
 
 class OctaviaDBTestBase(test_base.BaseTestCase):
 
     def setUp(self, connection_string='sqlite://'):
         super().setUp()
+
+        self.connection_string = connection_string
+        self.warning_fixture = self.useFixture(oc_fixtures.WarningsFixture())
+
         # NOTE(blogan): doing this for now because using the engine and
         # session set up in the fixture for test_base.DbTestCase does not work
         # with the API functional tests.  Need to investigate more if this
@@ -37,21 +43,17 @@ class OctaviaDBTestBase(test_base.BaseTestCase):
         conf = self.useFixture(oslo_fixture.Config(config.cfg.CONF))
         conf.config(group="database", connection=connection_string)
 
-        # We need to get our own Facade so that the file backed sqlite tests
-        # don't use the _FACADE singleton. Some tests will use in-memory
-        # sqlite, some will use a file backed sqlite.
-        if 'sqlite:///' in connection_string:
-            facade = db_session.EngineFacade.from_config(cfg.CONF,
-                                                         sqlite_fk=True)
-            engine = facade.get_engine()
-            self.session = facade.get_session(expire_on_commit=True,
-                                              autocommit=True)
-        else:
-            engine = db_api.get_engine()
-            self.session = db_api.get_session()
+        # Disable pool_timeout when using sqlite with a file
+        # pool_timeout is not support by sqlalchemy 2 with SQLite/NullPool
+        if connection_string.startswith('sqlite:///'):
+            conf.config(group="database", pool_timeout=None)
+
+        engine, self.session = self._get_db_engine_session()
 
         base_models.BASE.metadata.create_all(engine)
-        self._seed_lookup_tables(self.session)
+
+        with self.session.begin():
+            self._seed_lookup_tables(self.session)
 
         def clear_tables():
             """Unregister all data models."""
@@ -62,6 +64,20 @@ class OctaviaDBTestBase(test_base.BaseTestCase):
 
         self.addCleanup(clear_tables)
 
+    def _get_db_engine_session(self):
+        # We need to get our own Facade so that the file backed sqlite tests
+        # 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)
+        else:
+            engine = db_api.get_engine()
+            session = db_api.get_session()
+        return engine, session
+
     def _seed_lookup_tables(self, session):
         self._seed_lookup_table(
             session, constants.SUPPORTED_PROVISIONING_STATUSES,
@@ -123,6 +139,5 @@ class OctaviaDBTestBase(test_base.BaseTestCase):
 
     def _seed_lookup_table(self, session, name_list, model_cls):
         for name in name_list:
-            with session.begin():
-                model = model_cls(name=name)
-                session.add(model)
+            model = model_cls(name=name)
+            session.add(model)

octavia/tests/functional/db/test_models.py

@@ -32,9 +32,9 @@ class ModelTestMixin(object):
     FAKE_AZ = 'zone1'
 
     def _insert(self, session, model_cls, model_kwargs):
-        with session.begin():
-            model = model_cls(**model_kwargs)
-            session.add(model)
+        model = model_cls(**model_kwargs)
+        session.add(model)
+        session.commit()
         return model
 
     def create_flavor_profile(self, session, **overrides):
@@ -230,9 +230,8 @@ class PoolModelTest(base.OctaviaDBTestBase, ModelTestMixin):
     def test_delete(self):
         pool = self.create_pool(self.session)
         id = pool.id
-        with self.session.begin():
-            self.session.delete(pool)
-            self.session.flush()
+        self.session.delete(pool)
+        self.session.commit()
         new_pool = self.session.query(
             models.Pool).filter_by(id=id).first()
         self.assertIsNone(new_pool)
@@ -302,6 +301,7 @@ class MemberModelTest(base.OctaviaDBTestBase, ModelTestMixin):
 
         member_id = member.id
         member.enabled = False
+        self.session.commit()
 
         new_member = self.session.query(
             models.Member).filter_by(id=member_id).first()
@@ -311,9 +311,11 @@ class MemberModelTest(base.OctaviaDBTestBase, ModelTestMixin):
     def test_delete(self):
         member = self.create_member(self.session, self.pool.id)
         member_id = member.id
-        with self.session.begin():
-            self.session.delete(member)
-            self.session.flush()
+        self.session.commit()
+
+        self.session.delete(member)
+        self.session.commit()
+
         new_member = self.session.query(
             models.Member).filter_by(id=member_id).first()
         self.assertIsNone(new_member)
@@ -424,9 +426,8 @@ class ListenerModelTest(base.OctaviaDBTestBase, ModelTestMixin):
     def test_delete(self):
         listener = self.create_listener(self.session)
         listener_id = listener.id
-        with self.session.begin():
-            self.session.delete(listener)
-            self.session.flush()
+        self.session.delete(listener)
+        self.session.commit()
         new_listener = self.session.query(
             models.Listener).filter_by(id=listener_id).first()
         self.assertIsNone(new_listener)
@@ -578,9 +579,8 @@ class LoadBalancerModelTest(base.OctaviaDBTestBase, ModelTestMixin):
     def test_delete(self):
         load_balancer = self.create_load_balancer(self.session)
         lb_id = load_balancer.id
-        with self.session.begin():
-            self.session.delete(load_balancer)
-            self.session.flush()
+        self.session.delete(load_balancer)
+        self.session.commit()
         new_load_balancer = self.session.query(
             models.LoadBalancer).filter_by(id=lb_id).first()
         self.assertIsNone(new_load_balancer)
@@ -745,7 +745,7 @@ class AmphoraHealthModelTest(base.OctaviaDBTestBase, ModelTestMixin):
         new_amphora_health = self.session.query(
             models.AmphoraHealth).filter_by(
             amphora_id=amphora_health.amphora_id).first()
-        self.assertEqual(newdate, new_amphora_health.last_update.date())
+        self.assertEqual(newdate, new_amphora_health.last_update)
 
     def test_delete(self):
         amphora_health = self.create_amphora_health(
@@ -787,9 +787,8 @@ class L7PolicyModelTest(base.OctaviaDBTestBase, ModelTestMixin):
     def test_delete(self):
         l7policy = self.create_l7policy(self.session, self.listener.id)
         l7policy_id = l7policy.id
-        with self.session.begin():
-            self.session.delete(l7policy)
-            self.session.flush()
+        self.session.delete(l7policy)
+        self.session.commit()
         new_l7policy = self.session.query(
             models.L7Policy).filter_by(id=l7policy_id).first()
         self.assertIsNone(new_l7policy)
@@ -908,9 +907,8 @@ class L7RuleModelTest(base.OctaviaDBTestBase, ModelTestMixin):
     def test_delete(self):
         l7rule = self.create_l7rule(self.session, self.l7policy.id)
         l7rule_id = l7rule.id
-        with self.session.begin():
-            self.session.delete(l7rule)
-            self.session.flush()
+        self.session.delete(l7rule)
+        self.session.commit()
         new_l7rule = self.session.query(
             models.L7Rule).filter_by(id=l7rule_id).first()
         self.assertIsNone(new_l7rule)
@@ -1825,10 +1823,11 @@ class FlavorModelTest(base.OctaviaDBTestBase, ModelTestMixin):
         flavor = self.create_flavor(self.session, self.profile.id)
         self.assertIsNotNone(flavor.id)
         id = flavor.id
+        self.session.commit()
+
+        self.session.delete(flavor)
+        self.session.commit()
 
-        with self.session.begin():
-            self.session.delete(flavor)
-            self.session.flush()
         new_flavor = self.session.query(
             models.Flavor).filter_by(id=id).first()
         self.assertIsNone(new_flavor)
@@ -1847,10 +1846,10 @@ class FlavorProfileModelTest(base.OctaviaDBTestBase, ModelTestMixin):
         fp = self.create_flavor_profile(self.session)
         self.assertIsNotNone(fp.id)
         id = fp.id
+        self.session.commit()
 
-        with self.session.begin():
-            self.session.delete(fp)
-            self.session.flush()
+        self.session.delete(fp)
+        self.session.commit()
         new_fp = self.session.query(
             models.FlavorProfile).filter_by(id=id).first()
         self.assertIsNone(new_fp)