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

keystone/tests/unit/core.py

@@ -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}

keystone/tests/unit/identity/backends/test_ldap_common.py

@@ -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)

keystone/tests/unit/identity/backends/test_sql.py

@@ -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()
-        database._load_sqlalchemy_models(version_specifiers)
         sql.ModelBase.metadata.create_all(bind=self.engine)
 
         self.driver = sql_backend.Identity()

keystone/tests/unit/ksfixtures/database.py

@@ -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:
+        _load_sqlalchemy_models()
-            version_specifiers = {}
-        _load_sqlalchemy_models(version_specifiers)
 
     def setUp(self):
         super(Database, self).setUp()

keystone/tests/unit/resource/test_core.py

@@ -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):

keystone/tests/unit/rest.py

@@ -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)
 

keystone/tests/unit/test_backend_kvs.py

@@ -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()
 

keystone/tests/unit/test_backend_ldap.py

@@ -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)

keystone/tests/unit/test_backend_sql.py

@@ -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