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])
def test_get_resource_class_by_name(self, mock_write, mock_read):
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)
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'])
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)
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])
def test_list_containers_with_filters(self, mock_write, mock_read):
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])
def test_get_capsule_by_meta_name(self, mock_write, mock_read):
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)
def test_get_container_by_name(self, mock_write, mock_read):
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)
def test_list_zun_services(self, mock_write, mock_read):
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)
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'])
def test_list_resource_classes_sorted(self, mock_write, mock_read):
names = []
resource_classes = []
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)
def test_list_capsules(self, mock_write, mock_read):
uuids = []
capsules = []
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))
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_image(self.context)
res_uuids = [r.uuid for r in res]
self.assertEqual(sorted(uuids), sorted(res_uuids))
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)
def test_list_compute_nodes(self, mock_write, mock_read):
hostnames = []
compute_nodes = []
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))
def test_list_volume_mappings(self, mock_write, mock_read):
uuids = []
volume_mappings = []
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))
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'])
def test_update_container_with_the_same_name(self, mock_update, mock_write,
mock_read):
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'})
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))
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))
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')
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'])
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_image(self.context, filters={'repo': 'imageone'})
self.assertEqual([image1.uuid], [r.uuid for r in res])
res = self.dbapi.list_image(self.context, filters={'repo': 'imagetwo'})
self.assertEqual([image2.uuid], [r.uuid for r in res])
res = self.dbapi.list_image(self.context, filters={'repo': 'foo'})
self.assertEqual([], [r.uuid for r in res])
def test_list_containers_sorted(self, mock_write, mock_read):
uuids = []
containers = []
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')
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'})
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')
