def test_update_image_metadata(self):
# Update image metadata
image_metadata = {
'image_id': '5137a025-3c5f-43c1-bc64-5f41270040a5',
'image_name': 'image',
'kernel_id': '6ff710d2-942b-4d6b-9168-8c9cc2404ab1',
'ramdisk_id': 'somedisk'
}
self.volumes_client.update_volume_image_metadata(
self.volume['id'], **image_metadata)
# Fetch image metadata from the volume
volume_image_metadata = self.volumes_client.show_volume(
self.volume['id'])['volume']['volume_image_metadata']
# Verify image metadata was updated
self.assertThat(volume_image_metadata.items(),
matchers.ContainsAll(image_metadata.items()))
# Delete one item from image metadata of the volume
self.volumes_client.delete_volume_image_metadata(
self.volume['id'], 'ramdisk_id')
del image_metadata['ramdisk_id']
# Fetch the new image metadata from the volume
volume_image_metadata = self.volumes_client.show_volume(
self.volume['id'])['volume']['volume_image_metadata']
# Verify image metadata was updated after item deletion
self.assertThat(volume_image_metadata.items(),
matchers.ContainsAll(image_metadata.items()))
self.assertNotIn('ramdisk_id', volume_image_metadata)
def test_update_show_snapshot_metadata_item(self):
# Update metadata item for the snapshot
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
update_item = {"key3": "value3_update"}
expect = {"key1": "value1", "key2": "value2", "key3": "value3_update"}
# Create metadata for the snapshot
self.snapshots_client.create_snapshot_metadata(self.snapshot['id'],
metadata)
# Get the metadata of the snapshot
body = self.snapshots_client.show_snapshot_metadata(
self.snapshot['id'])['metadata']
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Update metadata item
body = self.snapshots_client.update_snapshot_metadata_item(
self.snapshot['id'], "key3", meta=update_item)['meta']
self.assertEqual(update_item, body)
# Get a specific metadata item of the snapshot
body = self.snapshots_client.show_snapshot_metadata_item(
self.snapshot['id'], "key3")['meta']
self.assertEqual({"key3": expect['key3']}, body)
# Get the metadata of the snapshot
body = self.snapshots_client.show_snapshot_metadata(
self.snapshot['id'])['metadata']
self.assertThat(body.items(), matchers.ContainsAll(expect.items()))
def test_update_default_quotas(self):
"""Test updating default compute quota class set"""
# get the current 'default' quota class values
body = (self.adm_client.show_quota_class_set('default')
['quota_class_set'])
self.assertEqual('default', body.pop('id'))
# restore the defaults when the test is done
self.addCleanup(self._restore_default_quotas, body.copy())
# increment all of the values for updating the default quota class
for quota, default in body.items():
# NOTE(sdague): we need to increment a lot, otherwise
# there is a real chance that we go from -1 (unlimited)
# to a very small number which causes issues.
body[quota] = default + 100
# update limits for the default quota class set
update_body = self.adm_client.update_quota_class_set(
'default', **body)['quota_class_set']
# assert that the response has all of the changed values
self.assertThat(update_body.items(),
matchers.ContainsAll(body.items()))
# check quota values are changed
show_body = self.adm_client.show_quota_class_set(
'default')['quota_class_set']
self.assertThat(show_body.items(),
matchers.ContainsAll(body.items()))
def test_crud_snapshot_metadata(self):
# Create metadata for the snapshot
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
update = {"key3": "value3_update", "key4": "value4"}
expect = {"key4": "value4"}
# Create metadata
body = self.snapshots_client.create_snapshot_metadata(
self.snapshot['id'], metadata)['metadata']
# Get the metadata of the snapshot
body = self.snapshots_client.show_snapshot_metadata(
self.snapshot['id'])['metadata']
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()),
'Create snapshot metadata failed')
# Update metadata
body = self.snapshots_client.update_snapshot_metadata(
self.snapshot['id'], metadata=update)['metadata']
body = self.snapshots_client.show_snapshot_metadata(
self.snapshot['id'])['metadata']
self.assertEqual(update, body, 'Update snapshot metadata failed')
# Delete one item metadata of the snapshot
self.snapshots_client.delete_snapshot_metadata_item(
self.snapshot['id'], "key3")
body = self.snapshots_client.show_snapshot_metadata(
self.snapshot['id'])['metadata']
self.assertThat(body.items(), matchers.ContainsAll(expect.items()),
'Delete one item metadata of the snapshot failed')
self.assertNotIn("key3", body)
def test_update_volume_metadata_item(self):
# Update metadata item for the volume
metadata = {"key1": "value1",
"key2": "value2",
"key3": "value3"}
update_item = {"key3": "value3_update"}
expect = {"key1": "value1",
"key2": "value2",
"key3": "value3_update"}
# Create metadata for the volume
resp, body = self.volumes_client.create_volume_metadata(
self.volume_id,
metadata)
self.assertEqual(200, resp.status)
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Update metadata item
resp, body = self.volumes_client.update_volume_metadata_item(
self.volume_id,
"key3",
update_item)
self.assertEqual(200, resp.status)
# Get the metadata of the volume
resp, body = self.volumes_client.get_volume_metadata(self.volume_id)
self.assertEqual(200, resp.status)
self.assertThat(body.items(), matchers.ContainsAll(expect.items()))
def test_crud_volume_metadata(self):
# Create metadata for the volume
metadata = {
"key1": "value1",
"key2": "value2",
"key3": "value3",
"key4": "<value&special_chars>"
}
update = {"key4": "value4", "key1": "value1_update"}
expected = {"key4": "value4"}
body = self.volumes_client.create_volume_metadata(
self.volume['id'], metadata)['metadata']
# Get the metadata of the volume
body = self.volumes_client.show_volume_metadata(
self.volume['id'])['metadata']
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()),
'Create metadata for the volume failed')
# Update metadata
body = self.volumes_client.update_volume_metadata(
self.volume['id'], update)['metadata']
body = self.volumes_client.show_volume_metadata(
self.volume['id'])['metadata']
self.assertEqual(update, body, 'Update metadata failed')
# Delete one item metadata of the volume
self.volumes_client.delete_volume_metadata_item(
self.volume['id'], "key1")
body = self.volumes_client.show_volume_metadata(
self.volume['id'])['metadata']
self.assertNotIn("key1", body)
self.assertThat(body.items(), matchers.ContainsAll(expected.items()),
'Delete one item metadata of the volume failed')
def test_update_default_quota(self):
"""Test updating default volume quota class set
Check current project and new project's default quota are updated
to the provided one.
"""
LOG.debug("Get the current default quota class values")
body = self.admin_quota_classes_client.show_quota_class_set(
'default')['quota_class_set']
# Note(jeremyZ) Only include specified quota keys to avoid the conflict
# that other tests may create/delete volume types or update volume
# type's default quotas in concurrency running.
update_kwargs = {key: body[key] for key in body if key in QUOTA_KEYS}
# Restore the defaults when the test is done.
self.addCleanup(self._restore_default_quotas, update_kwargs.copy())
# Note(jeremyZ) Increment some of the values for updating the default
# quota class. For safety, only items with value >= 0 will be updated,
# and items with value < 0 (-1 means unlimited) will be ignored.
for quota, default in update_kwargs.items():
if default >= 0:
update_kwargs[quota] = default + 1
# Create a volume type for updating default quotas class.
volume_type_name = self.create_volume_type()['name']
for key in ['volumes', 'snapshots', 'gigabytes']:
update_kwargs['%s_%s' % (key, volume_type_name)] = \
random.randint(1, 10)
LOG.debug("Update limits for the default quota class set")
update_body = self.admin_quota_classes_client.update_quota_class_set(
'default', **update_kwargs)['quota_class_set']
self.assertThat(update_body.items(),
matchers.ContainsAll(update_kwargs.items()))
# Verify current project's default quotas.
default_quotas = self.admin_quotas_client.show_default_quota_set(
self.os_admin.credentials.tenant_id)['quota_set']
self.assertThat(default_quotas.items(),
matchers.ContainsAll(update_kwargs.items()))
# Verify a new project's default quotas.
project_name = data_utils.rand_name('quota_class_tenant')
description = data_utils.rand_name('desc_')
project_id = identity.identity_utils(self.os_admin).create_project(
name=project_name, description=description)['id']
self.addCleanup(identity.identity_utils(self.os_admin).delete_project,
project_id)
default_quotas = self.admin_quotas_client.show_default_quota_set(
project_id)['quota_set']
self.assertThat(default_quotas.items(),
matchers.ContainsAll(update_kwargs.items()))
def test_create_get_delete_snapshot_metadata(self):
# Create metadata for the snapshot
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
expected = {"key2": "value2", "key3": "value3"}
body = self.client.create_snapshot_metadata(self.snapshot_id, metadata)
# Get the metadata of the snapshot
body = self.client.show_snapshot_metadata(self.snapshot_id)
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Delete one item metadata of the snapshot
self.client.delete_snapshot_metadata_item(self.snapshot_id, "key1")
body = self.client.show_snapshot_metadata(self.snapshot_id)
self.assertThat(body.items(), matchers.ContainsAll(expected.items()))
self.assertNotIn("key1", body)
def test_update_snapshot_metadata_item(self):
# Update metadata item for the snapshot
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
update_item = {"key3": "value3_update"}
expect = {"key1": "value1", "key2": "value2", "key3": "value3_update"}
# Create metadata for the snapshot
body = self.client.create_snapshot_metadata(self.snapshot_id, metadata)
# Get the metadata of the snapshot
body = self.client.show_snapshot_metadata(self.snapshot_id)
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Update metadata item
body = self.client.update_snapshot_metadata_item(
self.snapshot_id, "key3", update_item)
# Get the metadata of the snapshot
body = self.client.show_snapshot_metadata(self.snapshot_id)
self.assertThat(body.items(), matchers.ContainsAll(expect.items()))
def test_volume_create_get_delete(self):
# CREATE, GET, DELETE Volume
v_name = data_utils.rand_name(self.__class__.__name__ + '-Volume')
metadata = {'Type': 'work'}
# Create volume
volume = self.create_volume(size=CONF.volume.volume_size,
display_name=v_name,
metadata=metadata)
self.assertEqual(
volume['displayName'], v_name,
"The created volume name is not equal "
"to the requested name")
# GET Volume
fetched_volume = self.volumes_client.show_volume(
volume['id'])['volume']
# Verification of details of fetched Volume
self.assertEqual(
v_name, fetched_volume['displayName'],
'The fetched Volume is different '
'from the created Volume')
self.assertEqual(
CONF.volume.volume_size, fetched_volume['size'],
'The fetched volume size is different '
'from the created Volume')
self.assertEqual(
volume['id'], fetched_volume['id'],
'The fetched Volume is different '
'from the created Volume')
self.assertThat(
fetched_volume['metadata'].items(),
matchers.ContainsAll(metadata.items()),
'The fetched Volume metadata misses data '
'from the created Volume')
def test_entry_point_middleware(self):
"""Assert that our list of expected middleware is present."""
expected_names = [
'admin_token_auth',
'build_auth_context',
'crud_extension',
'cors',
'debug',
'endpoint_filter_extension',
'ec2_extension',
'ec2_extension_v3',
'federation_extension',
'json_body',
'oauth1_extension',
'request_id',
'revoke_extension',
's3_extension',
'simple_cert_extension',
'sizelimit',
'token_auth',
'url_normalize',
'user_crud_extension',
]
em = stevedore.ExtensionManager('paste.filter_factory')
actual_names = [extension.name for extension in em]
self.assertThat(actual_names, matchers.ContainsAll(expected_names))
def test_update_volume_metadata_item(self):
# Update metadata item for the volume
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
update_item = {"key3": "value3_update"}
expect = {"key1": "value1", "key2": "value2", "key3": "value3_update"}
# Create metadata for the volume
body = self.volumes_client.create_volume_metadata(
self.volume_id, metadata)['metadata']
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Update metadata item
body = self.volumes_client.update_volume_metadata_item(
self.volume_id, "key3", update_item)['meta']
# Get the metadata of the volume
body = self.volumes_client.show_volume_metadata(
self.volume_id)['metadata']
self.assertThat(body.items(), matchers.ContainsAll(expect.items()))
def _list_by_param_value_and_assert(self, params, with_detail=False):
"""
Perform list or list_details action with given params
and validates result.
"""
if with_detail:
_, fetched_vol_list = \
self.client.list_volumes_with_detail(params=params)
else:
_, fetched_vol_list = self.client.list_volumes(params=params)
# Validating params of fetched volumes
# In v2, only list detail view includes items in params.
# In v1, list view and list detail view are same. So the
# following check should be run when 'with_detail' is True
# or v1 tests.
if with_detail or self._api_version == 1:
for volume in fetched_vol_list:
for key in params:
msg = "Failed to list volumes %s by %s" % \
('details' if with_detail else '', key)
if key == 'metadata':
self.assertThat(
volume[key].items(),
matchers.ContainsAll(params[key].items()), msg)
else:
self.assertEqual(params[key], volume[key], msg)
def test_volume_create_get_delete(self):
# CREATE, GET, DELETE Volume
volume = None
v_name = data_utils.rand_name('Volume')
metadata = {'Type': 'work'}
# Create volume
volume = self.client.create_volume(size=1,
display_name=v_name,
metadata=metadata)
self.addCleanup(self.delete_volume, volume['id'])
self.assertIn('id', volume)
self.assertIn('displayName', volume)
self.assertEqual(volume['displayName'], v_name,
"The created volume name is not equal "
"to the requested name")
self.assertTrue(volume['id'] is not None,
"Field volume id is empty or not found.")
# Wait for Volume status to become ACTIVE
self.client.wait_for_volume_status(volume['id'], 'available')
# GET Volume
fetched_volume = self.client.get_volume(volume['id'])
# Verification of details of fetched Volume
self.assertEqual(v_name,
fetched_volume['displayName'],
'The fetched Volume is different '
'from the created Volume')
self.assertEqual(volume['id'],
fetched_volume['id'],
'The fetched Volume is different '
'from the created Volume')
self.assertThat(fetched_volume['metadata'].items(),
matchers.ContainsAll(metadata.items()),
'The fetched Volume metadata misses data '
'from the created Volume')
def _list_by_param_value_and_assert(self, params, expected_list=None,
with_detail=False):
"""
Perform list or list_details action with given params
and validates result.
"""
if with_detail:
resp, fetched_vol_list = \
self.client.list_volumes_with_detail(params=params)
else:
resp, fetched_vol_list = self.client.list_volumes(params=params)
self.assertEqual(200, resp.status)
if expected_list is None:
expected_list = self.volume_list
self.assertVolumesIn(fetched_vol_list, expected_list,
fields=VOLUME_FIELDS)
# Validating params of fetched volumes
if with_detail:
for volume in fetched_vol_list:
for key in params:
msg = "Failed to list volumes %s by %s" % \
('details' if with_detail else '', key)
if key == 'metadata':
self.assertThat(volume[key].items(),
matchers.ContainsAll(
params[key].items()), msg)
else:
self.assertEqual(params[key], volume[key], msg)
def __init__(self, expected):
super(_VersionsEqual, self).__init__([
tt_matchers.KeysEqual(expected),
tt_matchers.KeysEqual(expected['versions']),
tt_matchers.HasLength(len(expected['versions']['values'])),
tt_matchers.ContainsAll(expected['versions']['values']),
])
def test_update_volume_metadata(self):
# Update metadata for the volume
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
update = {"key4": "value4", "key1": "value1_update"}
# Create metadata for the volume
body = self.volumes_client.create_volume_metadata(
self.volume_id, metadata)
# Get the metadata of the volume
body = self.volumes_client.get_volume_metadata(self.volume_id)
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Update metadata
body = self.volumes_client.update_volume_metadata(
self.volume_id, update)
# Get the metadata of the volume
body = self.volumes_client.get_volume_metadata(self.volume_id)
self.assertThat(body.items(), matchers.ContainsAll(update.items()))
def test_create_get_delete_volume_metadata(self):
# Create metadata for the volume
metadata = {"key1": "value1",
"key2": "value2",
"key3": "value3",
"key4": "<value&special_chars>"}
_, body = self.volumes_client.create_volume_metadata(self.volume_id,
metadata)
# Get the metadata of the volume
_, body = self.volumes_client.get_volume_metadata(self.volume_id)
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Delete one item metadata of the volume
self.volumes_client.delete_volume_metadata_item(
self.volume_id, "key1")
_, body = self.volumes_client.get_volume_metadata(self.volume_id)
self.assertNotIn("key1", body)
del metadata["key1"]
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
def test_volume_backup_create_get_detailed_list_restore_delete(self):
"""Test create/get/list/restore/delete volume backup
1. Create volume1 with metadata
2. Create backup1 from volume1
3. Show backup1
4. List backups with detail
5. Restore backup1
6. Verify backup1 has been restored successfully with the metadata
of volume1
"""
# Create a volume with metadata
metadata = {
"vol-meta1": "value1",
"vol-meta2": "value2",
"vol-meta3": "value3"
}
volume = self.create_volume(metadata=metadata)
self.addCleanup(self.delete_volume, self.volumes_client, volume['id'])
# Create a backup
backup_name = data_utils.rand_name(self.__class__.__name__ + '-Backup')
description = data_utils.rand_name("volume-backup-description")
backup = self.create_backup(volume_id=volume['id'],
name=backup_name,
description=description,
container='container')
self.assertEqual(backup_name, backup['name'])
waiters.wait_for_volume_resource_status(self.volumes_client,
volume['id'], 'available')
# Get a given backup
backup = self.backups_client.show_backup(backup['id'])['backup']
self.assertEqual(backup_name, backup['name'])
self.assertEqual(description, backup['description'])
self.assertEqual('container', backup['container'])
# Get all backups with detail
backups = self.backups_client.list_backups(detail=True)['backups']
self.assertIn((backup['name'], backup['id']),
[(m['name'], m['id']) for m in backups])
restored_volume = self.restore_backup(backup['id'])
restored_volume_metadata = self.volumes_client.show_volume(
restored_volume['volume_id'])['volume']['metadata']
# Verify the backup has been restored successfully
# with the metadata of the source volume.
self.assertThat(restored_volume_metadata.items(),
matchers.ContainsAll(metadata.items()))
def test_update_default_quota(self):
LOG.debug("Get the current default quota class values")
body = self.admin_quota_classes_client.show_quota_class_set(
'default')['quota_class_set']
body.pop('id')
# Restore the defaults when the test is done
self.addCleanup(self._restore_default_quotas, body.copy())
# Increment some of the values for updating the default quota class.
# For safety, only items with value >= 0 will be updated, and items
# with value < 0 (-1 means unlimited) will be ignored.
for quota, default in body.items():
if default >= 0:
body[quota] = default + 1
LOG.debug("Update limits for the default quota class set")
update_body = self.admin_quota_classes_client.update_quota_class_set(
'default', **body)['quota_class_set']
self.assertThat(update_body.items(),
matchers.ContainsAll(body.items()))
# Verify current project's default quotas
default_quotas = self.admin_quotas_client.show_default_quota_set(
self.os_adm.credentials.tenant_id)['quota_set']
self.assertThat(default_quotas.items(),
matchers.ContainsAll(body.items()))
# Verify a new project's default quotas
project_name = data_utils.rand_name('quota_class_tenant')
description = data_utils.rand_name('desc_')
project_id = self.identity_utils.create_project(
name=project_name, description=description)['id']
self.addCleanup(self.identity_utils.delete_project, project_id)
default_quotas = self.admin_quotas_client.show_default_quota_set(
project_id)['quota_set']
self.assertThat(default_quotas.items(),
matchers.ContainsAll(body.items()))
def test_entry_point_middleware(self):
"""Assert that our list of expected middleware is present."""
expected_names = [
'cors',
'debug',
'request_id',
'sizelimit',
]
em = stevedore.ExtensionManager('keystone.server_middleware')
actual_names = [extension.name for extension in em]
self.assertThat(actual_names, matchers.ContainsAll(expected_names))
def test_update_show_volume_metadata_item(self):
"""Test updating and getting single volume metadata item"""
# Update metadata item for the volume
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
update_item = {"key3": "value3_update"}
expect = {"key1": "value1", "key2": "value2", "key3": "value3_update"}
# Create metadata for the volume
body = self.volumes_client.create_volume_metadata(
self.volume['id'], metadata)['metadata']
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Update metadata item
body = self.volumes_client.update_volume_metadata_item(
self.volume['id'], "key3", update_item)['meta']
self.assertEqual(update_item, body)
# Get a specific metadata item of the volume
body = self.volumes_client.show_volume_metadata_item(
self.volume['id'], "key3")['meta']
self.assertEqual({"key3": expect['key3']}, body)
# Get the metadata of the volume
body = self.volumes_client.show_volume_metadata(
self.volume['id'])['metadata']
self.assertThat(body.items(), matchers.ContainsAll(expect.items()))
def test_entry_points(self):
expected_factory_names = [
'audit',
'auth_token',
'ec2_token',
's3_token',
]
em = stevedore.ExtensionManager('paste.filter_factory')
exp_factories = set(['keystonemiddleware.' + name + ':filter_factory'
for name in expected_factory_names])
actual_factories = set(['{0.__module__}:{0.__name__}'.format(
extension.plugin) for extension in em])
# Ensure that all factories are defined by their names
self.assertThat(actual_factories, matchers.ContainsAll(exp_factories))
def test_update_snapshot_metadata(self):
# Update metadata for the snapshot
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
update = {"key3": "value3_update", "key4": "value4"}
# Create metadata for the snapshot
body = self.client.create_snapshot_metadata(self.snapshot_id, metadata)
# Get the metadata of the snapshot
body = self.client.show_snapshot_metadata(self.snapshot_id)
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Update metadata item
body = self.client.update_snapshot_metadata(self.snapshot_id, update)
# Get the metadata of the snapshot
body = self.client.show_snapshot_metadata(self.snapshot_id)
self.assertEqual(update, body)
def test_snapshot_create_get_list_update_delete(self):
"""Test create/get/list/update/delete snapshot"""
# Create a snapshot with metadata
metadata = {
"snap-meta1": "value1",
"snap-meta2": "value2",
"snap-meta3": "value3"
}
snapshot = self.create_snapshot(self.volume_origin['id'],
metadata=metadata)
# Get the snap and check for some of its details
snap_get = self.snapshots_client.show_snapshot(
snapshot['id'])['snapshot']
self.assertEqual(self.volume_origin['id'], snap_get['volume_id'],
"Referred volume origin mismatch")
self.assertEqual(self.volume_origin['size'], snap_get['size'])
# Verify snapshot metadata
self.assertThat(snap_get['metadata'].items(),
matchers.ContainsAll(metadata.items()))
# Compare also with the output from the list action
tracking_data = (snapshot['id'], snapshot['name'])
snaps_list = self.snapshots_client.list_snapshots()['snapshots']
snaps_data = [(f['id'], f['name']) for f in snaps_list]
self.assertIn(tracking_data, snaps_data)
# Updates snapshot with new values
new_s_name = data_utils.rand_name(self.__class__.__name__ +
'-new-snap')
new_desc = 'This is the new description of snapshot.'
params = {'name': new_s_name, 'description': new_desc}
update_snapshot = self.snapshots_client.update_snapshot(
snapshot['id'], **params)['snapshot']
# Assert response body for update_snapshot method
self.assertEqual(new_s_name, update_snapshot['name'])
self.assertEqual(new_desc, update_snapshot['description'])
# Assert response body for show_snapshot method
updated_snapshot = self.snapshots_client.show_snapshot(
snapshot['id'])['snapshot']
self.assertEqual(new_s_name, updated_snapshot['name'])
self.assertEqual(new_desc, updated_snapshot['description'])
# Delete the snapshot
self.delete_snapshot(snapshot['id'])
def test_entry_points(self):
factory_classes = {
'catch_errors': 'CatchErrors',
'correlation_id': 'CorrelationId',
'cors': 'CORS',
'debug': 'Debug',
'healthcheck': 'Healthcheck',
'http_proxy_to_wsgi': 'HTTPProxyToWSGI',
'request_id': 'RequestId',
'sizelimit': 'RequestBodySizeLimiter',
'ssl': 'SSLMiddleware',
}
em = stevedore.ExtensionManager('paste.filter_factory')
# Ensure all the factories are defined by their names
factory_names = [extension.name for extension in em]
self.assertThat(factory_names, matchers.ContainsAll(factory_classes))
def test_update_default_quotas(self):
LOG.debug("get the current 'default' quota class values")
body = self.adm_client.show_quota_class_set('default')
self.assertIn('id', body)
self.assertEqual('default', body.pop('id'))
# restore the defaults when the test is done
self.addCleanup(self._restore_default_quotas, body.copy())
# increment all of the values for updating the default quota class
for quota, default in six.iteritems(body):
# NOTE(sdague): we need to increment a lot, otherwise
# there is a real chance that we go from -1 (unlimitted)
# to a very small number which causes issues.
body[quota] = default + 100
LOG.debug("update limits for the default quota class set")
update_body = self.adm_client.update_quota_class_set('default', **body)
LOG.debug("assert that the response has all of the changed values")
self.assertThat(update_body.items(),
matchers.ContainsAll(body.items()))
def _list_by_param_value_and_assert(self, params, with_detail=False):
"""list or list_details with given params and validates result"""
if with_detail:
fetched_vol_list = \
self.volumes_client.list_volumes(detail=True,
params=params)['volumes']
else:
fetched_vol_list = self.volumes_client.list_volumes(
params=params)['volumes']
# Validating params of fetched volumes
if with_detail:
for volume in fetched_vol_list:
for key in params:
msg = "Failed to list volumes %s by %s" % \
('details' if with_detail else '', key)
if key == 'metadata':
self.assertThat(
volume[key].items(),
matchers.ContainsAll(params[key].items()), msg)
else:
self.assertEqual(params[key], volume[key], msg)
def test_update_volume_metadata(self):
# Update metadata for the volume
metadata = {"key1": "value1",
"key2": "value2",
"key3": "value3"}
update = {"key4": "value4",
"key1": "value1_update"}
# Create metadata for the volume
body = self.volumes_client.create_volume_metadata(
self.volume['id'], metadata)['metadata']
# Get the metadata of the volume
body = self.volumes_client.show_volume_metadata(
self.volume['id'])['metadata']
self.assertThat(body.items(), matchers.ContainsAll(metadata.items()))
# Update metadata
body = self.volumes_client.update_volume_metadata(
self.volume['id'], update)['metadata']
# Get the metadata of the volume
body = self.volumes_client.show_volume_metadata(
self.volume['id'])['metadata']
self.assertEqual(update, body)
def _volume_create_get_update_delete(self, **kwargs):
# Create a volume, Get it's details and Delete the volume
v_name = data_utils.rand_name(self.__class__.__name__ + '-Volume')
metadata = {'Type': 'Test'}
# Create a volume
kwargs['name'] = v_name
kwargs['metadata'] = metadata
volume = self.volumes_client.create_volume(**kwargs)['volume']
self.addCleanup(self.delete_volume, self.volumes_client, volume['id'])
waiters.wait_for_volume_resource_status(self.volumes_client,
volume['id'], 'available')
self.assertEqual(
volume['name'], v_name, "The created volume name is not equal "
"to the requested name")
# Get Volume information
fetched_volume = self.volumes_client.show_volume(
volume['id'])['volume']
self.assertEqual(
v_name, fetched_volume['name'],
'The fetched Volume name is different '
'from the created Volume')
self.assertEqual(
volume['id'], fetched_volume['id'],
'The fetched Volume id is different '
'from the created Volume')
self.assertThat(
fetched_volume['metadata'].items(),
matchers.ContainsAll(metadata.items()),
'The fetched Volume metadata misses data '
'from the created Volume')
if 'imageRef' in kwargs:
self.assertEqual('true', fetched_volume['bootable'])
else:
self.assertEqual('false', fetched_volume['bootable'])
# Update Volume
# Test volume update when display_name is same with original value
params = {'name': v_name}
self.volumes_client.update_volume(volume['id'], **params)
# Test volume update when display_name is new
new_v_name = data_utils.rand_name(self.__class__.__name__ +
'-new-Volume')
new_desc = 'This is the new description of volume'
params = {'name': new_v_name, 'description': new_desc}
update_volume = self.volumes_client.update_volume(
volume['id'], **params)['volume']
# Assert response body for update_volume method
self.assertEqual(new_v_name, update_volume['name'])
self.assertEqual(new_desc, update_volume['description'])
# Assert response body for show_volume method
updated_volume = self.volumes_client.show_volume(
volume['id'])['volume']
self.assertEqual(volume['id'], updated_volume['id'])
self.assertEqual(new_v_name, updated_volume['name'])
self.assertEqual(new_desc, updated_volume['description'])
self.assertThat(
updated_volume['metadata'].items(),
matchers.ContainsAll(metadata.items()),
'The fetched Volume metadata misses data '
'from the created Volume')
# Test volume create when display_name is none and display_description
# contains specific characters,
# then test volume update if display_name is duplicated
new_v_desc = data_utils.rand_name('@#$%^* description')
params = {
'description': new_v_desc,
'availability_zone': volume['availability_zone'],
'size': CONF.volume.volume_size
}
new_volume = self.volumes_client.create_volume(**params)['volume']
self.addCleanup(self.delete_volume, self.volumes_client,
new_volume['id'])
waiters.wait_for_volume_resource_status(self.volumes_client,
new_volume['id'], 'available')
params = {'name': volume['name'], 'description': volume['description']}
self.volumes_client.update_volume(new_volume['id'], **params)
if 'imageRef' in kwargs:
self.assertEqual('true', updated_volume['bootable'])
else:
self.assertEqual('false', updated_volume['bootable'])
