remove the extra parameter 'db_type' in section [DEFAULT]

Change-Id: Id9870f57373f9f2f7045b86703c3cd8e9447d1b7
Signed-off-by: WangChangyu <wang.changyu@zte.com.cn>

zun/conf/database.py

@@ -15,14 +15,6 @@
 from oslo_config import cfg
 
 
-db_opts = [
-    # TODO(yuywz): Change to etcd after all etcd db driver code is landed
-    cfg.StrOpt('db_type',
-               default='sql',
-               help='Defines which db type to use for storing container. '
-                    'Possible Values: sql, etcd')
-]
-
 sql_opts = [
     cfg.StrOpt('mysql_engine',
                default='InnoDB',
@@ -42,12 +34,11 @@ etcd_opts = [
 
 etcd_group = cfg.OptGroup(name='etcd', title='Options for etcd connection')
 
-DEFAULT_OPTS = (db_opts + sql_opts)
+DEFAULT_OPTS = (sql_opts)
 ETCD_OPTS = (etcd_opts)
 
 
 def register_opts(conf):
-    conf.register_opts(db_opts)
     conf.register_opts(sql_opts, 'database')
     conf.register_group(etcd_group)
     conf.register_opts(etcd_opts, etcd_group)

zun/db/api.py

@@ -17,36 +17,23 @@ Base API for Database
 
 from oslo_db import api as db_api
 
-from zun.common import exception
-from zun.common.i18n import _
 from zun.common import profiler
 import zun.conf
 
 """Add the database backend mapping here"""
 
 CONF = zun.conf.CONF
-_BACKEND_MAPPING = {'sqlalchemy': 'zun.db.sqlalchemy.api'}
+_BACKEND_MAPPING = {'sqlalchemy': 'zun.db.sqlalchemy.api',
+                    'etcd': 'zun.db.etcd.api'}
 IMPL = db_api.DBAPI.from_config(CONF,
                                 backend_mapping=_BACKEND_MAPPING,
                                 lazy=True)
-_etcd_instance = None
 
 
 @profiler.trace("db")
 def _get_dbdriver_instance():
     """Return a DB API instance."""
-    if CONF.db_type == 'sql':
+    return IMPL
-        return IMPL
-    elif CONF.db_type == 'etcd':
-        global _etcd_instance
-        if _etcd_instance is None:
-            import zun.db.etcd.api as etcd_api
-            _etcd_instance = etcd_api.get_connection()
-        return _etcd_instance
-    else:
-        raise exception.ConfigInvalid(
-            _("db_type value of %s is invalid, "
-              "must be sql or etcd") % CONF.db_type)
 
 
 @profiler.trace("db")

zun/db/etcd/api.py

@@ -34,14 +34,14 @@ LOG = log.getLogger(__name__)
 CONF = zun.conf.CONF
 
 
-def get_connection():
+def get_backend():
     connection = EtcdAPI(host=CONF.etcd.etcd_host,
                          port=CONF.etcd.etcd_port)
     return connection
 
 
 def clean_all_data():
-    conn = get_connection()
+    conn = get_backend()
     conn.clean_all_zun_data()
 
 

zun/db/etcd/models.py

@@ -60,7 +60,7 @@ class Base(object):
 
     def save(self, session=None):
         if session is None:
-            session = db.api.get_connection()
+            session = db.api.get_backend()
         client = session.client
         path = self.etcd_path(self.uuid)
 
@@ -110,7 +110,7 @@ class ZunService(Base):
 
     def save(self, session=None):
         if session is None:
-            session = db.api.get_connection()
+            session = db.api.get_backend()
         client = session.client
         path = self.etcd_path(self.host + '_' + self.binary)
 
@@ -259,7 +259,7 @@ class ComputeNode(Base):
 
     def save(self, session=None):
         if session is None:
-            session = db.api.get_connection()
+            session = db.api.get_backend()
         client = session.client
         path = self.etcd_path(self.uuid)
         if self.path_already_exist(client, path):

zun/db/sqlalchemy/api.py

@@ -378,7 +378,7 @@ class Connection(object):
         return _paginate_query(models.ZunService, limit, marker,
                                sort_key, sort_dir, query)
 
-    def list_zun_services_by_binary(cls, binary):
+    def list_zun_services_by_binary(self, binary):
         query = model_query(models.ZunService)
         query = query.filter_by(binary=binary)
         return _paginate_query(models.ZunService, query=query)

zun/tests/unit/api/base.py

@@ -16,7 +16,6 @@
 
 # NOTE(deva): import auth_token so we can override a config option
 from keystonemiddleware import auth_token  # noqa
-from oslo_config import cfg
 import pecan
 import pecan.testing
 from six.moves.urllib import parse as urlparse
@@ -40,10 +39,6 @@ class FunctionalTest(base.DbTestCase):
 
     def setUp(self):
         super(FunctionalTest, self).setUp()
-        # NOTE(yuywz): In API test cases, we use sqllite as the DB
-        # backend, so we should set 'db_type' to 'sql' to access
-        # sqllite DB with sqlalchemy api.
-        cfg.CONF.set_override('db_type', 'sql')
         zun.conf.CONF.set_override("auth_version", "v2.0",
                                    group='keystone_authtoken')
         zun.conf.CONF.set_override("admin_user", "admin",

zun/tests/unit/container/base.py

@@ -10,8 +10,6 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-from oslo_config import cfg
-
 import zun.conf
 from zun.db import api as db_api
 from zun.db.sqlalchemy import api as sqla_api
@@ -27,10 +25,6 @@ _DB_CACHE = None
 class DriverTestCase(base.TestCase):
     def setUp(self):
         super(DriverTestCase, self).setUp()
-        # NOTE(yuywz): In driver test cases, we use sqllite as
-        # the DB backend, so we should set 'db_type' to 'sql'
-        # to access sqllite DB with sqlalchemy api.
-        cfg.CONF.set_override('db_type', 'sql')
         self.dbapi = db_api._get_dbdriver_instance()
 
         global _DB_CACHE

zun/tests/unit/db/base.py

@@ -16,6 +16,7 @@ import fixtures
 
 import zun.conf
 from zun.db import api as db_api
+from zun.db.etcd import api as etcd_api
 from zun.db.sqlalchemy import api as sqla_api
 from zun.db.sqlalchemy import migration
 from zun.db.sqlalchemy import models
@@ -60,7 +61,9 @@ class DbTestCase(base.TestCase):
     def setUp(self):
         super(DbTestCase, self).setUp()
 
-        self.dbapi = db_api._get_dbdriver_instance()
+        self.dbapi = (db_api._get_dbdriver_instance()
+                      if CONF.database.backend == "sqlalchemy"
+                      else etcd_api.get_backend())
 
         global _DB_CACHE
         if not _DB_CACHE:

zun/tests/unit/db/test_allocation.py

@@ -10,7 +10,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from oslo_config import cfg
 from oslo_utils import uuidutils
 
 from zun.common import exception
@@ -25,7 +24,6 @@ CONF = zun.conf.CONF
 class DbAllocationTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbAllocationTestCase, self).setUp()
 
     def test_create_allocation(self):

zun/tests/unit/db/test_capsule.py

@@ -23,6 +23,7 @@ import six
 from zun.common import exception
 import zun.conf
 from zun.db import api as dbapi
+from zun.db.etcd import api as etcdapi
 from zun.tests.unit.db import base
 from zun.tests.unit.db import utils
 from zun.tests.unit.db.utils import FakeEtcdMultipleResult
@@ -35,7 +36,6 @@ CONF = zun.conf.CONF
 class SqlDbCapsuleTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(SqlDbCapsuleTestCase, self).setUp()
 
     def test_create_capsule(self):
@@ -171,7 +171,7 @@ class SqlDbCapsuleTestCase(base.DbTestCase):
 class EtcdDbCapsuleTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbCapsuleTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')
@@ -186,7 +186,10 @@ class EtcdDbCapsuleTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_capsule_by_uuid(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_capsule_by_uuid(self, mock_db_inst,
+                                 mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         capsule = utils.create_test_capsule(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdResult(
@@ -198,7 +201,10 @@ class EtcdDbCapsuleTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_capsule_by_meta_name(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_capsule_by_meta_name(self, mock_db_inst,
+                                      mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         capsule = utils.create_test_capsule(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
@@ -218,9 +224,11 @@ class EtcdDbCapsuleTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_capsules(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_capsules(self, mock_db_inst, mock_write, mock_read):
         uuids = []
         capsules = []
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(1, 6):
             capsule = utils.create_test_capsule(
@@ -237,10 +245,12 @@ class EtcdDbCapsuleTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_capsules_sorted(self, mock_write,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
-                                  mock_read):
+    def test_list_capsules_sorted(self, mock_db_inst,
+                                  mock_write, mock_read):
         uuids = []
         capsules = []
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(1, 6):
             capsule = utils.create_test_capsule(
@@ -261,8 +271,10 @@ class EtcdDbCapsuleTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_capsules_with_filters(self, mock_write,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
-                                        mock_read):
+    def test_list_capsules_with_filters(self, mock_db_inst,
+                                        mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
 
         capsule1 = utils.create_test_capsule(
@@ -292,7 +304,10 @@ class EtcdDbCapsuleTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'delete')
-    def test_destroy_capsule_by_uuid(self, mock_delete, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_destroy_capsule_by_uuid(self, mock_db_inst, mock_delete,
+                                     mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         capsule = utils.create_test_capsule(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdResult(
@@ -310,7 +325,10 @@ class EtcdDbCapsuleTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'update')
-    def test_update_capsule(self, mock_update, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_update_capsule(self, mock_db_inst,
+                            mock_update, mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         capsule = utils.create_test_capsule(context=self.context)
         new_meta_name = 'new_meta_name'

zun/tests/unit/db/test_compute_host.py

@@ -22,6 +22,7 @@ from etcd import Client as etcd_client
 from zun.common import exception
 import zun.conf
 from zun.db import api as dbapi
+from zun.db.etcd import api as etcdapi
 from zun.tests.unit.db import base
 from zun.tests.unit.db import utils
 from zun.tests.unit.db.utils import FakeEtcdMultipleResult
@@ -33,7 +34,6 @@ CONF = zun.conf.CONF
 class DbComputeNodeTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbComputeNodeTestCase, self).setUp()
 
     def test_create_compute_node(self):
@@ -169,7 +169,7 @@ class DbComputeNodeTestCase(base.DbTestCase):
 class EtcdDbComputeNodeTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbComputeNodeTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')
@@ -191,7 +191,10 @@ class EtcdDbComputeNodeTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_compute_node_by_uuid(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_compute_node_by_uuid(self, mock_db_inst,
+                                      mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         compute_node = utils.create_test_compute_node(
             context=self.context)
@@ -203,7 +206,10 @@ class EtcdDbComputeNodeTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_compute_node_by_name(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_compute_node_by_name(self, mock_db_inst,
+                                      mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         node = utils.create_test_compute_node(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdResult(
@@ -220,9 +226,11 @@ class EtcdDbComputeNodeTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_compute_nodes(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_compute_nodes(self, mock_db_inst, mock_write, mock_read):
         hostnames = []
         compute_nodes = []
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(1, 6):
             res_class = utils.create_test_compute_node(
@@ -237,9 +245,12 @@ class EtcdDbComputeNodeTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_compute_nodes_sorted(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_compute_nodes_sorted(self, mock_db_inst,
+                                       mock_write, mock_read):
         hostnames = []
         compute_nodes = []
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(1, 6):
             res_class = utils.create_test_compute_node(
@@ -255,8 +266,10 @@ class EtcdDbComputeNodeTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'delete')
-    def test_destroy_compute_node(self, mock_delete,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_destroy_compute_node(self, mock_db_inst, mock_delete,
                                   mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         compute_node = utils.create_test_compute_node(
             context=self.context)
@@ -277,8 +290,10 @@ class EtcdDbComputeNodeTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'update')
-    def test_update_compute_node(self, mock_update,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_update_compute_node(self, mock_db_inst, mock_update,
                                  mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         compute_node = utils.create_test_compute_node(
             context=self.context)

zun/tests/unit/db/test_container.py

@@ -23,6 +23,7 @@ import six
 from zun.common import exception
 import zun.conf
 from zun.db import api as dbapi
+from zun.db.etcd import api as etcdapi
 from zun.db.etcd.api import EtcdAPI as etcd_api
 from zun.tests.unit.db import base
 from zun.tests.unit.db import utils
@@ -35,7 +36,6 @@ CONF = zun.conf.CONF
 class DbContainerTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbContainerTestCase, self).setUp()
 
     def test_create_container(self):
@@ -234,7 +234,7 @@ class DbContainerTestCase(base.DbTestCase):
 class EtcdDbContainerTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbContainerTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')
@@ -257,7 +257,9 @@ class EtcdDbContainerTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_container_by_uuid(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_container_by_uuid(self, mock_inst, mock_write, mock_read):
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         container = utils.create_test_container(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdResult(
@@ -269,7 +271,9 @@ class EtcdDbContainerTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_container_by_name(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_container_by_name(self, mock_inst, mock_write, mock_read):
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         container = utils.create_test_container(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
@@ -280,7 +284,9 @@ class EtcdDbContainerTestCase(base.DbTestCase):
         self.assertEqual(container.uuid, res.uuid)
 
     @mock.patch.object(etcd_client, 'read')
-    def test_get_container_that_does_not_exist(self, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_container_that_does_not_exist(self, mock_inst, mock_read):
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         self.assertRaises(exception.ContainerNotFound,
                           dbapi.get_container_by_uuid,
@@ -289,9 +295,11 @@ class EtcdDbContainerTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_containers(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_containers(self, mock_inst, mock_write, mock_read):
         uuids = []
         containers = []
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(1, 6):
             container = utils.create_test_container(
@@ -308,9 +316,11 @@ class EtcdDbContainerTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_containers_sorted(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_containers_sorted(self, mock_inst, mock_write, mock_read):
         uuids = []
         containers = []
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(5):
             container = utils.create_test_container(
@@ -332,7 +342,10 @@ class EtcdDbContainerTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_containers_with_filters(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_containers_with_filters(self, mock_db_inst,
+                                          mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
 
         container1 = utils.create_test_container(
@@ -367,7 +380,10 @@ class EtcdDbContainerTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'delete')
-    def test_destroy_container(self, mock_delete, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_destroy_container(self, mock_inst, mock_delete,
+                               mock_write, mock_read):
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         container = utils.create_test_container(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdResult(
@@ -378,8 +394,10 @@ class EtcdDbContainerTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'delete')
-    def test_destroy_container_by_uuid(self, mock_delete,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_destroy_container_by_uuid(self, mock_inst, mock_delete,
                                        mock_write, mock_read):
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         container = utils.create_test_container(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdResult(
@@ -397,7 +415,10 @@ class EtcdDbContainerTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'update')
-    def test_update_container(self, mock_update, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_update_container(self, mock_inst, mock_update,
+                              mock_write, mock_read):
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         container = utils.create_test_container(context=self.context)
         new_image = 'new-image'
@@ -412,10 +433,12 @@ class EtcdDbContainerTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'update')
-    def test_update_container_with_the_same_name(self, mock_update,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_update_container_with_the_same_name(self, mock_inst, mock_update,
                                                  mock_write, mock_read):
         CONF.set_override("unique_container_name_scope", "project",
                           group="compute")
+        mock_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         container1 = utils.create_test_container(
             name='container-one',
@@ -453,8 +476,10 @@ class EtcdDbContainerTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_api, 'list_containers')
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
     def test_create_container_already_exists_in_project_name_space(
-            self, mock_list_containers, mock_write, mock_read):
+            self, mock_db_inst, mock_list_containers, mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         mock_list_containers.return_value = []
         CONF.set_override("unique_container_name_scope", "project",

zun/tests/unit/db/test_container_action.py

@@ -23,6 +23,7 @@ from oslo_utils import uuidutils
 from zun.common import exception
 import zun.conf
 from zun.db import api as dbapi
+from zun.db.etcd import api as etcdapi
 from zun.db.etcd.api import EtcdAPI as etcd_api
 from zun.tests.unit.db import base
 from zun.tests.unit.db import utils
@@ -86,7 +87,6 @@ class _DBContainerActionBase(base.DbTestCase,
 class DbContainerActionTestCase(_DBContainerActionBase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbContainerActionTestCase, self).setUp()
 
     def test_container_action_start(self):
@@ -233,12 +233,15 @@ class DbContainerActionTestCase(_DBContainerActionBase):
 class EtcdDbContainerActionTestCase(_DBContainerActionBase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbContainerActionTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_container_action_start(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_container_action_start(self, mock_db_inst,
+                                    mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         uuid = uuidutils.generate_uuid()
         action_values = self._create_action_values(uuid)
@@ -254,7 +257,10 @@ class EtcdDbContainerActionTestCase(_DBContainerActionBase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_container_actions_get_by_container(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_container_actions_get_by_container(self, mock_db_inst,
+                                                mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         uuid1 = uuidutils.generate_uuid()
 
@@ -306,9 +312,12 @@ class EtcdDbContainerActionTestCase(_DBContainerActionBase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_api, '_action_get_by_request_id')
-    def test_container_action_event_start(self, mock__action_get_by_request_id,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_container_action_event_start(self, mock_db_inst,
+                                          mock__action_get_by_request_id,
                                           mock_write, mock_read):
         """Create a container action event."""
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         uuid = uuidutils.generate_uuid()
 
@@ -347,10 +356,13 @@ class EtcdDbContainerActionTestCase(_DBContainerActionBase):
     @mock.patch.object(etcd_client, 'update')
     @mock.patch.object(etcd_api, '_action_get_by_request_id')
     @mock.patch.object(etcd_api, '_get_event_by_name')
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
     def test_container_action_event_finish_success(
-            self, mock_get_event_by_name, mock__action_get_by_request_id,
+            self, mock_db_inst, mock_get_event_by_name,
+            mock__action_get_by_request_id,
             mock_update, mock_write, mock_read):
         """Finish a container action event."""
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         uuid = uuidutils.generate_uuid()
 
@@ -404,8 +416,11 @@ class EtcdDbContainerActionTestCase(_DBContainerActionBase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_api, '_action_get_by_request_id')
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
     def test_container_action_events_get_in_order(
-            self, mock__action_get_by_request_id, mock_write, mock_read):
+            self, mock_db_inst, mock__action_get_by_request_id,
+            mock_write, mock_read):
+        mock_db_inst.return_value = etcdapi.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         uuid1 = uuidutils.generate_uuid()
 

zun/tests/unit/db/test_image.py

@@ -30,7 +30,6 @@ from zun.tests.unit.db.utils import FakeEtcdResult
 class DbImageTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbImageTestCase, self).setUp()
 
     def test_pull_image(self):
@@ -154,7 +153,7 @@ class DbImageTestCase(base.DbTestCase):
 class EtcdDbImageTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbImageTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')

zun/tests/unit/db/test_inventory.py

@@ -10,7 +10,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from oslo_config import cfg
 from oslo_utils import uuidutils
 
 from zun.common import exception
@@ -25,7 +24,6 @@ CONF = zun.conf.CONF
 class DbInventoryTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbInventoryTestCase, self).setUp()
 
     def test_create_inventory(self):

zun/tests/unit/db/test_pci_device.py

@@ -33,7 +33,6 @@ CONF = zun.conf.CONF
 class DbPciDeviceTestCase(base.DbTestCase, base.ModelsObjectComparatorMixin):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbPciDeviceTestCase, self).setUp()
         self.admin_context = context.get_admin_context()
         self._compute_node = None
@@ -222,7 +221,7 @@ fake_values = {'id': 1,
 class EtcdDbPciDeviceTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbPciDeviceTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')

zun/tests/unit/db/test_resource_class.py

@@ -23,6 +23,7 @@ import six
 from zun.common import exception
 import zun.conf
 from zun.db import api as dbapi
+from zun.db.etcd import api as etcd_api
 from zun.tests.unit.db import base
 from zun.tests.unit.db import utils
 from zun.tests.unit.db.utils import FakeEtcdMultipleResult
@@ -34,7 +35,6 @@ CONF = zun.conf.CONF
 class DbResourceClassTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbResourceClassTestCase, self).setUp()
 
     def test_create_resource_class(self):
@@ -128,7 +128,7 @@ class DbResourceClassTestCase(base.DbTestCase):
 class EtcdDbResourceClassTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbResourceClassTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')
@@ -150,7 +150,10 @@ class EtcdDbResourceClassTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_resource_class_by_uuid(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_resource_class_by_uuid(self, mock_db_inst,
+                                        mock_write, mock_read):
+        mock_db_inst.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         resource_class = utils.create_test_resource_class(
             context=self.context)
@@ -162,7 +165,10 @@ class EtcdDbResourceClassTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_resource_class_by_name(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_resource_class_by_name(self, mock_db_inst,
+                                        mock_write, mock_read):
+        mock_db_inst.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         rcs = utils.create_test_resource_class(context=self.context)
         mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
@@ -179,9 +185,11 @@ class EtcdDbResourceClassTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_resource_classes(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_resource_classes(self, mock_ins, mock_write, mock_read):
         names = []
         resource_classes = []
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(1, 6):
             res_class = utils.create_test_resource_class(
@@ -196,9 +204,12 @@ class EtcdDbResourceClassTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_resource_classes_sorted(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_resource_classes_sorted(self, mock_ins,
+                                          mock_write, mock_read):
         names = []
         resource_classes = []
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(1, 6):
             res_class = utils.create_test_resource_class(
@@ -214,8 +225,10 @@ class EtcdDbResourceClassTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'delete')
-    def test_destroy_resource_class(self, mock_delete,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_destroy_resource_class(self, mock_ins, mock_delete,
                                     mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         resource_class = utils.create_test_resource_class(
             context=self.context)
@@ -236,8 +249,10 @@ class EtcdDbResourceClassTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'update')
-    def test_update_resource_class(self, mock_update,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_update_resource_class(self, mock_ins, mock_update,
                                    mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         resource_class = utils.create_test_resource_class(
             context=self.context)
@@ -263,7 +278,9 @@ class EtcdDbResourceClassTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_update_resource_class_uuid(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_update_resource_class_uuid(self, mock_ins, mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         resource_class = utils.create_test_resource_class(
             context=self.context)

zun/tests/unit/db/test_resource_provider.py

@@ -12,7 +12,6 @@
 
 """Tests for manipulating resource providers via the DB API"""
 
-from oslo_config import cfg
 from oslo_utils import uuidutils
 import six
 
@@ -28,7 +27,6 @@ CONF = zun.conf.CONF
 class DbResourceProviderTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbResourceProviderTestCase, self).setUp()
 
     def test_create_resource_provider(self):

zun/tests/unit/db/test_volume_mapping.py

@@ -22,6 +22,7 @@ import six
 from zun.common import exception
 import zun.conf
 from zun.db import api as dbapi
+from zun.db.etcd import api as etcd_api
 from zun.tests.unit.db import base
 from zun.tests.unit.db import utils
 from zun.tests.unit.db.utils import FakeEtcdMultipleResult
@@ -33,7 +34,6 @@ CONF = zun.conf.CONF
 class DbVolumeMappingTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbVolumeMappingTestCase, self).setUp()
 
     def test_create_volume_mapping(self):
@@ -161,7 +161,7 @@ class DbVolumeMappingTestCase(base.DbTestCase):
 class EtcdDbVolumeMappingTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbVolumeMappingTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')
@@ -183,7 +183,9 @@ class EtcdDbVolumeMappingTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_volume_mapping_by_uuid(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_volume_mapping_by_uuid(self, mock_ins, mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         volume_mapping = utils.create_test_volume_mapping(
             context=self.context)
@@ -204,9 +206,11 @@ class EtcdDbVolumeMappingTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_volume_mappings(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_volume_mappings(self, mock_ins, mock_write, mock_read):
         uuids = []
         volume_mappings = []
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(0, 6):
             volume_mapping = utils.create_test_volume_mapping(
@@ -223,9 +227,12 @@ class EtcdDbVolumeMappingTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_volume_mappings_sorted(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_volume_mappings_sorted(self, mock_ins,
+                                         mock_write, mock_read):
         uuids = []
         volume_mappings = []
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         for i in range(0, 6):
             volume_mapping = utils.create_test_volume_mapping(
@@ -246,7 +253,10 @@ class EtcdDbVolumeMappingTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_volume_mappings_with_filters(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_volume_mappings_with_filters(self, mock_ins,
+                                               mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
 
         volume_mapping1 = utils.create_test_volume_mapping(
@@ -276,8 +286,10 @@ class EtcdDbVolumeMappingTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'delete')
-    def test_destroy_volume_mapping_by_uuid(self, mock_delete,
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_destroy_volume_mapping_by_uuid(self, mock_ins, mock_delete,
                                             mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         volume_mapping = utils.create_test_volume_mapping(
             context=self.context)
@@ -297,7 +309,10 @@ class EtcdDbVolumeMappingTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'update')
-    def test_update_volume_mapping(self, mock_update, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_update_volume_mapping(self, mock_ins, mock_update,
+                                   mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         volume_mapping = utils.create_test_volume_mapping(
             context=self.context)

zun/tests/unit/db/test_zun_service.py

@@ -21,6 +21,7 @@ from oslo_serialization import jsonutils as json
 
 from zun.common import exception
 from zun.db import api as dbapi
+from zun.db.etcd import api as etcd_api
 from zun.tests.unit.db import base
 from zun.tests.unit.db import utils
 from zun.tests.unit.db.utils import FakeEtcdMultipleResult
@@ -30,7 +31,6 @@ from zun.tests.unit.db.utils import FakeEtcdResult
 class DbZunServiceTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'sql')
         super(DbZunServiceTestCase, self).setUp()
 
     def test_create_zun_service(self):
@@ -133,7 +133,7 @@ class DbZunServiceTestCase(base.DbTestCase):
 class EtcdDbZunServiceTestCase(base.DbTestCase):
 
     def setUp(self):
-        cfg.CONF.set_override('db_type', 'etcd')
+        cfg.CONF.set_override('backend', 'etcd', 'database')
         super(EtcdDbZunServiceTestCase, self).setUp()
 
     @mock.patch.object(etcd_client, 'read')
@@ -153,7 +153,9 @@ class EtcdDbZunServiceTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_get_zun_service(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_get_zun_service(self, mock_ins, mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         zun_service = utils.create_test_zun_service()
         mock_read.side_effect = lambda *args: FakeEtcdResult(
@@ -174,7 +176,9 @@ class EtcdDbZunServiceTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_zun_services(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_zun_services(self, mock_ins, mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         service_1 = utils.create_test_zun_service(host='host_1')
         service_2 = utils.create_test_zun_service(host='host_2')
@@ -187,7 +191,10 @@ class EtcdDbZunServiceTestCase(base.DbTestCase):
 
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
-    def test_list_zun_services_by_binary(self, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_list_zun_services_by_binary(self, mock_ins,
+                                         mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         service_1 = utils.create_test_zun_service(
             host='host_1', binary='binary_1')
@@ -208,7 +215,10 @@ class EtcdDbZunServiceTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'delete')
-    def test_destroy_zun_service(self, mock_delete, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_destroy_zun_service(self, mock_ins, mock_delete,
+                                 mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         zun_service = utils.create_test_zun_service()
         mock_read.side_effect = lambda *args: FakeEtcdResult(
@@ -219,7 +229,9 @@ class EtcdDbZunServiceTestCase(base.DbTestCase):
             '/zun_services/%s' % zun_service.host + '_' + zun_service.binary)
 
     @mock.patch.object(etcd_client, 'delete')
-    def test_destroy_zun_service_not_exist(self, mock_delete):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_destroy_zun_service_not_exist(self, mock_ins, mock_delete):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_delete.side_effect = etcd.EtcdKeyNotFound
         self.assertRaises(exception.ZunServiceNotFound,
                           dbapi.destroy_zun_service,
@@ -228,7 +240,10 @@ class EtcdDbZunServiceTestCase(base.DbTestCase):
     @mock.patch.object(etcd_client, 'read')
     @mock.patch.object(etcd_client, 'write')
     @mock.patch.object(etcd_client, 'update')
-    def test_update_zun_service(self, mock_update, mock_write, mock_read):
+    @mock.patch.object(dbapi, "_get_dbdriver_instance")
+    def test_update_zun_service(self, mock_ins, mock_update,
+                                mock_write, mock_read):
+        mock_ins.return_value = etcd_api.get_backend()
         mock_read.side_effect = etcd.EtcdKeyNotFound
         service = utils.create_test_zun_service()
         new_host = 'new-host'

zun/tests/unit/db/utils.py

@@ -17,6 +17,7 @@ from oslo_serialization import jsonutils as json
 
 from zun.common import name_generator
 from zun.db import api as db_api
+from zun.db.etcd import api as etcd_api
 
 CONF = cfg.CONF
 
@@ -93,6 +94,14 @@ def get_test_container(**kwargs):
     }
 
 
+def _get_dbapi():
+    if CONF.database.backend == 'sqlalchemy':
+        dbapi = db_api._get_dbdriver_instance()
+    else:
+        dbapi = etcd_api.get_backend()
+    return dbapi
+
+
 def create_test_container(**kwargs):
     """Create test container entry in DB and return Container DB object.
 
@@ -102,9 +111,9 @@ def create_test_container(**kwargs):
     """
     container = get_test_container(**kwargs)
     # Let DB generate ID if it isn't specified explicitly
-    if CONF.db_type == 'sql' and 'id' not in kwargs:
+    if 'id' not in kwargs:
         del container['id']
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_container(kwargs['context'], container)
 
 
@@ -130,9 +139,9 @@ def get_test_volume_mapping(**kwargs):
 def create_test_volume_mapping(**kwargs):
     volume_mapping = get_test_volume_mapping(**kwargs)
     # Let DB generate ID if it isn't specified explicitly
-    if CONF.db_type == 'sql' and 'id' not in kwargs:
+    if 'id' not in kwargs:
         del volume_mapping['id']
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_volume_mapping(kwargs['context'], volume_mapping)
 
 
@@ -164,7 +173,7 @@ def create_test_image(**kwargs):
         del image['id']
     if 'repo' not in kwargs:
         image['repo'] = _generate_repo_for_image()
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.pull_image(kwargs['context'], image)
 
 
@@ -194,9 +203,9 @@ def get_test_zun_service(**kwargs):
 def create_test_zun_service(**kwargs):
     zun_service = get_test_zun_service(**kwargs)
     # Let DB generate ID if it isn't specifiled explicitly
-    if CONF.db_type == 'sql' and 'id' not in kwargs:
+    if 'id' not in kwargs:
         del zun_service['id']
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_zun_service(zun_service)
 
 
@@ -218,9 +227,9 @@ def get_test_resource_provider(**kwargs):
 def create_test_resource_provider(**kwargs):
     provider = get_test_resource_provider(**kwargs)
     # Let DB generate ID if it isn't specified explicitly
-    if CONF.db_type == 'sql' and 'id' not in kwargs:
+    if 'id' not in kwargs:
         del provider['id']
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_resource_provider(kwargs['context'], provider)
 
 
@@ -237,9 +246,9 @@ def get_test_resource_class(**kwargs):
 def create_test_resource_class(**kwargs):
     resource = get_test_resource_class(**kwargs)
     # Let DB generate ID if it isn't specified explicitly
-    if CONF.db_type == 'sql' and 'id' not in kwargs:
+    if 'id' not in kwargs:
         del resource['id']
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_resource_class(kwargs['context'], resource)
 
 
@@ -264,10 +273,10 @@ def get_test_inventory(**kwargs):
 def create_test_inventory(**kwargs):
     inventory = get_test_inventory(**kwargs)
     # Let DB generate ID if it isn't specified explicitly
-    if CONF.db_type == 'sql' and 'id' not in kwargs:
+    if 'id' not in kwargs:
         del inventory['id']
     provider_id = inventory.pop('resource_provider_id')
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_inventory(kwargs['context'], provider_id, inventory)
 
 
@@ -289,9 +298,9 @@ def get_test_allocation(**kwargs):
 def create_test_allocation(**kwargs):
     allocation = get_test_allocation(**kwargs)
     # Let DB generate ID if it isn't specified explicitly
-    if CONF.db_type == 'sql' and 'id' not in kwargs:
+    if 'id' not in kwargs:
         del allocation['id']
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_allocation(kwargs['context'], allocation)
 
 
@@ -340,7 +349,7 @@ def get_test_compute_node(**kwargs):
 
 def create_test_compute_node(**kwargs):
     compute_host = get_test_compute_node(**kwargs)
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_compute_node(kwargs['context'], compute_host)
 
 
@@ -397,9 +406,9 @@ def create_test_capsule(**kwargs):
     """
     capsule = get_test_capsule(**kwargs)
     # Let DB generate ID if it isn't specified explicitly
-    if CONF.db_type == 'sql' and 'id' not in kwargs:
+    if CONF.database.backend == 'sqlalchemy' and 'id' not in kwargs:
         del capsule['id']
-    dbapi = db_api._get_dbdriver_instance()
+    dbapi = _get_dbapi()
     return dbapi.create_capsule(kwargs['context'], capsule)