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'])