def test_restore_backup_to_undersized_volume(self):
backup_size = 10
backup_id = self._create_backup(status='available', size=backup_size)
# need to create the volume referenced below first
volume_size = 5
volume_id = self._create_volume(status='available', size=volume_size)
body = {"restore": {"volume_id": volume_id, }}
req = webob.Request.blank('/v2/fake/backups/%s/restore' %
backup_id)
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = json.dumps(body)
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(res.status_int, 400)
self.assertEqual(res_dict['badRequest']['code'], 400)
self.assertEqual(res_dict['badRequest']['message'],
'Invalid volume: volume size %d is too '
'small to restore backup of size %d.'
% (volume_size, backup_size))
db.volume_destroy(context.get_admin_context(), volume_id)
db.backup_destroy(context.get_admin_context(), backup_id)
def test_create_volume_from_exact_sized_image(self):
"""Verify that an image which is exactly the same size as the
volume, will work correctly."""
class _FakeImageService:
def __init__(self, db_driver=None, image_service=None):
pass
def show(self, context, image_id):
return {'size': 2 * 1024 * 1024 * 1024,
'disk_format': 'raw',
'container_format': 'bare'}
image_id = '70a599e0-31e7-49b7-b260-868f441e862b'
try:
volume_id = None
volume_api = cinder.volume.api.API(
image_service=_FakeImageService())
volume = volume_api.create(self.context, 2, 'name', 'description',
image_id=1)
volume_id = volume['id']
self.assertEqual(volume['status'], 'creating')
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
def test_create_consistencygroup_from_src_cgsnapshot_empty(self):
consistencygroup = utils.create_consistencygroup(self.ctxt)
volume_id = utils.create_volume(
self.ctxt,
consistencygroup_id=consistencygroup.id)['id']
cgsnapshot = utils.create_cgsnapshot(
self.ctxt,
consistencygroup_id=consistencygroup.id)
test_cg_name = 'test cg'
body = {"consistencygroup-from-src": {"name": test_cg_name,
"description":
"Consistency Group 1",
"cgsnapshot_id": cgsnapshot.id}}
req = webob.Request.blank('/v2/fake/consistencygroups/create_from_src')
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = json.dumps(body)
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(400, res.status_int)
self.assertEqual(400, res_dict['badRequest']['code'])
self.assertIsNotNone(res_dict['badRequest']['message'])
db.volume_destroy(self.ctxt.elevated(), volume_id)
consistencygroup.destroy()
cgsnapshot.destroy()
def test_show_backup(self):
volume_id = self._create_volume(size=5)
backup_id = self._create_backup(volume_id)
LOG.debug('Created backup with id %s' % backup_id)
req = webob.Request.blank('/v2/fake/backups/%s' %
backup_id)
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(res.status_int, 200)
self.assertEqual(res_dict['backup']['availability_zone'], 'az1')
self.assertEqual(res_dict['backup']['container'], 'volumebackups')
self.assertEqual(res_dict['backup']['description'],
'this is a test backup')
self.assertEqual(res_dict['backup']['name'], 'test_backup')
self.assertEqual(res_dict['backup']['id'], backup_id)
self.assertEqual(res_dict['backup']['object_count'], 0)
self.assertEqual(res_dict['backup']['size'], 0)
self.assertEqual(res_dict['backup']['status'], 'creating')
self.assertEqual(res_dict['backup']['volume_id'], volume_id)
db.backup_destroy(context.get_admin_context(), backup_id)
db.volume_destroy(context.get_admin_context(), volume_id)
def test_list_transfers_xml(self):
volume_id_1 = self._create_volume(size=5)
volume_id_2 = self._create_volume(size=5)
transfer1 = self._create_transfer(volume_id_1)
transfer2 = self._create_transfer(volume_id_2)
req = webob.Request.blank('/v2/fake/os-volume-transfer')
req.method = 'GET'
req.headers['Content-Type'] = 'application/xml'
req.headers['Accept'] = 'application/xml'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(res.status_int, 200)
dom = minidom.parseString(res.body)
transfer_list = dom.getElementsByTagName('transfer')
self.assertEqual(transfer_list.item(0).attributes.length, 3)
self.assertEqual(transfer_list.item(0).getAttribute('id'),
transfer1['id'])
self.assertEqual(transfer_list.item(1).attributes.length, 3)
self.assertEqual(transfer_list.item(1).getAttribute('id'),
transfer2['id'])
db.transfer_destroy(context.get_admin_context(), transfer2['id'])
db.transfer_destroy(context.get_admin_context(), transfer1['id'])
db.volume_destroy(context.get_admin_context(), volume_id_2)
db.volume_destroy(context.get_admin_context(), volume_id_1)
def test_create_consistencygroup_from_src_cgsnapshot_empty(self):
ctxt = context.RequestContext('fake', 'fake', auth_token=True)
consistencygroup_id = utils.create_consistencygroup(
ctxt)['id']
volume_id = utils.create_volume(
ctxt,
consistencygroup_id=consistencygroup_id)['id']
cgsnapshot_id = utils.create_cgsnapshot(
ctxt,
consistencygroup_id=consistencygroup_id)['id']
test_cg_name = 'test cg'
body = {"consistencygroup-from-src": {"name": test_cg_name,
"description":
"Consistency Group 1",
"cgsnapshot_id": cgsnapshot_id}}
req = webob.Request.blank('/v2/fake/consistencygroups/create_from_src')
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = json.dumps(body)
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(400, res.status_int)
self.assertEqual(400, res_dict['badRequest']['code'])
msg = _("Invalid ConsistencyGroup: Cgsnahost is empty. No "
"consistency group will be created.")
self.assertIn(msg, res_dict['badRequest']['message'])
db.cgsnapshot_destroy(ctxt.elevated(), cgsnapshot_id)
db.volume_destroy(ctxt.elevated(), volume_id)
db.consistencygroup_destroy(ctxt.elevated(), consistencygroup_id)
def test_list_transfers_detail_json(self):
volume_id_1 = self._create_volume(size=5)
volume_id_2 = self._create_volume(size=5)
transfer1 = self._create_transfer(volume_id_1)
transfer2 = self._create_transfer(volume_id_2)
req = webob.Request.blank('/v2/fake/os-volume-transfer/detail')
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
req.headers['Accept'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(res.status_int, 200)
self.assertEqual(len(res_dict['transfers'][0]), 5)
self.assertEqual(res_dict['transfers'][0]['name'],
'test_transfer')
self.assertEqual(res_dict['transfers'][0]['id'], transfer1['id'])
self.assertEqual(res_dict['transfers'][0]['volume_id'], volume_id_1)
self.assertEqual(len(res_dict['transfers'][1]), 5)
self.assertEqual(res_dict['transfers'][1]['name'],
'test_transfer')
self.assertEqual(res_dict['transfers'][1]['id'], transfer2['id'])
self.assertEqual(res_dict['transfers'][1]['volume_id'], volume_id_2)
db.transfer_destroy(context.get_admin_context(), transfer2['id'])
db.transfer_destroy(context.get_admin_context(), transfer1['id'])
db.volume_destroy(context.get_admin_context(), volume_id_2)
db.volume_destroy(context.get_admin_context(), volume_id_1)
def test_create_volume_from_image_exception(self):
"""Verify that create volume from image, the volume status is
'downloading'."""
dst_fd, dst_path = tempfile.mkstemp()
os.close(dst_fd)
self.stubs.Set(self.volume.driver, "local_path", lambda x: dst_path)
image_id = "aaaaaaaa-0000-0000-0000-000000000000"
# creating volume testdata
volume_id = 1
db.volume_create(
self.context,
{
"id": volume_id,
"updated_at": datetime.datetime(1, 1, 1, 1, 1, 1),
"display_description": "Test Desc",
"size": 20,
"status": "creating",
"host": "dummy",
},
)
self.assertRaises(exception.ImageNotFound, self.volume.create_volume, self.context, volume_id, None, image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume["status"], "error")
# cleanup
db.volume_destroy(self.context, volume_id)
os.unlink(dst_path)
def test_delete_cgsnapshot_with_Invalidcgsnapshot(self):
consistencygroup = utils.create_consistencygroup(self.context)
volume_id = utils.create_volume(
self.context,
consistencygroup_id=consistencygroup.id)['id']
cgsnapshot = utils.create_cgsnapshot(
self.context,
consistencygroup_id=consistencygroup.id,
status='invalid')
req = webob.Request.blank('/v2/fake/cgsnapshots/%s' %
cgsnapshot.id)
req.method = 'DELETE'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
res_dict = jsonutils.loads(res.body)
self.assertEqual(400, res.status_int)
self.assertEqual(400, res_dict['badRequest']['code'])
self.assertEqual('Invalid cgsnapshot',
res_dict['badRequest']['message'])
cgsnapshot.destroy()
db.volume_destroy(context.get_admin_context(),
volume_id)
consistencygroup.destroy()
def test_create_volume_from_image_exception(self):
"""Verify that create volume from image, the volume status is
'downloading'."""
dst_fd, dst_path = tempfile.mkstemp()
os.close(dst_fd)
self.stubs.Set(self.volume.driver, 'local_path', lambda x: dst_path)
image_id = 'aaaaaaaa-0000-0000-0000-000000000000'
# creating volume testdata
volume_id = 1
db.volume_create(self.context,
{'id': volume_id,
'updated_at': datetime.datetime(1, 1, 1, 1, 1, 1),
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'host': 'dummy'})
self.assertRaises(exception.ImageNotFound,
self.volume.create_volume,
self.context,
volume_id, None, None, None,
None,
image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume['status'], "error")
# cleanup
db.volume_destroy(self.context, volume_id)
os.unlink(dst_path)
def test_unmanage_volume_attached(self):
"""Return 400 if the volume exists but is attached."""
vol = utils.create_volume(self.ctxt, status='in-use',
attach_status='attached')
res = self._get_resp(vol.id)
self.assertEqual(400, res.status_int, res)
db.volume_destroy(self.ctxt, vol.id)
def test_show_cgsnapshot(self):
consistencygroup = utils.create_consistencygroup(self.context)
volume_id = utils.create_volume(self.context,
consistencygroup_id=
consistencygroup.id)['id']
cgsnapshot_id = self._create_cgsnapshot(
consistencygroup_id=consistencygroup.id)
req = webob.Request.blank('/v2/fake/cgsnapshots/%s' %
cgsnapshot_id)
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(200, res.status_int)
self.assertEqual('this is a test cgsnapshot',
res_dict['cgsnapshot']['description'])
self.assertEqual('test_cgsnapshot',
res_dict['cgsnapshot']['name'])
self.assertEqual('creating', res_dict['cgsnapshot']['status'])
db.cgsnapshot_destroy(context.get_admin_context(),
cgsnapshot_id)
db.volume_destroy(context.get_admin_context(),
volume_id)
consistencygroup.destroy()
def test_create_consistencygroup_from_src_cg(self):
self.mock_object(volume_api.API, "create", stubs.stub_volume_create)
source_cg = utils.create_consistencygroup(self.ctxt)
volume_id = utils.create_volume(self.ctxt, consistencygroup_id=source_cg.id)["id"]
test_cg_name = "test cg"
body = {
"consistencygroup-from-src": {
"name": test_cg_name,
"description": "Consistency Group 1",
"source_cgid": source_cg.id,
}
}
req = webob.Request.blank("/v2/fake/consistencygroups/create_from_src")
req.method = "POST"
req.headers["Content-Type"] = "application/json"
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app())
res_dict = jsonutils.loads(res.body)
self.assertEqual(202, res.status_int)
self.assertIn("id", res_dict["consistencygroup"])
self.assertEqual(test_cg_name, res_dict["consistencygroup"]["name"])
cg = objects.ConsistencyGroup.get_by_id(self.ctxt, res_dict["consistencygroup"]["id"])
cg.destroy
db.volume_destroy(self.ctxt.elevated(), volume_id)
source_cg.destroy()
def test_delete_cgsnapshot_with_invalid_cgsnapshot(self):
vol_type = utils.create_volume_type(context.get_admin_context(),
self, name='my_vol_type')
consistencygroup = utils.create_group(
self.context,
group_type_id=fake.GROUP_TYPE_ID,
volume_type_ids=[vol_type['id']])
volume_id = utils.create_volume(self.context,
volume_type_id=vol_type['id'],
group_id=
consistencygroup.id)['id']
cgsnapshot = utils.create_group_snapshot(
self.context, group_id=consistencygroup.id,
group_type_id=fake.GROUP_TYPE_ID,
status='invalid')
req = webob.Request.blank('/v2/%s/cgsnapshots/%s' % (
fake.PROJECT_ID, cgsnapshot.id))
req.method = 'DELETE'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app(
fake_auth_context=self.user_ctxt))
res_dict = jsonutils.loads(res.body)
self.assertEqual(http_client.BAD_REQUEST, res.status_int)
self.assertEqual(http_client.BAD_REQUEST,
res_dict['badRequest']['code'])
self.assertIsNotNone(res_dict['badRequest']['message'])
cgsnapshot.destroy()
db.volume_destroy(context.get_admin_context(), volume_id)
consistencygroup.destroy()
def test_list_transfers_detail_json(self):
volume_id_1 = self._create_volume(size=5)
volume_id_2 = self._create_volume(size=5)
transfer1 = self._create_transfer(volume_id_1)
transfer2 = self._create_transfer(volume_id_2)
req = webob.Request.blank('/v2/%s/os-volume-transfer/detail' %
fake.PROJECT_ID)
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
req.headers['Accept'] = 'application/json'
res = req.get_response(fakes.wsgi_app(
fake_auth_context=self.user_ctxt))
res_dict = jsonutils.loads(res.body)
self.assertEqual(200, res.status_int)
self.assertEqual(5, len(res_dict['transfers'][0]))
self.assertEqual('test_transfer',
res_dict['transfers'][0]['name'])
self.assertEqual(transfer1['id'], res_dict['transfers'][0]['id'])
self.assertEqual(volume_id_1, res_dict['transfers'][0]['volume_id'])
self.assertEqual(5, len(res_dict['transfers'][1]))
self.assertEqual('test_transfer',
res_dict['transfers'][1]['name'])
self.assertEqual(transfer2['id'], res_dict['transfers'][1]['id'])
self.assertEqual(volume_id_2, res_dict['transfers'][1]['volume_id'])
db.transfer_destroy(context.get_admin_context(), transfer2['id'])
db.transfer_destroy(context.get_admin_context(), transfer1['id'])
db.volume_destroy(context.get_admin_context(), volume_id_2)
db.volume_destroy(context.get_admin_context(), volume_id_1)
def test_delete_cgsnapshot_available(self):
consistencygroup_id = utils.create_consistencygroup(self.context)['id']
volume_id = utils.create_volume(
self.context,
consistencygroup_id=consistencygroup_id)['id']
cgsnapshot_id = self._create_cgsnapshot(
consistencygroup_id=consistencygroup_id,
status='available')
req = webob.Request.blank('/v2/fake/cgsnapshots/%s' %
cgsnapshot_id)
req.method = 'DELETE'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(res.status_int, 202)
self.assertEqual(self._get_cgsnapshot_attrib(cgsnapshot_id,
'status'),
'deleting')
db.cgsnapshot_destroy(context.get_admin_context(),
cgsnapshot_id)
db.volume_destroy(context.get_admin_context(),
volume_id)
db.consistencygroup_destroy(context.get_admin_context(),
consistencygroup_id)
def test_copy_volume_to_image_status_available(self):
dst_fd, dst_path = tempfile.mkstemp()
os.close(dst_fd)
def fake_local_path(volume):
return dst_path
self.stubs.Set(self.volume.driver, 'local_path', fake_local_path)
image_id = '70a599e0-31e7-49b7-b260-868f441e862b'
# creating volume testdata
volume_id = 1
db.volume_create(self.context, {'id': volume_id,
'updated_at': datetime.datetime(1, 1, 1, 1, 1, 1),
'display_description': 'Test Desc',
'size': 20,
'status': 'uploading',
'instance_uuid': None,
'host': 'dummy'})
try:
# start test
self.volume.copy_volume_to_image(self.context,
volume_id,
image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume['status'], 'available')
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
os.unlink(dst_path)
def test_delete_transfer_awaiting_transfer(self):
volume_id = self._create_volume()
transfer = self._create_transfer(volume_id)
req = webob.Request.blank('/v2/%s/os-volume-transfer/%s' % (
fake.PROJECT_ID, transfer['id']))
req.method = 'DELETE'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app(
fake_auth_context=self.user_ctxt))
self.assertEqual(202, res.status_int)
# verify transfer has been deleted
req = webob.Request.blank('/v2/%s/os-volume-transfer/%s' % (
fake.PROJECT_ID, transfer['id']))
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app(
fake_auth_context=self.user_ctxt))
res_dict = jsonutils.loads(res.body)
self.assertEqual(404, res.status_int)
self.assertEqual(404, res_dict['itemNotFound']['code'])
self.assertEqual('Transfer %s could not be found.' % transfer['id'],
res_dict['itemNotFound']['message'])
self.assertEqual(db.volume_get(context.get_admin_context(),
volume_id)['status'], 'available')
db.volume_destroy(context.get_admin_context(), volume_id)
def test_create_snapshot_force(self):
"""Test snapshot in use can be created forcibly."""
def fake_cast(ctxt, topic, msg):
pass
self.stubs.Set(rpc, 'cast', fake_cast)
instance_uuid = '12345678-1234-5678-1234-567812345678'
volume = self._create_volume()
self.volume.create_volume(self.context, volume['id'])
db.volume_attached(self.context, volume['id'], instance_uuid,
'/dev/sda1')
volume_api = cinder.volume.api.API()
volume = volume_api.get(self.context, volume['id'])
self.assertRaises(exception.InvalidVolume,
volume_api.create_snapshot,
self.context, volume,
'fake_name', 'fake_description')
snapshot_ref = volume_api.create_snapshot_force(self.context,
volume,
'fake_name',
'fake_description')
db.snapshot_destroy(self.context, snapshot_ref['id'])
db.volume_destroy(self.context, volume['id'])
def test_copy_volume_to_image_status_use(self):
dst_fd, dst_path = tempfile.mkstemp()
os.close(dst_fd)
def fake_local_path(volume):
return dst_path
self.stubs.Set(self.volume.driver, 'local_path', fake_local_path)
#image_id = '70a599e0-31e7-49b7-b260-868f441e862b'
image_id = 'a440c04b-79fa-479c-bed1-0b816eaec379'
# creating volume testdata
volume_id = 1
db.volume_create(self.context,
{'id': volume_id,
'updated_at': datetime.datetime(1, 1, 1, 1, 1, 1),
'display_description': 'Test Desc',
'size': 20,
'status': 'uploading',
'instance_uuid':
'b21f957d-a72f-4b93-b5a5-45b1161abb02',
'host': 'dummy'})
try:
# start test
self.volume.copy_volume_to_image(self.context,
volume_id,
image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume['status'], 'in-use')
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
os.unlink(dst_path)
def test_copy_volume_to_image_exception(self):
dst_fd, dst_path = tempfile.mkstemp()
os.close(dst_fd)
def fake_local_path(volume):
return dst_path
self.stubs.Set(self.volume.driver, 'local_path', fake_local_path)
image_id = 'aaaaaaaa-0000-0000-0000-000000000000'
# creating volume testdata
volume_id = 1
db.volume_create(self.context, {'id': volume_id,
'updated_at': datetime.datetime(1, 1, 1, 1, 1, 1),
'display_description': 'Test Desc',
'size': 20,
'status': 'in-use',
'host': 'dummy'})
try:
# start test
self.assertRaises(exception.ImageNotFound,
self.volume.copy_volume_to_image,
self.context,
volume_id,
image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume['status'], 'available')
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
os.unlink(dst_path)
def test_create_consistencygroup_from_src_no_host(self):
consistencygroup = utils.create_consistencygroup(self.ctxt, host=None)
volume_id = utils.create_volume(self.ctxt, consistencygroup_id=consistencygroup.id)["id"]
cgsnapshot = utils.create_cgsnapshot(self.ctxt, consistencygroup_id=consistencygroup.id)
snapshot = utils.create_snapshot(self.ctxt, volume_id, cgsnapshot_id=cgsnapshot.id, status="available")
test_cg_name = "test cg"
body = {
"consistencygroup-from-src": {
"name": test_cg_name,
"description": "Consistency Group 1",
"cgsnapshot_id": cgsnapshot.id,
}
}
req = webob.Request.blank("/v2/fake/consistencygroups/create_from_src")
req.method = "POST"
req.headers["Content-Type"] = "application/json"
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app())
res_dict = jsonutils.loads(res.body)
self.assertEqual(400, res.status_int)
self.assertEqual(400, res_dict["badRequest"]["code"])
msg = _("Invalid ConsistencyGroup: No host to create consistency " "group")
self.assertIn(msg, res_dict["badRequest"]["message"])
snapshot.destroy()
db.volume_destroy(self.ctxt.elevated(), volume_id)
consistencygroup.destroy()
cgsnapshot.destroy()
def test_create_consistencygroup_from_src_cgsnapshot_notfound(self):
consistencygroup = utils.create_consistencygroup(self.ctxt)
volume_id = utils.create_volume(self.ctxt, consistencygroup_id=consistencygroup.id)["id"]
test_cg_name = "test cg"
body = {
"consistencygroup-from-src": {
"name": test_cg_name,
"description": "Consistency Group 1",
"cgsnapshot_id": "fake_cgsnap",
}
}
req = webob.Request.blank("/v2/fake/consistencygroups/create_from_src")
req.method = "POST"
req.headers["Content-Type"] = "application/json"
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app())
res_dict = jsonutils.loads(res.body)
self.assertEqual(404, res.status_int)
self.assertEqual(404, res_dict["itemNotFound"]["code"])
self.assertIsNotNone(res_dict["itemNotFound"]["message"])
db.volume_destroy(self.ctxt.elevated(), volume_id)
consistencygroup.destroy()
def test_create_consistencygroup_from_src_both_snap_cg(self):
self.stubs.Set(volume_api.API, "create", stubs.stub_volume_create)
consistencygroup = utils.create_consistencygroup(self.ctxt)
volume_id = utils.create_volume(self.ctxt, consistencygroup_id=consistencygroup.id)["id"]
cgsnapshot_id = utils.create_cgsnapshot(self.ctxt, consistencygroup_id=consistencygroup.id)["id"]
snapshot = utils.create_snapshot(self.ctxt, volume_id, cgsnapshot_id=cgsnapshot_id, status="available")
test_cg_name = "test cg"
body = {
"consistencygroup-from-src": {
"name": test_cg_name,
"description": "Consistency Group 1",
"cgsnapshot_id": cgsnapshot_id,
"source_cgid": consistencygroup.id,
}
}
req = webob.Request.blank("/v2/fake/consistencygroups/create_from_src")
req.method = "POST"
req.headers["Content-Type"] = "application/json"
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app())
res_dict = jsonutils.loads(res.body)
self.assertEqual(400, res.status_int)
self.assertEqual(400, res_dict["badRequest"]["code"])
self.assertIsNotNone(res_dict["badRequest"]["message"])
snapshot.destroy()
db.cgsnapshot_destroy(self.ctxt.elevated(), cgsnapshot_id)
db.volume_destroy(self.ctxt.elevated(), volume_id)
consistencygroup.destroy()
def test_delete_cgsnapshot_available_used_as_source(self):
vol_type = utils.create_volume_type(context.get_admin_context(),
self, name='my_vol_type')
consistencygroup = utils.create_group(
self.context,
group_type_id=fake.GROUP_TYPE_ID,
volume_type_ids=[vol_type['id']])
volume_id = utils.create_volume(self.context,
volume_type_id=vol_type['id'],
group_id=
consistencygroup.id)['id']
cgsnapshot = utils.create_group_snapshot(
self.context, group_id=consistencygroup.id,
group_type_id=fake.GROUP_TYPE_ID,
status='available')
cg2 = utils.create_consistencygroup(
self.context, status='creating',
group_snapshot_id=cgsnapshot.id,
group_type_id=fake.GROUP_TYPE_ID)
req = webob.Request.blank('/v2/fake/cgsnapshots/%s' %
cgsnapshot.id)
req.method = 'DELETE'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
cgsnapshot = objects.GroupSnapshot.get_by_id(self.context,
cgsnapshot.id)
self.assertEqual(http_client.BAD_REQUEST, res.status_int)
self.assertEqual('available', cgsnapshot.status)
cgsnapshot.destroy()
db.volume_destroy(context.get_admin_context(), volume_id)
consistencygroup.destroy()
cg2.destroy()
def test_create_consistencygroup_from_src_cg(self):
self.mock_object(volume_api.API, "create", stubs.stub_volume_create)
source_cg = utils.create_consistencygroup(self.ctxt)
volume_id = utils.create_volume(
self.ctxt,
consistencygroup_id=source_cg.id)['id']
test_cg_name = 'test cg'
body = {"consistencygroup-from-src": {"name": test_cg_name,
"description":
"Consistency Group 1",
"source_cgid": source_cg.id}}
req = webob.Request.blank('/v2/fake/consistencygroups/create_from_src')
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = json.dumps(body)
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(202, res.status_int)
self.assertIn('id', res_dict['consistencygroup'])
self.assertEqual(test_cg_name, res_dict['consistencygroup']['name'])
cg = objects.ConsistencyGroup.get_by_id(
self.ctxt, res_dict['consistencygroup']['id'])
cg.destroy
db.volume_destroy(self.ctxt.elevated(), volume_id)
source_cg.destroy()
def test_snapshot_create_force(self):
volume = utils.create_volume(self.ctx, status='in-use')
snapshot_name = 'Snapshot Test Name'
snapshot_description = 'Snapshot Test Desc'
snapshot = {
"volume_id": volume.id,
"force": True,
"name": snapshot_name,
"description": snapshot_description
}
body = dict(snapshot=snapshot)
req = fakes.HTTPRequest.blank('/v2/snapshots')
resp_dict = self.controller.create(req, body)
self.assertIn('snapshot', resp_dict)
self.assertEqual(snapshot_name,
resp_dict['snapshot']['name'])
self.assertEqual(snapshot_description,
resp_dict['snapshot']['description'])
self.assertIn('updated_at', resp_dict['snapshot'])
snapshot = {
"volume_id": volume.id,
"force": "**&&^^%%$$##@@",
"name": "Snapshot Test Name",
"description": "Snapshot Test Desc"
}
body = dict(snapshot=snapshot)
req = fakes.HTTPRequest.blank('/v2/snapshots')
self.assertRaises(exception.InvalidParameterValue,
self.controller.create,
req,
body)
db.volume_destroy(self.ctx, volume.id)
def _create_volume_from_image(self, expected_status, raw=False,
clone_error=False):
"""Try to clone a volume from an image, and check the status
afterwards.
NOTE: if clone_error is True we force the image type to raw otherwise
clone_image is not called
"""
def mock_clone_image(volume, image_location, image_id, image_meta):
self.called.append('clone_image')
if clone_error:
raise exception.CinderException()
else:
return {'provider_location': None}, True
# See tests.image.fake for image types.
if raw:
image_id = '155d900f-4e14-4e4c-a73d-069cbf4541e6'
else:
image_id = 'c905cedb-7281-47e4-8a62-f26bc5fc4c77'
volume_id = 1
# creating volume testdata
db.volume_create(self.context,
{'id': volume_id,
'updated_at': timeutils.utcnow(),
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy'})
mpo = mock.patch.object
with mpo(self.volume.driver, 'create_volume') as mock_create_volume:
with mpo(self.volume.driver, 'clone_image', mock_clone_image):
with mpo(create_volume.CreateVolumeFromSpecTask,
'_copy_image_to_volume') as mock_copy_image_to_volume:
try:
if not clone_error:
self.volume.create_volume(self.context,
volume_id,
image_id=image_id)
else:
self.assertRaises(exception.CinderException,
self.volume.create_volume,
self.context,
volume_id,
image_id=image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume['status'], expected_status)
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
self.assertEqual(self.called, ['clone_image'])
mock_create_volume.assert_called()
mock_copy_image_to_volume.assert_called()
def test_create_consistencygroup_from_src(self, mock_validate):
self.stubs.Set(volume_api.API, "create", stubs.stub_volume_create)
consistencygroup = utils.create_consistencygroup(self.ctxt)
volume_id = utils.create_volume(self.ctxt, consistencygroup_id=consistencygroup.id)["id"]
cgsnapshot = utils.create_cgsnapshot(self.ctxt, consistencygroup_id=consistencygroup.id)
snapshot = utils.create_snapshot(self.ctxt, volume_id, cgsnapshot_id=cgsnapshot.id, status="available")
test_cg_name = "test cg"
body = {
"consistencygroup-from-src": {
"name": test_cg_name,
"description": "Consistency Group 1",
"cgsnapshot_id": cgsnapshot.id,
}
}
req = webob.Request.blank("/v2/fake/consistencygroups/create_from_src")
req.method = "POST"
req.headers["Content-Type"] = "application/json"
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app())
res_dict = jsonutils.loads(res.body)
self.assertEqual(202, res.status_int)
self.assertIn("id", res_dict["consistencygroup"])
self.assertEqual(test_cg_name, res_dict["consistencygroup"]["name"])
self.assertTrue(mock_validate.called)
cg_ref = objects.ConsistencyGroup.get_by_id(self.ctxt.elevated(), res_dict["consistencygroup"]["id"])
cg_ref.destroy()
snapshot.destroy()
db.volume_destroy(self.ctxt.elevated(), volume_id)
consistencygroup.destroy()
cgsnapshot.destroy()
def test_copy_volume_to_image_status_available(self):
dst_fd, dst_path = tempfile.mkstemp()
os.close(dst_fd)
def fake_local_path(volume):
return dst_path
self.stubs.Set(self.volume.driver, "local_path", fake_local_path)
image_id = "70a599e0-31e7-49b7-b260-868f441e862b"
# creating volume testdata
volume_id = 1
db.volume_create(
self.context,
{
"id": volume_id,
"updated_at": datetime.datetime(1, 1, 1, 1, 1, 1),
"display_description": "Test Desc",
"size": 20,
"status": "uploading",
"instance_uuid": None,
"host": "dummy",
},
)
try:
# start test
self.volume.copy_volume_to_image(self.context, volume_id, image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume["status"], "available")
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
os.unlink(dst_path)
def test_show_transfer_xml_content_type(self):
volume_id = self._create_volume(size=5)
transfer = self._create_transfer(volume_id)
req = webob.Request.blank('/v2/fake/os-volume-transfer/%s' %
transfer['id'])
req.method = 'GET'
req.headers['Content-Type'] = 'application/xml'
req.headers['Accept'] = 'application/xml'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(200, res.status_int)
dom = minidom.parseString(res.body)
transfer_xml = dom.getElementsByTagName('transfer')
name = transfer_xml.item(0).getAttribute('name')
self.assertEqual('test_transfer', name.strip())
db.transfer_destroy(context.get_admin_context(), transfer['id'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_show_transfer(self):
volume_id = self._create_volume(size=5)
transfer = self._create_transfer(volume_id)
req = webob.Request.blank('/v2/%s/os-volume-transfer/%s' % (
fake.PROJECT_ID, transfer['id']))
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app(
fake_auth_context=self.user_ctxt))
res_dict = jsonutils.loads(res.body)
self.assertEqual(http_client.OK, res.status_int)
self.assertEqual('test_transfer', res_dict['transfer']['name'])
self.assertEqual(transfer['id'], res_dict['transfer']['id'])
self.assertEqual(volume_id, res_dict['transfer']['volume_id'])
db.transfer_destroy(context.get_admin_context(), transfer['id'])
db.volume_destroy(context.get_admin_context(), volume_id)
def _clone_volume_from_image(self, expected_status, clone_works=True):
"""Try to clone a volume from an image, and check the status
afterwards.
"""
def fake_clone_image(volume, image_location):
return {'provider_location': None}, True
def fake_clone_error(volume, image_location):
raise exception.CinderException()
self.stubs.Set(self.volume.driver, '_is_cloneable', lambda x: True)
if clone_works:
self.stubs.Set(self.volume.driver, 'clone_image', fake_clone_image)
else:
self.stubs.Set(self.volume.driver, 'clone_image', fake_clone_error)
image_id = 'c905cedb-7281-47e4-8a62-f26bc5fc4c77'
volume_id = 1
# creating volume testdata
db.volume_create(
self.context, {
'id': volume_id,
'updated_at': timeutils.utcnow(),
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy'
})
try:
if clone_works:
self.volume.create_volume(self.context,
volume_id,
image_id=image_id)
else:
self.assertRaises(exception.CinderException,
self.volume.create_volume,
self.context,
volume_id,
image_id=image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume['status'], expected_status)
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
def test_show_backup_xml_content_type(self):
volume_id = self._create_volume(size=5)
backup_id = self._create_backup(volume_id)
req = webob.Request.blank('/v2/fake/backups/%s' % backup_id)
req.method = 'GET'
req.headers['Content-Type'] = 'application/xml'
req.headers['Accept'] = 'application/xml'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(res.status_int, 200)
dom = minidom.parseString(res.body)
backup = dom.getElementsByTagName('backup')
name = backup.item(0).getAttribute('name')
container_name = backup.item(0).getAttribute('container')
self.assertEquals(container_name.strip(), "volumebackups")
self.assertEquals(name.strip(), "test_backup")
db.backup_destroy(context.get_admin_context(), backup_id)
db.volume_destroy(context.get_admin_context(), volume_id)
def test_show_transfer(self):
volume_id = self._create_volume(size=5)
transfer = self._create_transfer(volume_id)
LOG.debug('Created transfer with id %s' % transfer)
req = webob.Request.blank('/v2/fake/os-volume-transfer/%s' %
transfer['id'])
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(res.status_int, 200)
self.assertEqual(res_dict['transfer']['name'], 'test_transfer')
self.assertEqual(res_dict['transfer']['id'], transfer['id'])
self.assertEqual(res_dict['transfer']['volume_id'], volume_id)
db.transfer_destroy(context.get_admin_context(), transfer['id'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_snapshot_create_invalid_force_param(self, force_param):
volume = utils.create_volume(self.ctx, status='in-use')
snapshot_name = 'Snapshot Test Name'
snapshot_description = 'Snapshot Test Desc'
snapshot = {
"volume_id": volume.id,
"force": force_param,
"name": snapshot_name,
"description": snapshot_description
}
body = dict(snapshot=snapshot)
req = fakes.HTTPRequest.blank('/v2/snapshots')
self.assertRaises(exception.InvalidParameterValue,
self.controller.create, req, body)
db.volume_destroy(self.ctx, volume.id)
def test_create_snapshot_from_bootable_volume_fail(self, mock_qemu_info):
"""Test create snapshot from bootable volume.
But it fails to volume_glance_metadata_copy_to_snapshot.
As a result, status of snapshot is changed to ERROR.
"""
# create bootable volume from image
volume = self._create_volume_from_image()
volume_id = volume['id']
self.assertEqual('available', volume['status'])
self.assertTrue(volume['bootable'])
image_info = imageutils.QemuImgInfo()
image_info.virtual_size = '1073741824'
mock_qemu_info.return_value = image_info
# get volume's volume_glance_metadata
ctxt = context.get_admin_context()
vol_glance_meta = db.volume_glance_metadata_get(ctxt, volume_id)
self.assertTrue(bool(vol_glance_meta))
snap = create_snapshot(volume_id)
self.assertEqual(36, len(snap.id)) # dynamically-generated UUID
self.assertEqual('creating', snap.status)
# set to return DB exception
with mock.patch.object(db, 'volume_glance_metadata_copy_to_snapshot')\
as mock_db:
mock_db.side_effect = exception.MetadataCopyFailure(
reason="Because of DB service down.")
# create snapshot from bootable volume
self.assertRaises(exception.MetadataCopyFailure,
self.volume.create_snapshot,
ctxt,
snap)
# get snapshot's volume_glance_metadata
self.assertRaises(exception.GlanceMetadataNotFound,
db.volume_snapshot_glance_metadata_get,
ctxt, snap.id)
# ensure that status of snapshot is 'error'
self.assertEqual(fields.SnapshotStatus.ERROR, snap.status)
# cleanup resource
snap.destroy()
db.volume_destroy(ctxt, volume_id)
def test_create_transfer_with_InvalidVolume(self):
volume_id = self._create_volume(status='attached')
body = {"transfer": {"name": "transfer1", "volume_id": volume_id}}
req = webob.Request.blank('/v2/%s/os-volume-transfer' %
fake.PROJECT_ID)
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(
fakes.wsgi_app(fake_auth_context=self.user_ctxt))
res_dict = jsonutils.loads(res.body)
self.assertEqual(400, res.status_int)
self.assertEqual(400, res_dict['badRequest']['code'])
self.assertEqual('Invalid volume: status must be available',
res_dict['badRequest']['message'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_create_volume_from_exact_sized_image(self):
"""Test create volume from an image of the same size.
Verify that an image which is exactly the same size as the
volume, will work correctly.
"""
try:
volume_id = None
volume_api = cinder.volume.api.API(
image_service=FakeImageService())
volume = volume_api.create(self.context, 2, 'name', 'description',
image_id=self.FAKE_UUID)
volume_id = volume['id']
self.assertEqual('creating', volume['status'])
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
def test_restore_backup_with_BackupNotFound(self):
# need to create the volume referenced below first
volume_id = utils.create_volume(self.context, size=5)['id']
body = {"restore": {"volume_id": volume_id, }}
req = webob.Request.blank('/v2/fake/backups/9999/restore')
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = json.dumps(body)
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(res.status_int, 404)
self.assertEqual(res_dict['itemNotFound']['code'], 404)
self.assertEqual(res_dict['itemNotFound']['message'],
'Backup 9999 could not be found.')
db.volume_destroy(context.get_admin_context(), volume_id)
def test_snapshot_create_with_null_validate(self):
volume = utils.create_volume(self.ctx, volume_type_id=None)
snapshot = {
"volume_id": volume.id,
"force": False,
"name": None,
"description": None
}
body = dict(snapshot=snapshot)
req = fakes.HTTPRequest.blank('/v2/snapshots')
resp_dict = self.controller.create(req, body=body)
self.assertIn('snapshot', resp_dict)
self.assertIsNone(resp_dict['snapshot']['name'])
self.assertIsNone(resp_dict['snapshot']['description'])
db.volume_destroy(self.ctx, volume.id)
def _create_volume_from_image(self, expected_status,
fakeout_copy_image_to_volume=False):
"""Call copy image to volume, Test the status of volume after calling
copying image to volume."""
def fake_local_path(volume):
return dst_path
def fake_copy_image_to_volume(context, volume,
image_service, image_id):
pass
def fake_fetch_to_raw(context, image_service, image_id, vol_path):
pass
dst_fd, dst_path = tempfile.mkstemp()
os.close(dst_fd)
self.stubs.Set(self.volume.driver, 'local_path', fake_local_path)
self.stubs.Set(image_utils, 'fetch_to_raw', fake_fetch_to_raw)
if fakeout_copy_image_to_volume:
self.stubs.Set(self.volume, '_copy_image_to_volume',
fake_copy_image_to_volume)
image_id = 'c905cedb-7281-47e4-8a62-f26bc5fc4c77'
volume_id = 1
# creating volume testdata
db.volume_create(self.context,
{'id': volume_id,
'updated_at': datetime.datetime(1, 1, 1, 1, 1, 1),
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy'})
try:
self.volume.create_volume(self.context,
volume_id,
image_id=image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume['status'], expected_status)
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
os.unlink(dst_path)
def test_create_volume_exists(self):
# Create the volume type and a volume with the volume type.
volume_type = self._default_volume_type
db.volume_type_create(context.get_admin_context(), volume_type)
db.volume_create(
context.get_admin_context(), {
'id': fake.VOLUME_ID,
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy',
'volume_type_id': volume_type['id']
})
body = {
"encryption": {
'cipher': 'cipher',
'key_size': 128,
'control_location': 'front-end',
'provider': 'fake_provider',
'volume_type_id': volume_type['id']
}
}
# Try to create encryption specs for a volume type
# with a volume.
res = self._get_response(volume_type,
req_method='POST',
req_body=jsonutils.dump_as_bytes(body),
req_headers='application/json')
res_dict = jsonutils.loads(res.body)
expected = {
'badRequest': {
'code':
400,
'message': ('Cannot create encryption specs. '
'Volume type in use.')
}
}
self.assertEqual(expected, res_dict)
db.volume_destroy(context.get_admin_context(), fake.VOLUME_ID)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_list_cgsnapshots_detail_json(self):
consistencygroup = utils.create_consistencygroup(self.context)
volume_id = utils.create_volume(
self.context, consistencygroup_id=consistencygroup.id)['id']
cgsnapshot1 = utils.create_cgsnapshot(
self.context, consistencygroup_id=consistencygroup.id)
cgsnapshot2 = utils.create_cgsnapshot(
self.context, consistencygroup_id=consistencygroup.id)
cgsnapshot3 = utils.create_cgsnapshot(
self.context, consistencygroup_id=consistencygroup.id)
req = webob.Request.blank('/v2/%s/cgsnapshots/detail' %
fake.PROJECT_ID)
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
req.headers['Accept'] = 'application/json'
res = req.get_response(
fakes.wsgi_app(fake_auth_context=self.user_ctxt))
res_dict = jsonutils.loads(res.body)
self.assertEqual(http_client.OK, res.status_int)
self.assertEqual('this is a test cgsnapshot',
res_dict['cgsnapshots'][0]['description'])
self.assertEqual('test_cgsnapshot', res_dict['cgsnapshots'][0]['name'])
self.assertEqual(cgsnapshot1.id, res_dict['cgsnapshots'][0]['id'])
self.assertEqual('creating', res_dict['cgsnapshots'][0]['status'])
self.assertEqual('this is a test cgsnapshot',
res_dict['cgsnapshots'][1]['description'])
self.assertEqual('test_cgsnapshot', res_dict['cgsnapshots'][1]['name'])
self.assertEqual(cgsnapshot2.id, res_dict['cgsnapshots'][1]['id'])
self.assertEqual('creating', res_dict['cgsnapshots'][1]['status'])
self.assertEqual('this is a test cgsnapshot',
res_dict['cgsnapshots'][2]['description'])
self.assertEqual('test_cgsnapshot', res_dict['cgsnapshots'][2]['name'])
self.assertEqual(cgsnapshot3.id, res_dict['cgsnapshots'][2]['id'])
self.assertEqual('creating', res_dict['cgsnapshots'][2]['status'])
cgsnapshot3.destroy()
cgsnapshot2.destroy()
cgsnapshot1.destroy()
db.volume_destroy(context.get_admin_context(), volume_id)
consistencygroup.destroy()
def delete(self, volume_id):
"""Delete a volume, bypassing the check that it must be available."""
ctxt = context.get_admin_context()
volume = db.volume_get(ctxt, param2id(volume_id))
host = vutils.extract_host(volume['host']) if volume['host'] else None
if not host:
print(_("Volume not yet assigned to host."))
print(_("Deleting volume from database and skipping rpc."))
db.volume_destroy(ctxt, param2id(volume_id))
return
if volume['status'] == 'in-use':
print(_("Volume is in-use."))
print(_("Detach volume from instance and then try again."))
return
cctxt = self.rpc_client().prepare(server=host)
cctxt.cast(ctxt, "delete_volume", volume_id=volume['id'])
def test_accept_transfer_with_no_body(self):
volume_id = self._create_volume(size=5)
transfer = self._create_transfer(volume_id)
req = webob.Request.blank('/v2/fake/os-volume-transfer/%s/accept' %
transfer['id'])
req.body = jsonutils.dump_as_bytes(None)
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.headers['Accept'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
res_dict = jsonutils.loads(res.body)
self.assertEqual(400, res.status_int)
self.assertEqual(400, res_dict['badRequest']['code'])
self.assertEqual("Missing required element 'accept' in request body.",
res_dict['badRequest']['message'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_accept_transfer_with_invalid_transfer(self):
volume_id = self._create_volume()
transfer = self._create_transfer(volume_id)
body = {"accept": {"id": transfer['id'], "auth_key": 1}}
req = webob.Request.blank('/v2/fake/os-volume-transfer/1/accept')
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = json.dumps(body)
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(res.status_int, 404)
self.assertEqual(res_dict['itemNotFound']['code'], 404)
self.assertEqual(res_dict['itemNotFound']['message'],
'TransferNotFound: Transfer 1 could not be found.')
db.transfer_destroy(context.get_admin_context(), transfer['id'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_accept_transfer_volume_id_specified_xml(self):
volume_id = self._create_volume(size=5)
transfer = self._create_transfer(volume_id)
req = webob.Request.blank('/v2/fake/os-volume-transfer/%s/accept' %
transfer['id'])
req.body = '<accept auth_key="%s"/>' % transfer['auth_key']
req.method = 'POST'
req.headers['Content-Type'] = 'application/xml'
req.headers['Accept'] = 'application/xml'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(res.status_int, 202)
dom = minidom.parseString(res.body)
accept = dom.getElementsByTagName('transfer')
self.assertEqual(accept.item(0).getAttribute('id'), transfer['id'])
self.assertEqual(accept.item(0).getAttribute('volume_id'), volume_id)
db.volume_destroy(context.get_admin_context(), volume_id)
def test_list_cgsnapshots_detail_json(self):
consistencygroup_id = utils.create_consistencygroup(self.context)['id']
volume_id = utils.create_volume(
self.context, consistencygroup_id=consistencygroup_id)['id']
cgsnapshot_id1 = self._create_cgsnapshot(
consistencygroup_id=consistencygroup_id)
cgsnapshot_id2 = self._create_cgsnapshot(
consistencygroup_id=consistencygroup_id)
cgsnapshot_id3 = self._create_cgsnapshot(
consistencygroup_id=consistencygroup_id)
req = webob.Request.blank('/v2/fake/cgsnapshots/detail')
req.method = 'GET'
req.headers['Content-Type'] = 'application/json'
req.headers['Accept'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(res.status_int, 200)
self.assertEqual(res_dict['cgsnapshots'][0]['description'],
'this is a test cgsnapshot')
self.assertEqual(res_dict['cgsnapshots'][0]['name'], 'test_cgsnapshot')
self.assertEqual(res_dict['cgsnapshots'][0]['id'], cgsnapshot_id1)
self.assertEqual(res_dict['cgsnapshots'][0]['status'], 'creating')
self.assertEqual(res_dict['cgsnapshots'][1]['description'],
'this is a test cgsnapshot')
self.assertEqual(res_dict['cgsnapshots'][1]['name'], 'test_cgsnapshot')
self.assertEqual(res_dict['cgsnapshots'][1]['id'], cgsnapshot_id2)
self.assertEqual(res_dict['cgsnapshots'][1]['status'], 'creating')
self.assertEqual(res_dict['cgsnapshots'][2]['description'],
'this is a test cgsnapshot')
self.assertEqual(res_dict['cgsnapshots'][2]['name'], 'test_cgsnapshot')
self.assertEqual(res_dict['cgsnapshots'][2]['id'], cgsnapshot_id3)
self.assertEqual(res_dict['cgsnapshots'][2]['status'], 'creating')
db.cgsnapshot_destroy(context.get_admin_context(), cgsnapshot_id3)
db.cgsnapshot_destroy(context.get_admin_context(), cgsnapshot_id2)
db.cgsnapshot_destroy(context.get_admin_context(), cgsnapshot_id1)
db.volume_destroy(context.get_admin_context(), volume_id)
db.consistencygroup_destroy(context.get_admin_context(),
consistencygroup_id)
def test_delete_cgsnapshot_available(self):
consistencygroup_id = utils.create_consistencygroup(self.context)['id']
volume_id = utils.create_volume(
self.context, consistencygroup_id=consistencygroup_id)['id']
cgsnapshot_id = self._create_cgsnapshot(
consistencygroup_id=consistencygroup_id, status='available')
req = webob.Request.blank('/v2/fake/cgsnapshots/%s' % cgsnapshot_id)
req.method = 'DELETE'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(res.status_int, 202)
self.assertEqual(self._get_cgsnapshot_attrib(cgsnapshot_id, 'status'),
'deleting')
db.cgsnapshot_destroy(context.get_admin_context(), cgsnapshot_id)
db.volume_destroy(context.get_admin_context(), volume_id)
db.consistencygroup_destroy(context.get_admin_context(),
consistencygroup_id)
def _create_volume_from_image(self, expected_status, raw=False,
clone_error=False):
"""Try to clone a volume from an image, and check the status
afterwards.
NOTE: if clone_error is True we force the image type to raw otherwise
clone_image is not called
"""
volume_id = 1
# See tests.image.fake for image types.
if raw:
image_id = '155d900f-4e14-4e4c-a73d-069cbf4541e6'
else:
image_id = 'c905cedb-7281-47e4-8a62-f26bc5fc4c77'
# creating volume testdata
db.volume_create(self.context,
{'id': volume_id,
'updated_at': timeutils.utcnow(),
'display_description': 'Test Desc',
'size': 20,
'status': 'creating',
'instance_uuid': None,
'host': 'dummy'})
try:
if not clone_error:
self.volume.create_volume(self.context,
volume_id,
image_id=image_id)
else:
self.assertRaises(exception.CinderException,
self.volume.create_volume,
self.context,
volume_id,
image_id=image_id)
volume = db.volume_get(self.context, volume_id)
self.assertEqual(volume['status'], expected_status)
finally:
# cleanup
db.volume_destroy(self.context, volume_id)
def test_restore_backup_volume_id_specified_xml(self):
backup_id = self._create_backup(status='available')
volume_id = utils.create_volume(self.context, size=2)['id']
req = webob.Request.blank('/v2/fake/backups/%s/restore' % backup_id)
req.body = '<restore volume_id="%s"/>' % volume_id
req.method = 'POST'
req.headers['Content-Type'] = 'application/xml'
req.headers['Accept'] = 'application/xml'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(res.status_int, 202)
dom = minidom.parseString(res.body)
restore = dom.getElementsByTagName('restore')
self.assertEqual(restore.item(0).getAttribute('backup_id'), backup_id)
self.assertEqual(restore.item(0).getAttribute('volume_id'), volume_id)
db.backup_destroy(context.get_admin_context(), backup_id)
db.volume_destroy(context.get_admin_context(), volume_id)
def test_create_backup_xml(self):
volume_size = 2
volume_id = self._create_volume(status='available', size=volume_size)
req = webob.Request.blank('/v2/fake/backups')
req.body = ('<backup display_name="backup-001" '
'display_description="Nightly Backup" '
'volume_id="%s" container="Container001"/>' % volume_id)
req.method = 'POST'
req.headers['Content-Type'] = 'application/xml'
req.headers['Accept'] = 'application/xml'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(res.status_int, 202)
dom = minidom.parseString(res.body)
backup = dom.getElementsByTagName('backup')
self.assertTrue(backup.item(0).hasAttribute('id'))
db.volume_destroy(context.get_admin_context(), volume_id)
def test_create_transfer_with_leading_trailing_spaces_for_name(self):
volume_id = self._create_volume(status='available', size=5)
body = {"transfer": {"name": " transfer1 ",
"volume_id": volume_id}}
req = webob.Request.blank('/v2/%s/os-volume-transfer' %
fake.PROJECT_ID)
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app(
fake_auth_context=self.user_ctxt))
res_dict = jsonutils.loads(res.body)
self.assertEqual(http_client.ACCEPTED, res.status_int)
self.assertEqual(body['transfer']['name'].strip(),
res_dict['transfer']['name'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_create_clone(self):
self.driver.do_setup(None)
vol_type = test_utils.create_volume_type(self.ctxt,
self,
name='my_vol_type')
volume = test_utils.create_volume(self.ctxt,
size=4,
volume_type_id=vol_type.id)
clone = test_utils.create_volume(self.ctxt,
size=4,
volume_type_id=vol_type.id)
self.driver.create_volume(volume)
self.driver.create_cloned_volume(clone, volume)
self.driver.delete_volume(volume)
self.driver.delete_volume(clone)
db.volume_destroy(self.ctxt, volume.id)
db.volume_destroy(self.ctxt, clone.id)
def test_restore_backup_to_oversized_volume(self):
backup_id = self._create_backup(status='available', size=10)
# need to create the volume referenced below first
volume_id = utils.create_volume(self.context, size=15)['id']
body = {"restore": {"volume_id": volume_id, }}
req = webob.Request.blank('/v2/fake/backups/%s/restore' %
backup_id)
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = json.dumps(body)
res = req.get_response(fakes.wsgi_app())
res_dict = json.loads(res.body)
self.assertEqual(res.status_int, 202)
self.assertEqual(res_dict['restore']['backup_id'], backup_id)
self.assertEqual(res_dict['restore']['volume_id'], volume_id)
db.volume_destroy(context.get_admin_context(), volume_id)
db.backup_destroy(context.get_admin_context(), backup_id)
def test_notify_usage_exists(self):
"""Ensure 'exists' notification generates appropriate usage data."""
volume_id = self._create_volume()
volume = db.volume_get(self.context, volume_id)
volume_utils.notify_usage_exists(self.context, volume)
LOG.info("%r" % test_notifier.NOTIFICATIONS)
self.assertEquals(len(test_notifier.NOTIFICATIONS), 1)
msg = test_notifier.NOTIFICATIONS[0]
self.assertEquals(msg['priority'], 'INFO')
self.assertEquals(msg['event_type'], 'volume.exists')
payload = msg['payload']
self.assertEquals(payload['tenant_id'], self.project_id)
self.assertEquals(payload['user_id'], self.user_id)
self.assertEquals(payload['snapshot_id'], self.snapshot_id)
self.assertEquals(payload['volume_id'], volume.id)
self.assertEquals(payload['size'], self.volume_size)
for attr in ('display_name', 'created_at', 'launched_at', 'status',
'audit_period_beginning', 'audit_period_ending'):
self.assertIn(attr, payload)
db.volume_destroy(context.get_admin_context(), volume['id'])
def test_delete_cgsnapshot_available(self):
consistencygroup = utils.create_consistencygroup(self.context)
volume_id = utils.create_volume(
self.context, consistencygroup_id=consistencygroup.id)['id']
cgsnapshot = utils.create_cgsnapshot(
self.context,
consistencygroup_id=consistencygroup.id,
status='available')
req = webob.Request.blank('/v2/fake/cgsnapshots/%s' % cgsnapshot.id)
req.method = 'DELETE'
req.headers['Content-Type'] = 'application/json'
res = req.get_response(fakes.wsgi_app())
cgsnapshot = objects.CGSnapshot.get_by_id(self.context, cgsnapshot.id)
self.assertEqual(202, res.status_int)
self.assertEqual('deleting', cgsnapshot.status)
cgsnapshot.destroy()
db.volume_destroy(context.get_admin_context(), volume_id)
consistencygroup.destroy()
def test_accept_transfer_with_no_body(self):
volume_id = self._create_volume(size=5)
transfer = self._create_transfer(volume_id)
req = webob.Request.blank('/v2/%s/os-volume-transfer/%s/accept' %
(fake.PROJECT_ID, transfer['id']))
req.body = jsonutils.dump_as_bytes(None)
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.headers['Accept'] = 'application/json'
res = req.get_response(
fakes.wsgi_app(fake_auth_context=self.user_ctxt))
res_dict = jsonutils.loads(res.body)
self.assertEqual(HTTPStatus.BAD_REQUEST, res.status_int)
self.assertEqual(HTTPStatus.BAD_REQUEST,
res_dict['badRequest']['code'])
db.transfer_destroy(context.get_admin_context(), transfer['id'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_show_cgsnapshot_xml_content_type(self):
consistencygroup = utils.create_consistencygroup(self.context)
volume_id = utils.create_volume(
self.context, consistencygroup_id=consistencygroup.id)['id']
cgsnapshot = utils.create_cgsnapshot(
self.context, consistencygroup_id=consistencygroup.id)
req = webob.Request.blank('/v2/fake/cgsnapshots/%s' % cgsnapshot.id)
req.method = 'GET'
req.headers['Content-Type'] = 'application/xml'
req.headers['Accept'] = 'application/xml'
res = req.get_response(fakes.wsgi_app())
self.assertEqual(200, res.status_int)
dom = minidom.parseString(res.body)
cgsnapshots = dom.getElementsByTagName('cgsnapshot')
name = cgsnapshots.item(0).getAttribute('name')
self.assertEqual("test_cgsnapshot", name.strip())
cgsnapshot.destroy()
db.volume_destroy(context.get_admin_context(), volume_id)
consistencygroup.destroy()
