openstack
/
keystone
Code Issues Proposed changes

Remove driver version specifiers from tests 

Now that we no longer support driver versioning, we don't need to
specify specific driver versioning in our tests. Unwinding this code.

Change-Id: I25d1202ada6b9e2806e102aa22e22ccc77429a53
This commit is contained in:
Ronald De Rose 2016-10-06 20:58:25 +00:00 committed by Ron De Rose
parent 4888a11c4d
commit 76d588be55
9 changed files with 13 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
keystone/tests/unit/core.py
View File

@ -647,7 +647,6 @@ class TestCase(BaseTestCase):
keystone.conf.auth, '_register_auth_plugin_opt',
new=mocked_register_auth_plugin_opt))
self.sql_driver_version_overrides = {}
self.config_overrides()
# NOTE(morganfainberg): ensure config_overrides has been called.
self.addCleanup(self._assert_config_overrides_called)
@ -874,20 +873,3 @@ class SQLDriverOverrides(object):
self.config_fixture.config(group='policy', driver='sql')
self.config_fixture.config(group='token', driver='sql')
self.config_fixture.config(group='trust', driver='sql')
def use_specific_sql_driver_version(self, driver_path,
versionless_backend, version_suffix):
"""Add this versioned driver to the list that will be loaded.
:param driver_path: The path to the drivers, e.g. 'keystone.assignment'
:param versionless_backend: The name of the versionless drivers, e.g.
'backends'
:param version_suffix: The suffix for the version , e.g. ``V8_``
This method assumes that versioned drivers are named:
<version_suffix><name of versionless driver>, e.g. 'V8_backends'.
"""
self.sql_driver_version_overrides[driver_path] = {
'versionless_backend': versionless_backend,
'versioned_backend': version_suffix + versionless_backend}

4
keystone/tests/unit/identity/backends/test_ldap_common.py
View File

@ -208,7 +208,7 @@ class LDAPDeleteTreeTest(unit.TestCase):
self.useFixture(
ldapdb.LDAPDatabase(dbclass=fakeldap.FakeLdapNoSubtreeDelete))
self.useFixture(database.Database(self.sql_driver_version_overrides))
self.useFixture(database.Database())
self.load_backends()
self.load_fixtures(default_fixtures)
@ -371,7 +371,7 @@ class LDAPPagedResultsTest(unit.TestCase):
super(LDAPPagedResultsTest, self).setUp()
self.useFixture(ldapdb.LDAPDatabase())
self.useFixture(database.Database(self.sql_driver_version_overrides))
self.useFixture(database.Database())
self.load_backends()
self.load_fixtures(default_fixtures)

3
keystone/tests/unit/identity/backends/test_sql.py
View File

@ -40,8 +40,7 @@ class TestIdentityDriver(db_test.DbTestCase,
sql.core, '_TESTING_USE_GLOBAL_CONTEXT_MANAGER', False)
self.addCleanup(sql.cleanup)
version_specifiers = {}
database._load_sqlalchemy_models(version_specifiers)
database._load_sqlalchemy_models()
sql.ModelBase.metadata.create_all(bind=self.engine)
self.driver = sql_backend.Identity()

56
keystone/tests/unit/ksfixtures/database.py
View File

@ -32,9 +32,9 @@ def run_once(f):
"""
@functools.wraps(f)
def wrapper(one):
def wrapper():
if not wrapper.already_ran:
f(one)
f()
wrapper.already_ran = True
wrapper.already_ran = False
return wrapper
@ -52,7 +52,7 @@ def initialize_sql_session(connection_str=unit.IN_MEM_DB_CONN_STRING):
@run_once
def _load_sqlalchemy_models(version_specifiers):
def _load_sqlalchemy_models():
"""Find all modules containing SQLAlchemy models and import them.
This creates more consistent, deterministic test runs because tables
@ -67,24 +67,6 @@ def _load_sqlalchemy_models(version_specifiers):
as more models are imported. Importing all models at the start of
the test run avoids this problem.
version_specifiers is a dict that contains any specific driver versions
that have been requested. The dict is of the form:
{<module_name> : {'versioned_backend' : <name of backend requested>,
'versionless_backend' : <name of default backend>}
}
For example:
{'keystone.assignment': {'versioned_backend' : 'V8_backends',
'versionless_backend' : 'backends'},
'keystone.identity': {'versioned_backend' : 'V9_backends',
'versionless_backend' : 'backends'}
}
The version_specifiers will be used to load the correct driver. The
algorithm for this assumes that versioned drivers begin in 'V'.
"""
keystone_root = os.path.normpath(os.path.join(
os.path.dirname(__file__), '..', '..', '..'))
@ -104,32 +86,6 @@ def _load_sqlalchemy_models(version_specifiers):
for x in range(0, len(module_components) - 1):
module_without_backends += module_components[x] + '.'
module_without_backends = module_without_backends.rstrip('.')
this_backend = module_components[len(module_components) - 1]
# At this point module_without_backends might be something like
# 'keystone.assignment', while this_backend might be something
# 'V8_backends'.
if module_without_backends.startswith('keystone.contrib'):
# All the sql modules have now been moved into the core tree
# so no point in loading these again here (and, in fact, doing
# so might break trying to load a versioned driver.
continue
if module_without_backends in version_specifiers:
# OK, so there is a request for a specific version of this one.
# We therefore should skip any other versioned backend as well
# as the non-versioned one.
version = version_specifiers[module_without_backends]
if ((this_backend != version['versioned_backend'] and
this_backend.startswith('V')) or
this_backend == version['versionless_backend']):
continue
else:
# No versioned driver requested, so ignore any that are
# versioned
if this_backend.startswith('V'):
continue
module_name = module_root + '.sql'
__import__(module_name)
@ -138,12 +94,10 @@ def _load_sqlalchemy_models(version_specifiers):
class Database(fixtures.Fixture):
"""A fixture for setting up and tearing down a database."""
def __init__(self, version_specifiers=None):
def __init__(self):
super(Database, self).__init__()
initialize_sql_session()
if version_specifiers is None:
version_specifiers = {}
_load_sqlalchemy_models(version_specifiers)
_load_sqlalchemy_models()
def setUp(self):
super(Database, self).setUp()

2
keystone/tests/unit/resource/test_core.py
View File

@ -30,7 +30,7 @@ class TestResourceManagerNoFixtures(unit.SQLDriverOverrides, unit.TestCase):
def setUp(self):
super(TestResourceManagerNoFixtures, self).setUp()
self.useFixture(database.Database(self.sql_driver_version_overrides))
self.useFixture(database.Database())
self.load_backends()
def test_ensure_default_domain_exists(self):

2
keystone/tests/unit/rest.py
View File

@ -57,7 +57,7 @@ class RestfulTestCase(unit.TestCase):
self.auth_plugin_config_override()
self.useFixture(database.Database(self.sql_driver_version_overrides))
self.useFixture(database.Database())
self.load_backends()
self.load_fixtures(default_fixtures)

2
keystone/tests/unit/test_backend_kvs.py
View File

@ -108,7 +108,7 @@ class KvsTokenCacheInvalidation(unit.TestCase,
token_tests.TokenCacheInvalidation):
def setUp(self):
super(KvsTokenCacheInvalidation, self).setUp()
self.useFixture(database.Database(self.sql_driver_version_overrides))
self.useFixture(database.Database())
self.load_backends()
self._create_test_data()

2
keystone/tests/unit/test_backend_ldap.py
View File

@ -1946,7 +1946,7 @@ class LDAPLimitTests(unit.TestCase, identity_tests.LimitTests):
super(LDAPLimitTests, self).setUp()
self.useFixture(ldapdb.LDAPDatabase())
self.useFixture(database.Database(self.sql_driver_version_overrides))
self.useFixture(database.Database())
self.load_backends()
self.load_fixtures(default_fixtures)
identity_tests.LimitTests.setUp(self)

2
keystone/tests/unit/test_backend_sql.py
View File

@ -52,7 +52,7 @@ class SqlTests(unit.SQLDriverOverrides, unit.TestCase):
def setUp(self):
super(SqlTests, self).setUp()
self.useFixture(database.Database(self.sql_driver_version_overrides))
self.useFixture(database.Database())
self.load_backends()
# populate the engine with tables & fixtures