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 _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()