Merge "Remove unit test for etcd api"
This commit is contained in:
Zuul
Gerrit Code Review
commit
0622e15840
|
|
@ -11,23 +11,15 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating Capsule via the DB API"""
|
||||
import json
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
import mock
|
||||
from oslo_config import cfg
|
||||
from oslo_utils import uuidutils
|
||||
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
|
||||
from zun.tests.unit.db.utils import FakeEtcdResult
|
||||
|
||||
|
||||
CONF = zun.conf.CONF
|
||||
|
|
@ -166,195 +158,3 @@ class SqlDbCapsuleTestCase(base.DbTestCase):
|
|||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_capsule, self.context,
|
||||
capsule.id, {'uuid': ''})
|
||||
|
||||
|
||||
class EtcdDbCapsuleTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbCapsuleTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_capsule(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_capsule(context=self.context)
|
||||
mock_read.side_effect = lambda *args: None
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_capsule,
|
||||
context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
capsule.as_dict())
|
||||
res = dbapi.get_capsule_by_uuid(self.context,
|
||||
capsule.uuid)
|
||||
self.assertEqual(capsule.id, res.id)
|
||||
self.assertEqual(capsule.uuid, res.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
[capsule.as_dict()])
|
||||
res = dbapi.get_capsule_by_meta_name(
|
||||
self.context, capsule.meta_name)
|
||||
self.assertEqual(capsule.id, res.id)
|
||||
self.assertEqual(capsule.uuid, res.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_get_nonexists_capsule(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.CapsuleNotFound,
|
||||
dbapi.get_capsule_by_uuid,
|
||||
self.context,
|
||||
uuidutils.generate_uuid())
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,
|
||||
name='capsule' + str(i))
|
||||
capsules.append(capsule.as_dict())
|
||||
uuids.append(six.text_type(capsule['uuid']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
capsules)
|
||||
res = dbapi.list_capsules(self.context)
|
||||
res_uuids = [r.uuid for r in res]
|
||||
self.assertEqual(sorted(uuids), sorted(res_uuids))
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(dbapi, "_get_dbdriver_instance")
|
||||
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(
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,
|
||||
name='capsule' + str(i))
|
||||
capsules.append(capsule.as_dict())
|
||||
uuids.append(six.text_type(capsule['uuid']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
capsules)
|
||||
res = dbapi.list_capsules(self.context, sort_key='uuid')
|
||||
res_uuids = [r.uuid for r in res]
|
||||
self.assertEqual(sorted(uuids), res_uuids)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.list_capsules,
|
||||
self.context,
|
||||
sort_key='foo')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(dbapi, "_get_dbdriver_instance")
|
||||
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(
|
||||
name='capsule1',
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context)
|
||||
capsule2 = utils.create_test_capsule(
|
||||
name='capsule2',
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context)
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
[capsule1.as_dict(), capsule2.as_dict()])
|
||||
|
||||
res = dbapi.list_capsules(
|
||||
self.context, filters={'uuid': capsule1.uuid})
|
||||
self.assertEqual([capsule1.id], [r.id for r in res])
|
||||
|
||||
res = dbapi.list_capsules(
|
||||
self.context, filters={'uuid': capsule2.uuid})
|
||||
self.assertEqual([capsule2.id], [r.id for r in res])
|
||||
|
||||
res = dbapi.list_capsules(
|
||||
self.context, filters={'uuid': 'unknow-uuid'})
|
||||
self.assertEqual([], [r.id for r in res])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'delete')
|
||||
@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(
|
||||
capsule.as_dict())
|
||||
dbapi.destroy_capsule(self.context, capsule.uuid)
|
||||
mock_delete.assert_called_once_with('/capsules/%s' % capsule.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_destroy_non_exists_capsule(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.CapsuleNotFound,
|
||||
dbapi.destroy_capsule, self.context,
|
||||
uuidutils.generate_uuid())
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'update')
|
||||
@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'
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
capsule.as_dict())
|
||||
dbapi.update_capsule(self.context, capsule.uuid,
|
||||
{'meta_name': new_meta_name})
|
||||
self.assertEqual(new_meta_name, json.loads(
|
||||
mock_update.call_args_list[0][0][0].value.decode('utf-8'))
|
||||
['meta_name'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_update_capsule_not_found(self, mock_read):
|
||||
capsule_uuid = uuidutils.generate_uuid()
|
||||
new_meta_name = 'new-meta-name'
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.CapsuleNotFound,
|
||||
dbapi.update_capsule, self.context,
|
||||
capsule_uuid, {'meta_name': new_meta_name})
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_update_capsule_uuid(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
capsule = utils.create_test_capsule(context=self.context)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_capsule, self.context,
|
||||
capsule.uuid, {'uuid': ''})
|
||||
|
|
|
|||
|
|
@ -11,22 +11,15 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating compute nodes via the DB API"""
|
||||
import json
|
||||
import mock
|
||||
from oslo_config import cfg
|
||||
|
||||
from oslo_utils import uuidutils
|
||||
import six
|
||||
|
||||
import etcd
|
||||
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
|
||||
from zun.tests.unit.db.utils import FakeEtcdResult
|
||||
|
||||
CONF = zun.conf.CONF
|
||||
|
||||
|
|
@ -164,166 +157,3 @@ class DbComputeNodeTestCase(base.DbTestCase):
|
|||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_compute_node, self.context,
|
||||
node.uuid, {'uuid': ''})
|
||||
|
||||
|
||||
class EtcdDbComputeNodeTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbComputeNodeTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_compute_node(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_compute_node(context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_compute_node_already_exists(self, mock_write,
|
||||
mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_compute_node(context=self.context, hostname='123')
|
||||
mock_read.side_effect = lambda *args: None
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_compute_node,
|
||||
context=self.context, hostname='123')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
compute_node.as_dict())
|
||||
res = dbapi.get_compute_node(self.context, compute_node.uuid)
|
||||
self.assertEqual(compute_node.uuid, res.uuid)
|
||||
self.assertEqual(compute_node.hostname, res.hostname)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
node.as_dict())
|
||||
res = dbapi.get_compute_node(self.context, node.hostname)
|
||||
self.assertEqual(node.uuid, res.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_get_compute_node_that_does_not_exist(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ComputeNodeNotFound,
|
||||
dbapi.get_compute_node,
|
||||
self.context, 'fake-ident')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
context=self.context, hostname='class' + str(i))
|
||||
compute_nodes.append(res_class.as_dict())
|
||||
hostnames.append(six.text_type(res_class['hostname']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
compute_nodes)
|
||||
res = dbapi.list_compute_nodes(self.context)
|
||||
res_names = [r.hostname for r in res]
|
||||
self.assertEqual(sorted(hostnames), sorted(res_names))
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
context=self.context, hostname='class' + str(i))
|
||||
compute_nodes.append(res_class.as_dict())
|
||||
hostnames.append(six.text_type(res_class['hostname']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
compute_nodes)
|
||||
res = dbapi.list_compute_nodes(self.context, sort_key='hostname')
|
||||
res_names = [r.hostname for r in res]
|
||||
self.assertEqual(sorted(hostnames), res_names)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, '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)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
compute_node.as_dict())
|
||||
dbapi.destroy_compute_node(self.context, compute_node.uuid)
|
||||
mock_delete.assert_called_once_with(
|
||||
'/compute_nodes/%s' % compute_node.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_destroy_compute_node_that_does_not_exist(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ComputeNodeNotFound,
|
||||
dbapi.destroy_compute_node,
|
||||
self.context,
|
||||
'ca3e2a25-2901-438d-8157-de7ffd68d535')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, '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)
|
||||
old_name = compute_node.hostname
|
||||
new_name = 'new-name'
|
||||
self.assertNotEqual(old_name, new_name)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
compute_node.as_dict())
|
||||
dbapi.update_compute_node(
|
||||
self.context, compute_node.uuid, {'hostname': new_name})
|
||||
self.assertEqual(new_name, json.loads(
|
||||
mock_update.call_args_list[0][0][0].value)['hostname'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_update_compute_node_not_found(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
new_name = 'new-name'
|
||||
self.assertRaises(exception.ComputeNodeNotFound,
|
||||
dbapi.update_compute_node,
|
||||
self.context,
|
||||
'ca3e2a25-2901-438d-8157-de7ffd68d535',
|
||||
{'hostname': new_name})
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_update_compute_node_uuid(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
compute_node = utils.create_test_compute_node(
|
||||
context=self.context)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_compute_node,
|
||||
self.context, compute_node.uuid,
|
||||
{'uuid': ''})
|
||||
|
|
|
|||
|
|
@ -11,24 +11,15 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating Containers via the DB API"""
|
||||
import mock
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
from oslo_config import cfg
|
||||
from oslo_serialization import jsonutils as json
|
||||
from oslo_utils import uuidutils
|
||||
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
|
||||
from zun.tests.unit.db.utils import FakeEtcdMultipleResult
|
||||
from zun.tests.unit.db.utils import FakeEtcdResult
|
||||
|
||||
CONF = zun.conf.CONF
|
||||
|
||||
|
|
@ -244,304 +235,3 @@ class DbContainerTestCase(base.DbTestCase):
|
|||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_container, self.context,
|
||||
container.id, {'uuid': ''})
|
||||
|
||||
|
||||
class EtcdDbContainerTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbContainerTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_container(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_container(context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_container_already_exists(self, mock_write, mock_read):
|
||||
CONF.set_override("unique_container_name_scope", "",
|
||||
group="compute")
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_container(context=self.context)
|
||||
mock_read.side_effect = lambda *args: None
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_container,
|
||||
context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
container.as_dict())
|
||||
res = dbapi.get_container_by_uuid(self.context,
|
||||
container.uuid)
|
||||
self.assertEqual(container.id, res.id)
|
||||
self.assertEqual(container.uuid, res.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
[container.as_dict()])
|
||||
res = dbapi.get_container_by_name(
|
||||
self.context, container.name)
|
||||
self.assertEqual(container.id, res.id)
|
||||
self.assertEqual(container.uuid, res.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, '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,
|
||||
self.context,
|
||||
uuidutils.generate_uuid())
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,
|
||||
name='cont' + str(i))
|
||||
containers.append(container.as_dict())
|
||||
uuids.append(six.text_type(container['uuid']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
containers)
|
||||
res = dbapi.list_containers(self.context)
|
||||
res_uuids = [r.uuid for r in res]
|
||||
self.assertEqual(sorted(uuids), sorted(res_uuids))
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,
|
||||
name='cont' + str(i))
|
||||
containers.append(container.as_dict())
|
||||
uuids.append(six.text_type(container.uuid))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
containers)
|
||||
res = dbapi.list_containers(self.context, sort_key='uuid')
|
||||
res_uuids = [r.uuid for r in res]
|
||||
self.assertEqual(sorted(uuids), res_uuids)
|
||||
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.list_containers,
|
||||
self.context,
|
||||
sort_key='foo')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
name='container-one',
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context)
|
||||
container2 = utils.create_test_container(
|
||||
name='container-two',
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context)
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
[container1.as_dict(), container2.as_dict()])
|
||||
|
||||
res = dbapi.list_containers(
|
||||
self.context, filters={'name': 'container-one'})
|
||||
self.assertEqual([container1.id], [r.id for r in res])
|
||||
|
||||
res = dbapi.list_containers(
|
||||
self.context, filters={'name': 'container-two'})
|
||||
self.assertEqual([container2.id], [r.id for r in res])
|
||||
|
||||
res = dbapi.list_containers(
|
||||
self.context, filters={'name': 'container-three'})
|
||||
self.assertEqual([], [r.id for r in res])
|
||||
|
||||
res = dbapi.list_containers(
|
||||
self.context,
|
||||
filters={'name': container1.name})
|
||||
self.assertEqual([container1.id], [r.id for r in res])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'delete')
|
||||
@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(
|
||||
container.as_dict())
|
||||
dbapi.destroy_container(self.context, container.uuid)
|
||||
mock_delete.assert_called_once_with('/containers/%s' % container.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, '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(
|
||||
container.as_dict())
|
||||
dbapi.destroy_container(self.context, container.uuid)
|
||||
mock_delete.assert_called_once_with('/containers/%s' % container.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_destroy_container_that_does_not_exist(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ContainerNotFound,
|
||||
dbapi.destroy_container, self.context,
|
||||
uuidutils.generate_uuid())
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'update')
|
||||
@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'
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
container.as_dict())
|
||||
dbapi.update_container(self.context, container.uuid,
|
||||
{'image': new_image})
|
||||
self.assertEqual(new_image, json.loads(
|
||||
mock_update.call_args_list[0][0][0].value)['image'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, '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',
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context)
|
||||
container2 = utils.create_test_container(
|
||||
name='container-two',
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context)
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
[container1.as_dict(), container2.as_dict()])
|
||||
self.assertRaises(exception.ContainerAlreadyExists,
|
||||
dbapi.update_container, self.context,
|
||||
container2.uuid, {'name': 'container-one'})
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_update_container_not_found(self, mock_read):
|
||||
container_uuid = uuidutils.generate_uuid()
|
||||
new_image = 'new-image'
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ContainerNotFound,
|
||||
dbapi.update_container, self.context,
|
||||
container_uuid, {'image': new_image})
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_update_container_uuid(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
container = utils.create_test_container(context=self.context)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_container, self.context,
|
||||
container.id, {'uuid': ''})
|
||||
|
||||
@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_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",
|
||||
group="compute")
|
||||
container1 = utils.create_test_container(
|
||||
context=self.context, name='cont1')
|
||||
mock_list_containers.return_value = [container1]
|
||||
with self.assertRaisesRegex(exception.ContainerAlreadyExists,
|
||||
'A container with name.*'):
|
||||
utils.create_test_container(uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,
|
||||
name='cont1')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_api, 'list_containers')
|
||||
def test_create_container_already_exists_in_global_name_space(
|
||||
self, mock_list_containers, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
mock_list_containers.return_value = []
|
||||
CONF.set_override("unique_container_name_scope", "global",
|
||||
group="compute")
|
||||
container1 = utils.create_test_container(
|
||||
context=self.context, name='cont1')
|
||||
self.context.project_id = 'fake_project_1'
|
||||
self.context.user_id = 'fake_user_1'
|
||||
mock_list_containers.return_value = [container1]
|
||||
with self.assertRaisesRegex(exception.ContainerAlreadyExists,
|
||||
'A container with name.*'):
|
||||
utils.create_test_container(uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,
|
||||
name='cont1')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_api, 'list_containers')
|
||||
def test_create_container_already_exists_in_default_name_space(
|
||||
self, mock_list_containers, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
mock_list_containers.return_value = []
|
||||
CONF.set_override("unique_container_name_scope", "",
|
||||
group="compute")
|
||||
container1 = utils.create_test_container(
|
||||
context=self.context, name='cont1',
|
||||
uuid=uuidutils.generate_uuid())
|
||||
mock_list_containers.return_value = [container1]
|
||||
self.context.project_id = 'fake_project_1'
|
||||
self.context.user_id = 'fake_user_1'
|
||||
utils.create_test_container(
|
||||
context=self.context, name='cont1', uuid=uuidutils.generate_uuid())
|
||||
|
|
|
|||
|
|
@ -11,24 +11,16 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating Container Actions via the DB API"""
|
||||
from datetime import datetime
|
||||
|
||||
from datetime import timedelta
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
import mock
|
||||
from oslo_config import cfg
|
||||
from oslo_utils import timeutils
|
||||
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
|
||||
from zun.tests.unit.db.utils import FakeEtcdMultipleResult
|
||||
from zun.tests.unit.db.utils import FakeEtcdResult
|
||||
|
||||
CONF = zun.conf.CONF
|
||||
|
||||
|
|
@ -228,239 +220,3 @@ class DbContainerActionTestCase(_DBContainerActionBase):
|
|||
|
||||
self._assertEqualOrderedListOfObjects([event3, event2, event1], events,
|
||||
['container_uuid', 'request_id'])
|
||||
|
||||
|
||||
class EtcdDbContainerActionTestCase(_DBContainerActionBase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbContainerActionTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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)
|
||||
action = dbapi.action_start(self.context, action_values)
|
||||
|
||||
ignored_keys = self.IGNORED_FIELDS + ['finish_time', 'uuid']
|
||||
|
||||
self._assertEqualObjects(action_values, action.as_dict(), ignored_keys)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
[action.as_dict()])
|
||||
action['start_time'] = datetime.isoformat(action['start_time'])
|
||||
self._assertActionSaved(action.as_dict(), uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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()
|
||||
|
||||
expected = []
|
||||
|
||||
action_values = self._create_action_values(uuid1)
|
||||
action = dbapi.action_start(self.context, action_values)
|
||||
action['start_time'] = datetime.isoformat(action['start_time'])
|
||||
expected.append(action)
|
||||
|
||||
action_values['action'] = 'test-action'
|
||||
action = dbapi.action_start(self.context, action_values)
|
||||
action['start_time'] = datetime.isoformat(action['start_time'])
|
||||
expected.append(action)
|
||||
|
||||
# Create an other container action.
|
||||
uuid2 = uuidutils.generate_uuid()
|
||||
action_values = self._create_action_values(uuid2, 'test-action')
|
||||
dbapi.action_start(self.context, action_values)
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
expected)
|
||||
actions = dbapi.actions_get(self.context, uuid1)
|
||||
self._assertEqualListsOfObjects(expected, actions)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_container_action_get_by_container_and_request(self, mock_write,
|
||||
mock_read):
|
||||
"""Ensure we can get an action by container UUID and request_id"""
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
uuid1 = uuidutils.generate_uuid()
|
||||
|
||||
action_values = self._create_action_values(uuid1)
|
||||
action = dbapi.action_start(self.context, action_values)
|
||||
request_id = action_values['request_id']
|
||||
|
||||
# An other action using a different req id
|
||||
action_values['action'] = 'test-action'
|
||||
action_values['request_id'] = 'req-00000000-7522-4d99-7ff-111111111111'
|
||||
dbapi.action_start(self.context, action_values)
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult([action])
|
||||
action = dbapi.action_get_by_request_id(self.context, uuid1,
|
||||
request_id)
|
||||
self.assertEqual('create_container', action['action'])
|
||||
self.assertEqual(self.context.request_id, action['request_id'])
|
||||
|
||||
@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_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()
|
||||
|
||||
action_values = self._create_action_values(uuid)
|
||||
action = dbapi.action_start(self.context, action_values)
|
||||
|
||||
event_values = self._create_event_values(uuid)
|
||||
|
||||
mock__action_get_by_request_id.return_value = action
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
event = dbapi.action_event_start(self.context, event_values)
|
||||
|
||||
ignored_keys = self.IGNORED_FIELDS + ['finish_time', 'traceback',
|
||||
'result', 'action_uuid',
|
||||
'request_id', 'container_uuid',
|
||||
'uuid']
|
||||
self._assertEqualObjects(event_values, event, ignored_keys)
|
||||
|
||||
event['start_time'] = datetime.isoformat(event['start_time'])
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult([event])
|
||||
self._assertActionEventSaved(event, action['uuid'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_container_action_event_start_without_action(self, mock_write,
|
||||
mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
uuid = uuidutils.generate_uuid()
|
||||
|
||||
event_values = self._create_event_values(uuid)
|
||||
self.assertRaises(exception.ContainerActionNotFound,
|
||||
dbapi.action_event_start, self.context, event_values)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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_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()
|
||||
|
||||
action = dbapi.action_start(self.context,
|
||||
self._create_action_values(uuid))
|
||||
|
||||
event_values = self._create_event_values(uuid)
|
||||
event_values['action_uuid'] = action['uuid']
|
||||
|
||||
mock__action_get_by_request_id.return_value = action
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
event = dbapi.action_event_start(self.context, event_values)
|
||||
|
||||
event_values = {
|
||||
'finish_time': timeutils.utcnow() + timedelta(seconds=5),
|
||||
'result': 'Success'
|
||||
}
|
||||
|
||||
event_values = self._create_event_values(uuid, extra=event_values)
|
||||
|
||||
mock__action_get_by_request_id.return_value = action
|
||||
mock_get_event_by_name.return_value = event
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(event)
|
||||
event = dbapi.action_event_finish(self.context, event_values)
|
||||
|
||||
event['start_time'] = datetime.isoformat(event['start_time'])
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult([event])
|
||||
self._assertActionEventSaved(event, action['uuid'])
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult([action])
|
||||
action = dbapi.action_get_by_request_id(self.context, uuid,
|
||||
self.context.request_id)
|
||||
self.assertNotEqual('Error', action['message'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_container_action_event_finish_without_action(self, mock_write,
|
||||
mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
uuid = uuidutils.generate_uuid()
|
||||
|
||||
event_values = {
|
||||
'finish_time': timeutils.utcnow() + timedelta(seconds=5),
|
||||
'result': 'Success'
|
||||
}
|
||||
event_values = self._create_event_values(uuid, extra=event_values)
|
||||
self.assertRaises(exception.ContainerActionNotFound,
|
||||
dbapi.action_event_finish,
|
||||
self.context, event_values)
|
||||
|
||||
@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_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()
|
||||
|
||||
action = dbapi.action_start(self.context,
|
||||
self._create_action_values(uuid1))
|
||||
|
||||
extra1 = {
|
||||
'action_uuid': action['uuid'],
|
||||
'created_at': timeutils.utcnow()
|
||||
}
|
||||
|
||||
extra2 = {
|
||||
'action_uuid': action['uuid'],
|
||||
'created_at': timeutils.utcnow() + timedelta(seconds=5)
|
||||
}
|
||||
|
||||
event_val1 = self._create_event_values(uuid1, 'fake1', extra=extra1)
|
||||
event_val2 = self._create_event_values(uuid1, 'fake2', extra=extra1)
|
||||
event_val3 = self._create_event_values(uuid1, 'fake3', extra=extra2)
|
||||
|
||||
mock__action_get_by_request_id.return_value = action
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
event1 = dbapi.action_event_start(self.context, event_val1)
|
||||
event1['start_time'] = datetime.isoformat(event1['start_time'])
|
||||
|
||||
mock__action_get_by_request_id.return_value = action
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
event2 = dbapi.action_event_start(self.context, event_val2)
|
||||
event2['start_time'] = datetime.isoformat(event2['start_time'])
|
||||
|
||||
mock__action_get_by_request_id.return_value = action
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
event3 = dbapi.action_event_start(self.context, event_val3)
|
||||
event3['start_time'] = datetime.isoformat(event3['start_time'])
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
[event1, event2, event3])
|
||||
events = dbapi.action_events_get(self.context, action['uuid'])
|
||||
|
||||
self.assertEqual(3, len(events))
|
||||
|
||||
self._assertEqualOrderedListOfObjects([event3, event2, event1], events,
|
||||
['container_uuid', 'request_id'])
|
||||
|
|
|
|||
|
|
@ -11,20 +11,13 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating Images via the DB API"""
|
||||
import mock
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
from oslo_config import cfg
|
||||
from oslo_serialization import jsonutils as json
|
||||
from oslo_utils import uuidutils
|
||||
import six
|
||||
|
||||
from zun.common import exception
|
||||
from zun.tests.unit.db import base
|
||||
from zun.tests.unit.db import utils
|
||||
from zun.tests.unit.db.utils import FakeEtcdMultipleResult
|
||||
from zun.tests.unit.db.utils import FakeEtcdResult
|
||||
|
||||
|
||||
class DbImageTestCase(base.DbTestCase):
|
||||
|
|
@ -148,173 +141,3 @@ class DbImageTestCase(base.DbTestCase):
|
|||
self.assertRaises(exception.InvalidParameterValue,
|
||||
self.dbapi.update_image, image.id,
|
||||
{'uuid': ''})
|
||||
|
||||
|
||||
class EtcdDbImageTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbImageTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_pull_image(self, mock_get, mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_image(context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_pull_image_duplicate_repo(self, mock_get,
|
||||
mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_image(context=self.context,
|
||||
repo="ubuntu:latest")
|
||||
utils.create_test_image(context=self.context,
|
||||
repo="ubuntu:14.04")
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_pull_image_duplicate_tag(self, mock_get,
|
||||
mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_image(context=self.context,
|
||||
repo="ubuntu:latest")
|
||||
utils.create_test_image(context=self.context,
|
||||
repo="centos:14.04")
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_pull_image_already_exists(self, mock_get,
|
||||
mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_image(context=self.context,
|
||||
repo="ubuntu:latest")
|
||||
mock_get.return_value = mock.MagicMock()
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_image,
|
||||
context=self.context, repo="ubuntu:latest")
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_get_image_by_uuid(self, mock_get, mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
image = utils.create_test_image(context=self.context)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(image.as_dict())
|
||||
res = self.dbapi.get_image_by_uuid(self.context, image.uuid)
|
||||
self.assertEqual(image.uuid, res.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_get_image_that_does_not_exist(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ImageNotFound,
|
||||
self.dbapi.get_image_by_uuid, self.context,
|
||||
'db09ecea-7d63-4638-ae88-b8581f796e86')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_list_images(self, mock_get, mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
uuids = []
|
||||
images = []
|
||||
for i in range(1, 6):
|
||||
image = utils.create_test_image(context=self.context,
|
||||
repo='testrepo' + str(i))
|
||||
images.append(image.as_dict())
|
||||
uuids.append(image.uuid)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(images)
|
||||
res = self.dbapi.list_images(self.context)
|
||||
res_uuids = [r.uuid for r in res]
|
||||
self.assertEqual(sorted(uuids), sorted(res_uuids))
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_list_images_sorted(self, mock_get, mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
uuids = []
|
||||
images = []
|
||||
for i in range(1, 6):
|
||||
image = utils.create_test_image(context=self.context,
|
||||
repo='testrepo' + str(i))
|
||||
images.append(image.as_dict())
|
||||
uuids.append(image.uuid)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(images)
|
||||
res = self.dbapi.list_images(self.context, sort_key='uuid')
|
||||
res_uuids = [r.uuid for r in res]
|
||||
|
||||
self.assertEqual(sorted(uuids), res_uuids)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
self.dbapi.list_images,
|
||||
self.context, sort_key='foo')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_list_images_with_filters(self, mock_get, mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
image1 = utils.create_test_image(
|
||||
context=self.context, repo='imageone',
|
||||
uuid=uuidutils.generate_uuid())
|
||||
image2 = utils.create_test_image(
|
||||
context=self.context, repo='imagetwo',
|
||||
uuid=uuidutils.generate_uuid())
|
||||
images = [image1.as_dict(), image2.as_dict()]
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(images)
|
||||
res = self.dbapi.list_images(self.context,
|
||||
filters={'repo': 'imageone'})
|
||||
self.assertEqual([image1.uuid], [r.uuid for r in res])
|
||||
|
||||
res = self.dbapi.list_images(self.context,
|
||||
filters={'repo': 'imagetwo'})
|
||||
self.assertEqual([image2.uuid], [r.uuid for r in res])
|
||||
|
||||
res = self.dbapi.list_images(self.context,
|
||||
filters={'repo': 'foo'})
|
||||
self.assertEqual([], [r.uuid for r in res])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'update')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_update_image(self, mock_get, mock_update, mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
image = utils.create_test_image(context=self.context)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(image.as_dict())
|
||||
self.dbapi.update_image(image.uuid, {'tag': 'newtag'})
|
||||
self.assertEqual('newtag', json.loads(
|
||||
mock_update.call_args_list[0][0][0].value)['tag'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_update_image_not_found(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ImageNotFound, self.dbapi.update_image,
|
||||
'db09ecea-7d63-4638-ae88-b8581f796e86',
|
||||
{'tag': 'newtag'})
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_image_by_repo_and_tag')
|
||||
def test_update_image_uuid(self, mock_get, mock_write, mock_read):
|
||||
mock_get.return_value = None
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
image = utils.create_test_image(context=self.context)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
self.dbapi.update_image, image.uuid,
|
||||
{'uuid': 'newuuid'})
|
||||
|
|
|
|||
|
|
@ -11,18 +11,11 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating pci device via the DB API"""
|
||||
import mock
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
|
||||
from oslo_config import cfg
|
||||
|
||||
from zun.common import context
|
||||
from zun.common import exception
|
||||
import zun.conf
|
||||
from zun.db import api as dbapi
|
||||
from zun.db.etcd import models
|
||||
from zun.objects import fields as z_fields
|
||||
from zun.tests.unit.db import base
|
||||
from zun.tests import uuidsentinel
|
||||
|
|
@ -200,87 +193,3 @@ class DbPciDeviceTestCase(base.DbTestCase, base.ModelsObjectComparatorMixin):
|
|||
dbapi.destroy_pci_device,
|
||||
v1['compute_node_uuid'],
|
||||
v1['address'])
|
||||
|
||||
|
||||
fake_values = {'id': 1,
|
||||
'uuid': 'bd45ca46351e64f91d5c32',
|
||||
'compute_node_uuid': 'ef5ef3492b57c8b9bc0556a',
|
||||
'address': 'fake_addr',
|
||||
'vendor_id': 'fake_vendor',
|
||||
'product_id': 'fake_product',
|
||||
'dev_type': 'VF',
|
||||
'dev_id': 'fake_dev_id',
|
||||
'lable': 'fake_label',
|
||||
'status': 'in-use',
|
||||
'request_id': 'fake_request_id',
|
||||
'extra_info': '',
|
||||
'parent_addr': '11:22',
|
||||
'container_uuid': 'Id64c317ff78e95af2fc046e9630d7ae016df9f2'}
|
||||
|
||||
|
||||
class EtcdDbPciDeviceTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbPciDeviceTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_update_pci_device(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
values = fake_values
|
||||
pcidevice = models.PciDevice(values)
|
||||
updated = self.dbapi.update_pci_device(values['compute_node_uuid'],
|
||||
values['address'], values)
|
||||
self.assertEqual(pcidevice.as_dict(), updated.as_dict())
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_list_pci_device(self, mock_read):
|
||||
res = self.dbapi.list_pci_devices()
|
||||
mock_read.assert_called_with('/pcidevices')
|
||||
self.assertEqual([], res)
|
||||
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.get_pci_device_by_addr')
|
||||
@mock.patch.object(etcd_client, 'delete')
|
||||
def test_destroy_pci_device(self, mock_delete, mock_get):
|
||||
self.dbapi.destroy_pci_device('1', 'fake_address')
|
||||
mock_delete.assert_called()
|
||||
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.list_pci_devices')
|
||||
def test_get_all_pci_device_by_container_uuid(self, mock_list):
|
||||
filters = {'container_uuid': 'Id64c317ff78e95af2fc'}
|
||||
mock_list.return_value = [models.PciDevice(fake_values)]
|
||||
self.dbapi.get_all_pci_device_by_container_uuid('Id64c317ff78e95af2fc')
|
||||
mock_list.assert_called_with(filters=filters)
|
||||
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.list_pci_devices')
|
||||
def test_get_all_pci_device_by_parent_addr(self, mock_list):
|
||||
filters = {'compute_node_uuid': 'ef5ef3492b57c8b9bc0556a',
|
||||
'parent_addr': '11:22'}
|
||||
mock_list.return_value = [models.PciDevice(fake_values)]
|
||||
self.dbapi.get_all_pci_device_by_parent_addr('ef5ef3492b57c8b9bc0556a',
|
||||
'11:22')
|
||||
mock_list.assert_called_with(filters=filters)
|
||||
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.list_pci_devices')
|
||||
def test_get_all_pci_device_by_node(self, mock_list):
|
||||
filters = {'compute_node_uuid': 'ef5ef3492b57c8b9bc0556a'}
|
||||
mock_list.return_value = [models.PciDevice(fake_values)]
|
||||
self.dbapi.get_all_pci_device_by_node('ef5ef3492b57c8b9bc0556a')
|
||||
mock_list.assert_called_with(filters=filters)
|
||||
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.list_pci_devices')
|
||||
def test_get_pci_device_by_id(self, mock_list):
|
||||
filters = {'id': '1'}
|
||||
mock_list.return_value = [models.PciDevice(fake_values)]
|
||||
self.dbapi.get_pci_device_by_id('1')
|
||||
mock_list.assert_called_with(filters=filters)
|
||||
|
||||
@mock.patch('zun.db.etcd.api.EtcdAPI.list_pci_devices')
|
||||
def test_get_pci_device_by_addr(self, mock_list):
|
||||
filters = {'compute_node_uuid': 'ef5ef3492b57c8b9bc0556a',
|
||||
'address': 'fake_addr'}
|
||||
mock_list.return_value = [models.PciDevice(fake_values)]
|
||||
self.dbapi.get_pci_device_by_addr('ef5ef3492b57c8b9bc0556a',
|
||||
'fake_addr')
|
||||
mock_list.assert_called_with(filters=filters)
|
||||
|
|
|
|||
|
|
@ -11,19 +11,11 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating Quota via the DB API"""
|
||||
import json
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
import mock
|
||||
from oslo_config import cfg
|
||||
|
||||
from zun.common import consts
|
||||
from zun.common import context
|
||||
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
|
||||
|
||||
|
|
@ -114,95 +106,3 @@ class DBQuotaClassesTestCase(base.DbTestCase):
|
|||
self.ctx, quota_class.class_name,
|
||||
quota_class.resource)
|
||||
self.assertEqual(updated_quota_class.hard_limit, 200)
|
||||
|
||||
|
||||
class EtcdDbQuotaClassTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbQuotaClassTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_quota_class(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_quota_class(context=self.context)
|
||||
mock_read.side_effect = lambda *args: None
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_quota_class,
|
||||
context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(dbapi, '_get_dbdriver_instance')
|
||||
def test_get_quota_class(self, mock_db_inst,
|
||||
mock_write, mock_read):
|
||||
mock_db_inst.return_value = etcdapi.get_backend()
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
quota_class = utils.create_test_quota_class(context=self.context)
|
||||
mock_read.side_effect = lambda *args: utils.FakeEtcdResult(
|
||||
quota_class.as_dict())
|
||||
res = dbapi.quota_class_get(self.context, quota_class.class_name,
|
||||
quota_class.resource)
|
||||
self.assertEqual(quota_class.hard_limit, res.hard_limit)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(dbapi, '_get_dbdriver_instance')
|
||||
def test_get_quota_class_by_default(self, mock_db_inst,
|
||||
mock_write, mock_read):
|
||||
mock_db_inst.return_value = etcdapi.get_backend()
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
quota_class_1 = utils.create_test_quota_class(
|
||||
context=self.context, resource='fake_resource_1', hard_limit=10)
|
||||
quota_class_2 = utils.create_test_quota_class(
|
||||
context=self.context, resource='fake_resource_2', hard_limit=10)
|
||||
quota_classes = [quota_class_1, quota_class_2]
|
||||
mock_read.side_effect = lambda *args: utils.FakeEtcdMultipleResult(
|
||||
[quota_class_1.as_dict(), quota_class_2.as_dict()])
|
||||
res = dbapi.quota_class_get_default(self.context)
|
||||
self.assertEqual([qc.resource for qc in res],
|
||||
[qc.resource for qc in quota_classes])
|
||||
self.assertEqual([q.hard_limit for q in res],
|
||||
[q.hard_limit for q in quota_classes])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(dbapi, '_get_dbdriver_instance')
|
||||
def test_get_quota_class_by_cls_name(self, mock_db_inst,
|
||||
mock_write, mock_read):
|
||||
cls_name = 'fake_class_name'
|
||||
mock_db_inst.return_value = etcdapi.get_backend()
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
quota_class_1 = utils.create_test_quota_class(
|
||||
context=self.context, class_name=cls_name,
|
||||
resource='fake_resource_1', hard_limit=10)
|
||||
quota_class_2 = utils.create_test_quota_class(
|
||||
context=self.context, class_name=cls_name,
|
||||
resource='fake_resource_2', hard_limit=10)
|
||||
quota_classes = [quota_class_1, quota_class_2]
|
||||
mock_read.side_effect = lambda *args: utils.FakeEtcdMultipleResult(
|
||||
[quota_class_1.as_dict(), quota_class_2.as_dict()])
|
||||
res = dbapi.quota_class_get_all_by_name(self.context, cls_name)
|
||||
self.assertEqual([qc.resource for qc in res],
|
||||
[qc.resource for qc in quota_classes])
|
||||
self.assertEqual([q.hard_limit for q in res],
|
||||
[q.hard_limit for q in quota_classes])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'update')
|
||||
@mock.patch.object(dbapi, '_get_dbdriver_instance')
|
||||
def test_update_quota_class(self, mock_db_inst, mock_update,
|
||||
mock_write, mock_read):
|
||||
mock_db_inst.return_value = etcdapi.get_backend()
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
quota_class = utils.create_test_quota_class(context=self.context)
|
||||
new_hard_limit = 60
|
||||
mock_read.side_effect = lambda *args: utils.FakeEtcdResult(
|
||||
quota_class.as_dict())
|
||||
dbapi.quota_class_update(self.context, quota_class.class_name,
|
||||
quota_class.resource, new_hard_limit)
|
||||
self.assertEqual(new_hard_limit,
|
||||
json.loads(mock_update.call_args_list[0][0][0].
|
||||
value.decode('utf-8'))['hard_limit'])
|
||||
|
|
|
|||
|
|
@ -11,18 +11,11 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating Quota via the DB API"""
|
||||
import json
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
import mock
|
||||
from oslo_config import cfg
|
||||
|
||||
from zun.common import context
|
||||
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
|
||||
|
||||
|
|
@ -92,93 +85,3 @@ class DBQuotaTestCase(base.DbTestCase):
|
|||
updated_quota = dbapi.quota_get(self.ctx, quota.project_id,
|
||||
quota.resource)
|
||||
self.assertEqual(updated_quota.hard_limit, 200)
|
||||
|
||||
|
||||
class EtcdDbQuotaTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbQuotaTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_quota(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_quota(context=self.context)
|
||||
mock_read.side_effect = lambda *args: None
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_quota,
|
||||
context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(dbapi, '_get_dbdriver_instance')
|
||||
def test_get_quota(self, mock_db_inst,
|
||||
mock_write, mock_read):
|
||||
mock_db_inst.return_value = etcdapi.get_backend()
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
quota = utils.create_test_quota(context=self.context)
|
||||
mock_read.side_effect = lambda *args: utils.FakeEtcdResult(
|
||||
quota.as_dict())
|
||||
res = dbapi.quota_get(self.context, quota.project_id,
|
||||
quota.resource)
|
||||
self.assertEqual(quota.hard_limit, res.hard_limit)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(dbapi, '_get_dbdriver_instance')
|
||||
def test_get_all_project_quota(self, mock_db_inst,
|
||||
mock_write, mock_read):
|
||||
prj_id = 'fake_project_id'
|
||||
resources = ['fake_resource_1', 'fake_resource_2']
|
||||
hard_limits = [10, 20]
|
||||
mock_db_inst.return_value = etcdapi.get_backend()
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
quota_1 = utils.create_test_quota(
|
||||
context=self.context, project_id=prj_id,
|
||||
resource=resources[0], hard_limit=hard_limits[0])
|
||||
quota_2 = utils.create_test_quota(
|
||||
context=self.context, project_id=prj_id,
|
||||
resource=resources[1], hard_limit=hard_limits[1])
|
||||
quotas = [quota_1, quota_2]
|
||||
mock_read.side_effect = lambda *args: utils.FakeEtcdMultipleResult(
|
||||
[quota_1.as_dict(), quota_2.as_dict()])
|
||||
res = dbapi.quota_get_all_by_project(self.context, prj_id)
|
||||
self.assertEqual([q.resource for q in res],
|
||||
[q.resource for q in quotas])
|
||||
self.assertEqual([q.hard_limit for q in res],
|
||||
[q.hard_limit for q in quotas])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'delete')
|
||||
@mock.patch.object(dbapi, '_get_dbdriver_instance')
|
||||
def test_destroy_quota(self, mock_db_inst, mock_delete,
|
||||
mock_write, mock_read):
|
||||
mock_db_inst.return_value = etcdapi.get_backend()
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
quota = utils.create_test_quota(context=self.context)
|
||||
mock_read.side_effect = lambda *args: utils.FakeEtcdResult(
|
||||
quota.as_dict())
|
||||
dbapi.quota_destroy(
|
||||
self.context, quota.project_id, quota.resource)
|
||||
mock_delete.assert_called_once_with(
|
||||
'/quotas/{}/{}' . format(quota.project_id, quota.resource))
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'update')
|
||||
@mock.patch.object(dbapi, '_get_dbdriver_instance')
|
||||
def test_update_quota(self, mock_db_inst, mock_update,
|
||||
mock_write, mock_read):
|
||||
mock_db_inst.return_value = etcdapi.get_backend()
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
quota = utils.create_test_quota(context=self.context)
|
||||
new_hard_limit = 60
|
||||
mock_read.side_effect = lambda *args: utils.FakeEtcdResult(
|
||||
quota.as_dict())
|
||||
dbapi.quota_update(self.context, quota.project_id, quota.resource,
|
||||
new_hard_limit)
|
||||
self.assertEqual(new_hard_limit,
|
||||
json.loads(mock_update.call_args_list[0][0][0].
|
||||
value.decode('utf-8'))['hard_limit'])
|
||||
|
|
|
|||
|
|
@ -11,23 +11,14 @@
|
|||
# under the License.
|
||||
|
||||
"""Tests for manipulating resource classes via the DB API"""
|
||||
import mock
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
from oslo_config import cfg
|
||||
from oslo_serialization import jsonutils as json
|
||||
from oslo_utils import uuidutils
|
||||
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
|
||||
from zun.tests.unit.db.utils import FakeEtcdResult
|
||||
|
||||
CONF = zun.conf.CONF
|
||||
|
||||
|
|
@ -123,168 +114,3 @@ class DbResourceClassTestCase(base.DbTestCase):
|
|||
self.assertRaises(exception.ResourceClassNotFound,
|
||||
dbapi.update_resource_class, self.context,
|
||||
bad_id, {'name': new_name})
|
||||
|
||||
|
||||
class EtcdDbResourceClassTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbResourceClassTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_resource_class(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_resource_class(context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_resource_class_already_exists(self, mock_write,
|
||||
mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_resource_class(context=self.context, name='123')
|
||||
mock_read.side_effect = lambda *args: None
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_resource_class,
|
||||
context=self.context, name='123')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
resource_class.as_dict())
|
||||
res = dbapi.get_resource_class(self.context, resource_class.uuid)
|
||||
self.assertEqual(resource_class.uuid, res.uuid)
|
||||
self.assertEqual(resource_class.name, res.name)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
[rcs.as_dict()])
|
||||
res = dbapi.get_resource_class(self.context, rcs.name)
|
||||
self.assertEqual(rcs.uuid, res.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_get_resource_class_that_does_not_exist(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ResourceClassNotFound,
|
||||
dbapi.get_resource_class,
|
||||
self.context, 'fake-ident')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
context=self.context, name='class' + str(i))
|
||||
resource_classes.append(res_class.as_dict())
|
||||
names.append(six.text_type(res_class['name']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
resource_classes)
|
||||
res = dbapi.list_resource_classes(self.context)
|
||||
res_names = [r.name for r in res]
|
||||
self.assertEqual(sorted(names), sorted(res_names))
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
context=self.context, name='class' + str(i))
|
||||
resource_classes.append(res_class.as_dict())
|
||||
names.append(six.text_type(res_class['name']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
resource_classes)
|
||||
res = dbapi.list_resource_classes(self.context, sort_key='name')
|
||||
res_names = [r.name for r in res]
|
||||
self.assertEqual(sorted(names), res_names)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, '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)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
resource_class.as_dict())
|
||||
dbapi.destroy_resource_class(self.context, resource_class.uuid)
|
||||
mock_delete.assert_called_once_with(
|
||||
'/resource_classes/%s' % resource_class.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_destroy_resource_class_that_does_not_exist(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ResourceClassNotFound,
|
||||
dbapi.destroy_resource_class,
|
||||
self.context,
|
||||
'ca3e2a25-2901-438d-8157-de7ffd68d535')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, '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)
|
||||
old_name = resource_class.name
|
||||
new_name = 'new-name'
|
||||
self.assertNotEqual(old_name, new_name)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
resource_class.as_dict())
|
||||
dbapi.update_resource_class(
|
||||
self.context, resource_class.uuid, {'name': new_name})
|
||||
self.assertEqual(new_name, json.loads(
|
||||
mock_update.call_args_list[0][0][0].value)['name'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_update_resource_class_not_found(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
new_name = 'new-name'
|
||||
self.assertRaises(exception.ResourceClassNotFound,
|
||||
dbapi.update_resource_class,
|
||||
self.context,
|
||||
'ca3e2a25-2901-438d-8157-de7ffd68d535',
|
||||
{'name': new_name})
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_resource_class,
|
||||
self.context, resource_class.uuid,
|
||||
{'uuid': ''})
|
||||
|
|
|
|||
|
|
@ -10,23 +10,14 @@
|
|||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
import json
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
import mock
|
||||
from oslo_config import cfg
|
||||
from oslo_utils import uuidutils
|
||||
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
|
||||
from zun.tests.unit.db.utils import FakeEtcdResult
|
||||
|
||||
CONF = zun.conf.CONF
|
||||
|
||||
|
|
@ -176,192 +167,3 @@ class DbVolumeMappingTestCase(base.DbTestCase):
|
|||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_volume_mapping, self.context,
|
||||
volume_mapping.id, {'uuid': ''})
|
||||
|
||||
|
||||
class EtcdDbVolumeMappingTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbVolumeMappingTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_volume_mapping(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_volume_mapping(context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_volume_mapping_already_exists(self, mock_write,
|
||||
mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_volume_mapping(context=self.context)
|
||||
mock_read.side_effect = lambda *args: None
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_volume_mapping,
|
||||
context=self.context)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
volume_mapping.as_dict())
|
||||
res = dbapi.get_volume_mapping_by_uuid(self.context,
|
||||
volume_mapping.uuid)
|
||||
self.assertEqual(volume_mapping.id, res.id)
|
||||
self.assertEqual(volume_mapping.uuid, res.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_get_volume_mapping_that_does_not_exist(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.VolumeMappingNotFound,
|
||||
dbapi.get_volume_mapping_by_uuid,
|
||||
self.context,
|
||||
uuidutils.generate_uuid())
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,
|
||||
name='volume_mapping' + str(i))
|
||||
volume_mappings.append(volume_mapping.as_dict())
|
||||
uuids.append(six.text_type(volume_mapping['uuid']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
volume_mappings)
|
||||
res = dbapi.list_volume_mappings(self.context)
|
||||
res_uuids = [r.uuid for r in res]
|
||||
self.assertEqual(sorted(uuids), sorted(res_uuids))
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,
|
||||
name='volume_mapping' + str(i))
|
||||
volume_mappings.append(volume_mapping.as_dict())
|
||||
uuids.append(six.text_type(volume_mapping['uuid']))
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
volume_mappings)
|
||||
res = dbapi.list_volume_mappings(self.context, sort_key='uuid')
|
||||
res_uuids = [r.uuid for r in res]
|
||||
self.assertEqual(sorted(uuids), res_uuids)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.list_volume_mappings,
|
||||
self.context,
|
||||
sort_key='wrong_key')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
name='volume_mapping1',
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context)
|
||||
volume_mapping2 = utils.create_test_volume_mapping(
|
||||
name='volume_mapping2',
|
||||
uuid=uuidutils.generate_uuid(),
|
||||
context=self.context,)
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
[volume_mapping1.as_dict(), volume_mapping2.as_dict()])
|
||||
|
||||
res = dbapi.list_volume_mappings(
|
||||
self.context, filters={'uuid': volume_mapping1.uuid})
|
||||
self.assertEqual([volume_mapping1.id], [r.id for r in res])
|
||||
|
||||
res = dbapi.list_volume_mappings(
|
||||
self.context, filters={'uuid': volume_mapping2.uuid})
|
||||
self.assertEqual([volume_mapping2.id], [r.id for r in res])
|
||||
|
||||
res = dbapi.list_volume_mappings(
|
||||
self.context, filters={'uuid': 'unknow-uuid'})
|
||||
self.assertEqual([], [r.id for r in res])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, '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)
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
volume_mapping.as_dict())
|
||||
dbapi.destroy_volume_mapping(self.context, volume_mapping.uuid)
|
||||
mock_delete.assert_called_once_with(
|
||||
'/volume_mappings/%s' % volume_mapping.uuid)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_destroy_volume_mapping_that_does_not_exist(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.VolumeMappingNotFound,
|
||||
dbapi.destroy_volume_mapping, self.context,
|
||||
uuidutils.generate_uuid())
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'update')
|
||||
@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)
|
||||
new_conn_info = 'new-conn-info'
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
volume_mapping.as_dict())
|
||||
dbapi.update_volume_mapping(self.context, volume_mapping.uuid,
|
||||
{'container_info': new_conn_info})
|
||||
self.assertEqual(new_conn_info, json.loads(
|
||||
mock_update.call_args_list[0][0][0].value.decode('utf-8'))
|
||||
['container_info'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_update_volume_mapping_not_found(self, mock_read):
|
||||
volume_mapping_uuid = uuidutils.generate_uuid()
|
||||
new_conn_info = 'new-conn-info'
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.VolumeMappingNotFound,
|
||||
dbapi.update_volume_mapping, self.context,
|
||||
volume_mapping_uuid,
|
||||
{'container_info': new_conn_info})
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_update_volume_mapping_uuid(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
volume_mapping = utils.create_test_volume_mapping(
|
||||
context=self.context)
|
||||
self.assertRaises(exception.InvalidParameterValue,
|
||||
dbapi.update_volume_mapping, self.context,
|
||||
volume_mapping.uuid, {'uuid': ''})
|
||||
|
|
|
|||
|
|
@ -12,20 +12,9 @@
|
|||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
import mock
|
||||
|
||||
import etcd
|
||||
from etcd import Client as etcd_client
|
||||
from oslo_config import cfg
|
||||
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
|
||||
from zun.tests.unit.db.utils import FakeEtcdResult
|
||||
|
||||
|
||||
class DbZunServiceTestCase(base.DbTestCase):
|
||||
|
|
@ -128,136 +117,3 @@ class DbZunServiceTestCase(base.DbTestCase):
|
|||
|
||||
res = self.dbapi.list_zun_services_by_binary(binary='none')
|
||||
self.assertEqual(0, len(res))
|
||||
|
||||
|
||||
class EtcdDbZunServiceTestCase(base.DbTestCase):
|
||||
|
||||
def setUp(self):
|
||||
cfg.CONF.set_override('backend', 'etcd', 'database')
|
||||
super(EtcdDbZunServiceTestCase, self).setUp()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_zun_service(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_zun_service()
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_create_zun_service_already_exists(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
utils.create_test_zun_service()
|
||||
mock_read.side_effect = lambda *args: None
|
||||
self.assertRaises(exception.ResourceExists,
|
||||
utils.create_test_zun_service)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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(
|
||||
zun_service.as_dict())
|
||||
res = dbapi.get_zun_service(
|
||||
self.context, zun_service.host, zun_service.binary)
|
||||
self.assertEqual(zun_service.host, res.host)
|
||||
self.assertEqual(zun_service.binary, res.binary)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
def test_get_zun_service_not_found(self, mock_write, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
zun_service = utils.create_test_zun_service()
|
||||
res = dbapi.get_zun_service(
|
||||
self.context, 'wrong_host_name', zun_service.binary)
|
||||
self.assertIsNone(res)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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')
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
[service_1.as_dict(), service_2.as_dict()])
|
||||
res = dbapi.list_zun_services(self.context)
|
||||
self.assertEqual(2, len(res))
|
||||
self.assertEqual('host_1', res[0].host)
|
||||
self.assertEqual('host_2', res[1].host)
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@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')
|
||||
service_2 = utils.create_test_zun_service(
|
||||
host='host_2', binary='binary_2')
|
||||
mock_read.side_effect = lambda *args: FakeEtcdMultipleResult(
|
||||
[service_1.as_dict(), service_2.as_dict()])
|
||||
res = dbapi.list_zun_services_by_binary(
|
||||
self.context, 'binary_1')
|
||||
self.assertEqual(1, len(res))
|
||||
self.assertEqual('host_1', res[0].host)
|
||||
self.assertEqual('binary_1', res[0].binary)
|
||||
|
||||
res = dbapi.list_zun_services_by_binary(
|
||||
self.context, 'fake-binary')
|
||||
self.assertEqual(0, len(res))
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'delete')
|
||||
@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(
|
||||
zun_service.as_dict())
|
||||
dbapi.destroy_zun_service(zun_service.host,
|
||||
zun_service.binary)
|
||||
mock_delete.assert_called_once_with(
|
||||
'/zun_services/%s' % zun_service.host + '_' + zun_service.binary)
|
||||
|
||||
@mock.patch.object(etcd_client, '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,
|
||||
'host_1', 'binary_1')
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
@mock.patch.object(etcd_client, 'write')
|
||||
@mock.patch.object(etcd_client, 'update')
|
||||
@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'
|
||||
|
||||
mock_read.side_effect = lambda *args: FakeEtcdResult(
|
||||
service.as_dict())
|
||||
dbapi.update_zun_service(service.host, service.binary,
|
||||
{'host': new_host})
|
||||
self.assertEqual(new_host, json.loads(
|
||||
mock_update.call_args_list[0][0][0].value)['host'])
|
||||
|
||||
@mock.patch.object(etcd_client, 'read')
|
||||
def test_update_zun_service_not_exist(self, mock_read):
|
||||
mock_read.side_effect = etcd.EtcdKeyNotFound
|
||||
self.assertRaises(exception.ZunServiceNotFound,
|
||||
dbapi.update_zun_service,
|
||||
'host_1', 'binary_1', {'host': 'new-host'})
|
||||
|
|
|
|||
|
|
@ -10,10 +10,8 @@
|
|||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
"""Zun test utilities."""
|
||||
import mock
|
||||
|
||||
from oslo_config import cfg
|
||||
from oslo_serialization import jsonutils as json
|
||||
|
||||
from zun.common import name_generator
|
||||
from zun.db import api as db_api
|
||||
|
|
@ -421,20 +419,6 @@ def create_test_compute_node(**kwargs):
|
|||
return dbapi.create_compute_node(kwargs['context'], compute_host)
|
||||
|
||||
|
||||
class FakeEtcdMultipleResult(object):
|
||||
def __init__(self, value):
|
||||
self.children = []
|
||||
for v in value:
|
||||
res = mock.MagicMock()
|
||||
res.value = json.dump_as_bytes(v)
|
||||
self.children.append(res)
|
||||
|
||||
|
||||
class FakeEtcdResult(object):
|
||||
def __init__(self, value):
|
||||
self.value = json.dump_as_bytes(value)
|
||||
|
||||
|
||||
def get_test_capsule(**kwargs):
|
||||
return {
|
||||
'capsule_version': kwargs.get('capsule_version', 'beta'),
|
||||
|
|
|
|||
Loading…
Reference in New Issue