def test_volume_force_detach_raises_remote_error(self):
# current status is available
volume = self._create_volume(self.ctx, {"provider_location": "", "size": 1})
connector = {"initiator": "iqn.2012-07.org.fake:01"}
self.volume_api.reserve_volume(self.ctx, volume)
mountpoint = "/dev/vbd"
attachment = self.volume_api.attach(self.ctx, volume, fake.INSTANCE_ID, None, mountpoint, "rw")
# volume is attached
volume.refresh()
self.assertEqual("in-use", volume.status)
self.assertEqual(fake.INSTANCE_ID, attachment["instance_uuid"])
self.assertEqual(mountpoint, attachment["mountpoint"])
self.assertEqual("attached", attachment["attach_status"])
admin_metadata = volume.admin_metadata
self.assertEqual(2, len(admin_metadata))
self.assertEqual("False", admin_metadata["readonly"])
self.assertEqual("rw", admin_metadata["attached_mode"])
conn_info = self.volume_api.initialize_connection(self.ctx, volume, connector)
self.assertEqual("rw", conn_info["data"]["access_mode"])
# build request to force detach
volume_remote_error = messaging.RemoteError(exc_type="VolumeAttachmentNotFound")
with mock.patch.object(volume_api.API, "detach", side_effect=volume_remote_error):
req = webob.Request.blank("/v2/%s/volumes/%s/action" % (fake.PROJECT_ID, volume.id))
req.method = "POST"
req.headers["content-type"] = "application/json"
body = {"os-force_detach": {"attachment_id": fake.ATTACHMENT_ID}}
req.body = jsonutils.dump_as_bytes(body)
# attach admin context to request
req.environ["cinder.context"] = self.ctx
# make request
resp = req.get_response(app())
self.assertEqual(400, resp.status_int)
# test for KeyError when missing connector
volume_remote_error = messaging.RemoteError(exc_type="KeyError")
with mock.patch.object(volume_api.API, "detach", side_effect=volume_remote_error):
req = webob.Request.blank("/v2/%s/volumes/%s/action" % (fake.PROJECT_ID, volume.id))
req.method = "POST"
req.headers["content-type"] = "application/json"
body = {"os-force_detach": {"attachment_id": fake.ATTACHMENT_ID}}
req.body = jsonutils.dump_as_bytes(body)
# attach admin context to request
req.environ["cinder.context"] = self.ctx
# make request
self.assertRaises(messaging.RemoteError, req.get_response, app())
# test for VolumeBackendAPIException
volume_remote_error = messaging.RemoteError(exc_type="VolumeBackendAPIException")
with mock.patch.object(volume_api.API, "detach", side_effect=volume_remote_error):
req = webob.Request.blank("/v2/%s/volumes/%s/action" % (fake.PROJECT_ID, volume.id))
req.method = "POST"
req.headers["content-type"] = "application/json"
body = {"os-force_detach": {"attachment_id": fake.ATTACHMENT_ID, "connector": connector}}
req.body = jsonutils.dump_as_bytes(body)
# attach admin context to request
req.environ["cinder.context"] = self.ctx
# make request
self.assertRaises(messaging.RemoteError, req.get_response, app())
def test_rpc_errors(self):
api = create_api()
req = webob.Request.blank('/rpc')
req.method = 'POST'
req.content_type = 'application/json'
# Body is not a list, it should fail
req.body = jsonutils.dump_as_bytes({})
res = req.get_response(api)
self.assertEqual(http.BAD_REQUEST, res.status_int)
# cmd is not dict, it should fail.
req.body = jsonutils.dump_as_bytes([None])
res = req.get_response(api)
self.assertEqual(http.BAD_REQUEST, res.status_int)
# No command key, it should fail.
req.body = jsonutils.dump_as_bytes([{}])
res = req.get_response(api)
self.assertEqual(http.BAD_REQUEST, res.status_int)
# kwargs not dict, it should fail.
req.body = jsonutils.dump_as_bytes([{"command": "test", "kwargs": 2}])
res = req.get_response(api)
self.assertEqual(http.BAD_REQUEST, res.status_int)
# Command does not exist, it should fail.
req.body = jsonutils.dump_as_bytes([{"command": "test"}])
res = req.get_response(api)
self.assertEqual(http.NOT_FOUND, res.status_int)
def test_attach_with_invalid_arguments(self):
# Invalid request to attach volume an invalid target
body = {'os-attach': {'mountpoint': '/dev/vdc'}}
req = webob.Request.blank('/v2/fake/volumes/1/action')
req.method = "POST"
req.headers["content-type"] = "application/json"
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app())
self.assertEqual(400, res.status_int)
# Invalid request to attach volume with an invalid mode
body = {'os-attach': {'instance_uuid': 'fake',
'mountpoint': '/dev/vdc',
'mode': 'rr'}}
req = webob.Request.blank('/v2/fake/volumes/1/action')
req.method = "POST"
req.headers["content-type"] = "application/json"
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app())
self.assertEqual(400, res.status_int)
body = {'os-attach': {'host_name': 'fake_host',
'mountpoint': '/dev/vdc',
'mode': 'ww'}}
req = webob.Request.blank('/v2/fake/volumes/1/action')
req.method = "POST"
req.headers["content-type"] = "application/json"
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(fakes.wsgi_app())
self.assertEqual(400, res.status_int)
def test_list_env_templates_with_different_tenant(self):
"""Test listing public template from another tenant
Create two template in two different tenants;
test list public template from another tenant.
"""
self._set_policy_rules(
{'create_env_template': '@',
'list_env_templates': '@'}
)
self.expect_policy_check('create_env_template')
body = {'name': 'mytemp', 'is_public': False}
req = self._post('/templates', jsonutils.dump_as_bytes(body),
tenant='first_tenant')
result = req.get_response(self.api)
self.assertFalse(jsonutils.loads(result.body)['is_public'])
self.expect_policy_check('create_env_template')
body = {'name': 'mytemp1', 'is_public': True}
req = self._post('/templates', jsonutils.dump_as_bytes(body),
tenant='second_tenant')
result = req.get_response(self.api)
self.assertTrue(jsonutils.loads(result.body)['is_public'])
self.expect_policy_check('list_env_templates')
req = self._get('/templates', tenant='first_tenant')
result = req.get_response(self.api)
self.assertEqual(2, len(jsonutils.loads(result.body)['templates']))
def test_invalid_metadata_items_on_create(self):
self.stubs.Set(db, 'volume_metadata_update',
fake_create_volume_metadata)
req = fakes.HTTPRequest.blank('/v2/%s/volumes/%s/action' % (
fake.PROJECT_ID, fake.VOLUME_ID))
req.method = 'POST'
req.headers["content-type"] = "application/json"
data = {"os-set_image_metadata": {
"metadata": {"a" * 260: "value1"}}
}
# Test for long key
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.create, req, fake.VOLUME_ID, data)
# Test for long value
data = {"os-set_image_metadata": {
"metadata": {"key": "v" * 260}}
}
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.create, req, fake.VOLUME_ID, data)
# Test for empty key.
data = {"os-set_image_metadata": {
"metadata": {"": "value1"}}
}
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.create, req, fake.VOLUME_ID, data)
def test_invalid_metadata_items_on_create(self, metadata_update):
fake_volume = {"id": self.req_id, "status": "available"}
fake_context = mock.Mock()
metadata_update.side_effect = return_create_volume_metadata
req = fakes.HTTPRequest.blank(self.url)
req.method = "POST"
req.headers["content-type"] = "application/json"
# test for long key
data = {"metadata": {"a" * 260: "value1"}}
req.body = jsonutils.dump_as_bytes(data)
req.environ["cinder.context"] = fake_context
with mock.patch.object(self.controller.volume_api, "get") as get_volume:
get_volume.return_value = fake_volume
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge, self.controller.create, req, self.req_id, data)
# test for long value
data = {"metadata": {"key": "v" * 260}}
req.body = jsonutils.dump_as_bytes(data)
req.environ["cinder.context"] = fake_context
with mock.patch.object(self.controller.volume_api, "get") as get_volume:
get_volume.return_value = fake_volume
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge, self.controller.create, req, self.req_id, data)
# test for empty key.
data = {"metadata": {"": "value1"}}
req.body = jsonutils.dump_as_bytes(data)
req.environ["cinder.context"] = fake_context
with mock.patch.object(self.controller.volume_api, "get") as get_volume:
get_volume.return_value = fake_volume
self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create, req, self.req_id, data)
def test_invalid_metadata_items_on_update_item(self):
self.stub_out('nova.db.instance_metadata_update',
return_create_instance_metadata)
self.stub_out('nova.db.instance_metadata_update',
return_create_instance_metadata)
data = {"metadata": {}}
for num in range(CONF.quota_metadata_items + 1):
data['metadata']['key%i' % num] = "blah"
req = self._get_request()
req.method = 'PUT'
req.body = jsonutils.dump_as_bytes(data)
req.headers["content-type"] = "application/json"
# test for long key
data = {"metadata": {"a" * 260: "value1"}}
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(self.validation_ex_large,
self.controller.update_all, req, self.uuid,
body=data)
# test for long value
data = {"metadata": {"key": "v" * 260}}
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(self.validation_ex_large,
self.controller.update_all, req, self.uuid,
body=data)
# test for empty key.
data = {"metadata": {"": "value1"}}
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(self.validation_ex,
self.controller.update_all, req, self.uuid,
body=data)
def test_attach_to_instance(self):
body = {'os-attach': {'instance_uuid': fake.INSTANCE_ID,
'mountpoint': '/dev/vdc',
'mode': 'rw'}}
req = webob.Request.blank('/v2/%s/volumes/%s/action' %
(fake.PROJECT_ID, fake.VOLUME_ID))
req.method = "POST"
req.body = jsonutils.dump_as_bytes(body)
req.headers["content-type"] = "application/json"
res = req.get_response(fakes.wsgi_app(
fake_auth_context=self.context))
self.assertEqual(202, res.status_int)
body = {'os-attach': {'instance_uuid': fake.INSTANCE_ID,
'host_name': 'fake_host',
'mountpoint': '/dev/vdc'}}
req = webob.Request.blank('/v2/%s/volumes/%s/action' %
(fake.PROJECT_ID, fake.VOLUME_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.context))
self.assertEqual(202, res.status_int)
def test_invalid_metadata_items_on_create(self, snapshot_get_by_id):
snapshot = {
'id': self.req_id,
'expected_attrs': ['metadata']
}
ctx = context.RequestContext('admin', 'fake', True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(ctx, **snapshot)
snapshot_get_by_id.return_value = snapshot_obj
self.stubs.Set(cinder.db, 'snapshot_metadata_update',
return_create_snapshot_metadata)
req = fakes.HTTPRequest.blank(self.url)
req.method = 'POST'
req.headers["content-type"] = "application/json"
# test for long key
data = {"metadata": {"a" * 260: "value1"}}
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.create, req, self.req_id, data)
# test for long value
data = {"metadata": {"key": "v" * 260}}
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
self.controller.create, req, self.req_id, data)
# test for empty key.
data = {"metadata": {"": "value1"}}
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.create, req, self.req_id, data)
def test_create_server_detect_from_image(self):
"""If user doesn't pass in diskConfig for server, use image metadata
to specify AUTO or MANUAL.
"""
req = fakes.HTTPRequest.blank('/fake/servers')
req.method = 'POST'
req.content_type = 'application/json'
body = {'server': {
'name': 'server_test',
'imageRef': 'a440c04b-79fa-479c-bed1-0b816eaec379',
'flavorRef': '1',
}}
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(self.app)
server_dict = jsonutils.loads(res.body)['server']
self.assertDiskConfig(server_dict, 'MANUAL')
req = fakes.HTTPRequest.blank('/fake/servers')
req.method = 'POST'
req.content_type = 'application/json'
body = {'server': {
'name': 'server_test',
'imageRef': '70a599e0-31e7-49b7-b260-868f441e862b',
'flavorRef': '1',
}}
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(self.app)
server_dict = jsonutils.loads(res.body)['server']
self.assertDiskConfig(server_dict, 'AUTO')
def test_list_env_templates(self):
"""Test listing public templates when there aren't any
Create a template; test list public with no
public templates.
"""
self._set_policy_rules(
{'create_env_template': '@',
'list_env_templates': '@'}
)
self.expect_policy_check('create_env_template')
body = {'name': 'mytemp', 'is_public': False}
req = self._post('/templates', jsonutils.dump_as_bytes(body))
result = req.get_response(self.api)
self.assertFalse(jsonutils.loads(result.body)['is_public'])
self.expect_policy_check('create_env_template')
body = {'name': 'mytemp1', 'is_public': True}
req = self._post('/templates', jsonutils.dump_as_bytes(body))
result = req.get_response(self.api)
self.assertTrue(jsonutils.loads(result.body)['is_public'])
self.expect_policy_check('list_env_templates')
req = self._get('/templates')
result = req.get_response(self.api)
self.assertEqual(2, len(jsonutils.loads(result.body)['templates']))
def default(self, data, result=None):
def sanitizer(obj):
if isinstance(obj, datetime.datetime):
_dtime = obj - datetime.timedelta(microseconds=obj.microsecond)
return _dtime.isoformat()
return six.text_type(obj)
if result:
data.body = jsonutils.dump_as_bytes(result)
return jsonutils.dump_as_bytes(data, default=sanitizer)
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 _force_delete_backup_util(self, test_status, mock_check_support,
mock_service_get_all):
mock_service_get_all.return_value = [{
'availability_zone': "az1",
'host': 'testhost',
'disabled': 0,
'updated_at': timeutils.utcnow()
}]
# admin context
mock_check_support.return_value = True
# current status is dependent on argument: test_status.
id = test_backups.BackupsAPITestCase._create_backup(status=test_status)
req = webob.Request.blank(
'/v2/%s/backups/%s/action' % (fake.PROJECT_ID, id))
req.method = 'POST'
req.headers['Content-Type'] = 'application/json'
req.body = jsonutils.dump_as_bytes({'os-force_delete': {}})
req.environ['cinder.context'] = self.ctx
res = req.get_response(app())
self.assertEqual(202, res.status_int)
self.assertEqual(
'deleting',
test_backups.BackupsAPITestCase._get_backup_attrib(id, 'status'))
db.backup_destroy(self.ctx, id)
def test_accept_transfer_with_VolumeSizeExceedsAvailableQuota(self):
def fake_transfer_api_accept_throwing_VolumeSizeExceedsAvailableQuota(
cls, context, transfer, volume_id):
raise exception.VolumeSizeExceedsAvailableQuota(requested='2',
consumed='2',
quota='3')
self.stubs.Set(
cinder.transfer.API,
'accept',
fake_transfer_api_accept_throwing_VolumeSizeExceedsAvailableQuota)
volume_id = self._create_volume()
transfer = self._create_transfer(volume_id)
body = {"accept": {"id": transfer['id'],
"auth_key": transfer['auth_key']}}
req = webob.Request.blank('/v2/%s/os-volume-transfer/%s/accept' % (
fake.PROJECT_ID, transfer['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(413, res.status_int)
self.assertEqual(413, res_dict['overLimit']['code'])
self.assertEqual('Requested volume or snapshot exceeds allowed '
'gigabytes quota. Requested 2G, quota is 3G and '
'2G has been consumed.',
res_dict['overLimit']['message'])
def test_update_all_with_keys_in_uppercase_and_lowercase(self,
metadata_get,
metadata_update):
fake_volume = {'id': fake.VOLUME_ID, 'status': 'available'}
fake_context = mock.Mock()
metadata_get.side_effect = return_create_volume_metadata
metadata_update.side_effect = return_new_volume_metadata
req = fakes.HTTPRequest.blank(self.url)
req.method = 'PUT'
req.content_type = "application/json"
body = {
'metadata': {
'key10': 'value10',
'KEY10': 'value10',
'key99': 'value99',
'KEY20': 'value20',
},
}
expected = {
'metadata': {
'key10': 'value10',
'key99': 'value99',
'KEY20': 'value20',
},
}
req.body = jsonutils.dump_as_bytes(expected)
req.environ['cinder.context'] = fake_context
with mock.patch.object(self.controller.volume_api,
'get') as get_volume:
get_volume.return_value = fake_volume
res_dict = self.controller.update_all(req, fake.VOLUME_ID, body)
self.assertEqual(expected, res_dict)
get_volume.assert_called_once_with(fake_context, fake.VOLUME_ID)
def _migrate_volume_comp_exec(self,
ctx,
volume,
new_volume,
error,
expected_status,
expected_id,
no_body=False):
req = webob.Request.blank(
'/v2/%s/volumes/%s/action' % (fake.PROJECT_ID, volume['id']))
req.method = 'POST'
req.headers['content-type'] = 'application/json'
body = {'new_volume': new_volume['id'], 'error': error}
if no_body:
body = {'': body}
else:
body = {'os-migrate_volume_completion': body}
req.body = jsonutils.dump_as_bytes(body)
req.environ['cinder.context'] = ctx
resp = req.get_response(app())
resp_dict = resp.json
# verify status
self.assertEqual(expected_status, resp.status_int)
if expected_id:
self.assertEqual(expected_id, resp_dict['save_volume_id'])
else:
self.assertNotIn('save_volume_id', resp_dict)
def test_accept_transfer_with_VolumeLimitExceeded(self):
def fake_transfer_api_accept_throwing_VolumeLimitExceeded(cls,
context,
transfer,
volume_id):
raise exception.VolumeLimitExceeded(allowed=1)
self.stubs.Set(cinder.transfer.API, 'accept',
fake_transfer_api_accept_throwing_VolumeLimitExceeded)
volume_id = self._create_volume()
transfer = self._create_transfer(volume_id)
body = {"accept": {"id": transfer['id'],
"auth_key": transfer['auth_key']}}
req = webob.Request.blank('/v2/%s/os-volume-transfer/%s/accept' % (
fake.PROJECT_ID, transfer['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(413, res.status_int)
self.assertEqual(413, res_dict['overLimit']['code'])
self.assertEqual("VolumeLimitExceeded: Maximum number of volumes "
"allowed (1) exceeded for quota 'volumes'.",
res_dict['overLimit']['message'])
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_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 _bands_handler(req, res):
#NOTE: This only handles JSON responses.
# You can use content type header to test for XML.
data = jsonutils.loads(res.body)
data['FOXNSOX:big_bands'] = 'Pig Bands!'
res.body = jsonutils.dump_as_bytes(data)
return res
def test_update_all_volume_maintenance(self, metadata_update):
fake_volume = {'id': self.req_id, 'status': 'maintenance'}
fake_context = mock.Mock()
metadata_update.side_effect = return_new_volume_metadata
req = fakes.HTTPRequest.blank(self.url)
req.method = 'PUT'
req.content_type = "application/json"
expected = {
'metadata': {
'key10': 'value10',
'key99': 'value99',
'KEY20': 'value20',
},
}
req.body = jsonutils.dump_as_bytes(expected)
req.environ['cinder.context'] = fake_context
with mock.patch.object(self.controller.volume_api,
'get') as get_volume:
get_volume.return_value = fake_volume
self.assertRaises(exception.InvalidVolume,
self.controller.update_all, req,
self.req_id, expected)
self.assertFalse(metadata_update.called)
get_volume.assert_called_once_with(fake_context, self.req_id)
def test_create_with_keys_in_uppercase_and_lowercase(self, metadata_get,
metadata_update):
# if the keys in uppercase_and_lowercase, should return the one
# which server added
fake_volume = {'id': fake.VOLUME_ID, 'status': 'available'}
fake_context = mock.Mock()
metadata_get.side_effect = return_empty_volume_metadata
metadata_update.side_effect = return_create_volume_metadata_insensitive
req = fakes.HTTPRequest.blank('/v1/volume_metadata')
req.method = 'POST'
req.content_type = "application/json"
body = {"metadata": {"key1": "value1",
"KEY1": "value1",
"key2": "value2",
"KEY2": "value2",
"key3": "value3",
"KEY4": "value4"}}
expected = {"metadata": {"key1": "value1",
"key2": "value2",
"key3": "value3",
"KEY4": "value4"}}
req.body = jsonutils.dump_as_bytes(body)
req.environ['cinder.context'] = fake_context
with mock.patch.object(self.controller.volume_api,
'get') as get_volume:
get_volume.return_value = fake_volume
res_dict = self.controller.create(req, fake.VOLUME_ID, body)
self.assertEqual(expected, res_dict)
def test_update_all_with_keys_in_uppercase_and_lowercase(
self, snapshot_get_by_id, snapshot_update):
snapshot = {
'id': self.req_id,
'expected_attrs': ['metadata']
}
ctx = context.RequestContext('admin', 'fake', True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(ctx, **snapshot)
snapshot_get_by_id.return_value = snapshot_obj
self.stubs.Set(cinder.db, 'snapshot_metadata_update',
return_new_snapshot_metadata)
req = fakes.HTTPRequest.blank(self.url)
req.method = 'PUT'
req.content_type = "application/json"
body = {
'metadata': {
'key10': 'value10',
'KEY10': 'value10',
'key99': 'value99',
'KEY20': 'value20',
},
}
expected = {
'metadata': {
'key10': 'value10',
'key99': 'value99',
'KEY20': 'value20',
},
}
req.body = jsonutils.dump_as_bytes(expected)
res_dict = self.controller.update_all(req, self.req_id, body)
self.assertEqual(expected, res_dict)
def test_create_with_keys_in_uppercase_and_lowercase(
self, snapshot_get_by_id, snapshot_update):
snapshot = {
'id': self.req_id,
'expected_attrs': ['metadata']
}
ctx = context.RequestContext('admin', 'fake', True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(ctx, **snapshot)
snapshot_get_by_id.return_value = snapshot_obj
# if the keys in uppercase_and_lowercase, should return the one
# which server added
self.stubs.Set(cinder.db, 'snapshot_metadata_update',
return_create_snapshot_metadata_insensitive)
req = fakes.HTTPRequest.blank('/v1/snapshot_metadata')
req.method = 'POST'
req.content_type = "application/json"
body = {"metadata": {"key1": "value1",
"KEY1": "value1",
"key2": "value2",
"KEY2": "value2",
"key3": "value3",
"KEY4": "value4"}}
expected = {"metadata": {"key1": "value1",
"key2": "value2",
"key3": "value3",
"KEY4": "value4"}}
req.body = jsonutils.dump_as_bytes(body)
res_dict = self.controller.create(req, self.req_id, body)
self.assertEqual(expected, res_dict)
def _get_response(self):
req = self._get_http_request(self.base_url)
req.headers['Content-Type'] = 'application/json'
req.method = 'POST'
req.body = jsonutils.dump_as_bytes(self.expected)
res = req.get_response(self.app)
return jsonutils.loads(res.body)
def test_create_root_volume_bdm_v2(self):
body = dict(server=dict(
name='test_server', imageRef=IMAGE_UUID,
flavorRef=2, min_count=1, max_count=1,
block_device_mapping_v2=[dict(
source_type='volume',
uuid='1',
device_name='/dev/vda',
boot_index=0,
delete_on_termination=False,
)]
))
req = fakes.HTTPRequest.blank('/v2/fake/os-volumes_boot')
req.method = 'POST'
req.body = jsonutils.dump_as_bytes(body)
req.headers['content-type'] = 'application/json'
res = req.get_response(fakes.wsgi_app(
init_only=('os-volumes_boot', 'servers')))
self.assertEqual(202, res.status_int)
server = jsonutils.loads(res.body)['server']
self.assertEqual(FAKE_UUID, server['id'])
self.assertEqual(CONF.password_length, len(server['adminPass']))
self.assertEqual(1, len(self._block_device_mapping_seen))
self.assertFalse(self._legacy_bdm_seen)
self.assertEqual('1', self._block_device_mapping_seen[0]['volume_id'])
self.assertEqual(0, self._block_device_mapping_seen[0]['boot_index'])
self.assertEqual('/dev/vda',
self._block_device_mapping_seen[0]['device_name'])
def _goose_handler(req, res):
#NOTE: This only handles JSON responses.
# You can use content type header to test for XML.
data = jsonutils.loads(res.body)
data['FOXNSOX:googoose'] = req.GET.get('chewing')
res.body = jsonutils.dump_as_bytes(data)
return res
def test_volume_create(self):
self.stubs.Set(cinder.API, "create", fakes.stub_volume_create)
vol = {"size": 100,
"display_name": "Volume Test Name",
"display_description": "Volume Test Desc",
"availability_zone": "zone1:host1"}
body = {"volume": vol}
req = fakes.HTTPRequest.blank(self.url_prefix + '/os-volumes')
req.method = 'POST'
req.body = jsonutils.dump_as_bytes(body)
req.headers['content-type'] = 'application/json'
resp = req.get_response(self.app)
self.assertEqual(200, resp.status_int)
resp_dict = jsonutils.loads(resp.body)
self.assertIn('volume', resp_dict)
self.assertEqual(vol['size'], resp_dict['volume']['size'])
self.assertEqual(vol['display_name'],
resp_dict['volume']['displayName'])
self.assertEqual(vol['display_description'],
resp_dict['volume']['displayDescription'])
self.assertEqual(vol['availability_zone'],
resp_dict['volume']['availabilityZone'])
def index(self, req, explicit=False):
"""Respond to a request for all OpenStack API versions."""
def build_version_object(version, path, status):
url = CONF.public_endpoint or req.host_url
return {
'id': 'v%s' % version,
'status': status,
'links': [
{
'rel': 'self',
'href': '%s/%s/' % (url, path),
},
],
}
version_objs = []
if CONF.enable_v2_api:
if CONF.enabled_backends:
version_objs.extend(
[build_version_object(2.8, 'v2', 'EXPERIMENTAL')])
version_objs.extend([
build_version_object(2.9, 'v2', 'EXPERIMENTAL'),
build_version_object(2.7, 'v2', 'CURRENT'),
build_version_object(2.6, 'v2', 'SUPPORTED'),
build_version_object(2.5, 'v2', 'SUPPORTED'),
build_version_object(2.4, 'v2', 'SUPPORTED'),
build_version_object(2.3, 'v2', 'SUPPORTED'),
build_version_object(2.2, 'v2', 'SUPPORTED'),
build_version_object(2.1, 'v2', 'SUPPORTED'),
build_version_object(2.0, 'v2', 'SUPPORTED'),
])
status = explicit and http_client.OK or http_client.MULTIPLE_CHOICES
response = webob.Response(request=req,
status=status,
content_type='application/json')
response.body = jsonutils.dump_as_bytes(dict(versions=version_objs))
return response
def test_create_with_keys_in_uppercase_and_lowercase(
self, metadata_get, metadata_update):
# if the keys in uppercase_and_lowercase, should return the one
# which server added
fake_volume = {'id': self.req_id, 'status': 'available'}
fake_context = mock.Mock()
metadata_get.return_value = {}
metadata_update.side_effect = return_create_volume_metadata_insensitive
req = fakes.HTTPRequest.blank('/v2/volume_metadata')
req.method = 'POST'
req.content_type = "application/json"
body = {
"metadata": {
"key1": "value1",
"KEY1": "value1",
"key2": "value2",
"KEY2": "value2",
"key3": "value3",
"KEY4": "value4"
}
}
expected = {
"metadata": {
"key1": "value1",
"key2": "value2",
"key3": "value3",
"KEY4": "value4"
}
}
req.body = jsonutils.dump_as_bytes(body)
req.environ['cinder.context'] = fake_context
with mock.patch.object(self.controller.volume_api,
'get') as get_volume:
get_volume.return_value = fake_volume
res_dict = self.controller.create(req, self.req_id, body=body)
self.assertEqual(expected, res_dict)
def test_session_show(self):
CREDENTIALS_1 = {'tenant': 'test_tenant_1', 'user': '******'}
CREDENTIALS_2 = {'tenant': 'test_tenant_2', 'user': '******'}
self._set_policy_rules({'create_environment': '@'})
self.expect_policy_check('create_environment')
# Create environment for user #1
request = self._post(
'/environments',
jsonutils.dump_as_bytes({'name': 'test_environment_1'}),
**CREDENTIALS_1)
response_body = jsonutils.loads(request.get_response(self.api).body)
self.assertEqual(CREDENTIALS_1['tenant'], response_body['tenant_id'])
ENVIRONMENT_ID = response_body['id']
# Create session of user #1
request = self._post(
'/environments/{environment_id}/configure'.format(
environment_id=ENVIRONMENT_ID), b'', **CREDENTIALS_1)
response_body = jsonutils.loads(request.get_response(self.api).body)
SESSION_ID = response_body['id']
# Show environment with correct credentials
request = self._get(
'/environments/{environment_id}/sessions/{session_id}'.format(
environment_id=ENVIRONMENT_ID, session_id=SESSION_ID), b'',
**CREDENTIALS_1)
response_body = jsonutils.loads(request.get_response(self.api).body)
self.assertEqual(SESSION_ID, response_body['id'])
# Show environment with incorrect credentials
request = self._get(
'/environments/{environment_id}/sessions/{session_id}'.format(
environment_id=ENVIRONMENT_ID, session_id=SESSION_ID), b'',
**CREDENTIALS_2)
response = request.get_response(self.api)
self.assertEqual(403, response.status_code)
def test_create_cgsnapshot_when_volume_in_error_status(
self, mock_validate):
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,
status='error')['id']
body = {
"cgsnapshot": {
"name": "cg1",
"description": "CG Snapshot 1",
"consistencygroup_id": consistencygroup.id
}
}
req = webob.Request.blank('/v2/%s/cgsnapshots' % 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.BAD_REQUEST, res.status_int)
self.assertEqual(http_client.BAD_REQUEST,
res_dict['badRequest']['code'])
self.assertEqual(
"Invalid volume: The snapshot cannot be created when the volume "
"is in error status.", res_dict['badRequest']['message'])
self.assertTrue(mock_validate.called)
db.volume_destroy(context.get_admin_context(), volume_id)
consistencygroup.destroy()
def test_accept_transfer_with_invalid_transfer(self):
volume_id = self._create_volume()
transfer = self._create_transfer(volume_id)
body = {"accept": {"auth_key": 1}}
req = webob.Request.blank('/v2/%s/os-volume-transfer/%s/accept' %
(fake.PROJECT_ID, fake.WILL_NOT_BE_FOUND_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(HTTPStatus.NOT_FOUND, res.status_int)
self.assertEqual(HTTPStatus.NOT_FOUND,
res_dict['itemNotFound']['code'])
self.assertEqual(
'Transfer %s could not be found.' % fake.WILL_NOT_BE_FOUND_ID,
res_dict['itemNotFound']['message'])
db.transfer_destroy(context.get_admin_context(), transfer['id'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_update_all(self, metadata_update):
fake_volume = {'id': self.req_id, 'status': 'available'}
fake_context = mock.Mock()
metadata_update.side_effect = return_new_volume_metadata
req = fakes.HTTPRequest.blank(self.url)
req.method = 'PUT'
req.content_type = "application/json"
expected = {
'metadata': {
'key10': 'value10',
'key99': 'value99',
'KEY20': 'value20',
},
}
req.body = jsonutils.dump_as_bytes(expected)
req.environ['cinder.context'] = fake_context
with mock.patch.object(self.controller.volume_api,
'get') as get_volume:
get_volume.return_value = fake_volume
res_dict = self.controller.update_all(req, self.req_id, expected)
self.assertEqual(expected, res_dict)
get_volume.assert_called_once_with(fake_context, self.req_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(HTTPStatus.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_attach_vol_shelved_supported(self, mock_get_instance,
mock_attach):
body = {
'volumeAttachment': {
'volumeId': FAKE_UUID_A,
'device': '/dev/fake'
}
}
inst = fake_instance.fake_instance_obj(self.context,
**{'uuid': FAKE_UUID})
inst.vm_state = vm_states.SHELVED
mock_get_instance.return_value = inst
req = fakes.HTTPRequest.blank('/v2/servers/id/os-volume_attachments',
version='2.20')
req.method = 'POST'
req.body = jsonutils.dump_as_bytes({})
req.headers['content-type'] = 'application/json'
req.environ['nova.context'] = self.context
result = self.attachments.create(req, FAKE_UUID, body=body)
self.assertEqual('00000000-aaaa-aaaa-aaaa-000000000000',
result['volumeAttachment']['id'])
self.assertEqual('/dev/myfake', result['volumeAttachment']['device'])
def test_create_volume_maintenance(self, metadata_get, metadata_update):
fake_volume = {'id': self.req_id, 'status': 'maintenance'}
fake_context = mock.Mock()
metadata_get.side_effect = return_empty_volume_metadata
metadata_update.side_effect = return_create_volume_metadata
req = fakes.HTTPRequest.blank('/v2/volume_metadata')
req.method = 'POST'
req.content_type = "application/json"
body = {
"metadata": {
"key1": "value1",
"key2": "value2",
"key3": "value3",
}
}
req.body = jsonutils.dump_as_bytes(body)
req.environ['cinder.context'] = fake_context
with mock.patch.object(self.controller.volume_api,
'get') as get_volume:
get_volume.return_value = fake_volume
self.assertRaises(exception.InvalidVolume, self.controller.create,
req, self.req_id, body)
def test_create_encryption_type_exists(self):
volume_type = self._default_volume_type
body = {"encryption": stub_volume_type_encryption()}
self._create_type_and_encryption(volume_type, body)
# Try to create encryption specs for a volume type
# that already has them.
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': ('Volume type encryption for type '
'%s already exists.' % fake.VOLUME_TYPE_ID)
}
}
self.assertEqual(expected, res_dict)
db.volume_type_destroy(context.get_admin_context(), volume_type['id'])
def test_create_transfer_json(self, mock_validate):
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(202, res.status_int)
self.assertIn('id', res_dict['transfer'])
self.assertIn('auth_key', res_dict['transfer'])
self.assertIn('created_at', res_dict['transfer'])
self.assertIn('name', res_dict['transfer'])
self.assertIn('volume_id', res_dict['transfer'])
self.assertTrue(mock_validate.called)
db.volume_destroy(context.get_admin_context(), volume_id)
def test_reassign_ports(self):
ports = [1, 2, 3]
test_input = {
"remote_server": "REMOTE_SERVER",
"ixload_cfg": "IXLOAD_CFG",
"result_dir": "RESULT_DIR",
"ixia_chassis": "IXIA_CHASSIS",
"IXIA": {
"card": "CARD",
"ports": ports,
},
'links_param': {}
}
j = jsonutils.dump_as_bytes(test_input)
ixload = http_ixload.IXLOADHttpTest(j)
repository = mock.Mock()
test = mock.MagicMock()
test.setPorts = mock.Mock()
ports_to_reassign = [(1, 2, 3), (1, 2, 4)]
ixload.format_ports_for_reassignment = mock.Mock(
return_value=["1;2;3"])
self.assertIsNone(
ixload.reassign_ports(test, repository, ports_to_reassign))
def _migrate_volume_exec(self,
ctx,
volume,
host,
expected_status,
force_host_copy=False):
# build request to migrate to host
req = webob.Request.blank('/v2/fake/volumes/%s/action' % volume['id'])
req.method = 'POST'
req.headers['content-type'] = 'application/json'
body = {
'os-migrate_volume': {
'host': host,
'force_host_copy': force_host_copy
}
}
req.body = jsonutils.dump_as_bytes(body)
req.environ['cinder.context'] = ctx
resp = req.get_response(app())
# verify status
self.assertEqual(expected_status, resp.status_int)
volume = db.volume_get(self.ctx, volume['id'])
return volume
def test_upload_vnf_package_content(self, mock_vnf_pack_save,
mock_vnf_by_id,
mock_upload_vnf_package_content,
mock_glance_store):
file_path = "tacker/tests/etc/samples/test_data.zip"
file_obj = open(file_path, "rb")
updates = {'onboarding_state': 'CREATED',
'operational_state': 'DISABLED'}
vnf_package_dict = fakes.fake_vnf_package(updates)
vnf_package_obj = objects.VnfPackage(**vnf_package_dict)
mock_vnf_by_id.return_value = vnf_package_obj
mock_vnf_pack_save.return_value = vnf_package_obj
mock_glance_store.return_value = 'location', 0, 'checksum',\
'multihash', 'loc_meta'
req = fake_request.HTTPRequest.blank(
'/vnf_packages/%s/package_content'
% constants.UUID)
req.headers['Content-Type'] = 'application/zip'
req.method = 'PUT'
req.body = jsonutils.dump_as_bytes(file_obj)
resp = req.get_response(self.app)
mock_glance_store.assert_called()
self.assertEqual(http_client.ACCEPTED, resp.status_code)
def test_create_with_cgsnapshot_not_found(self, mock_create_cgsnapshot):
consistencygroup = utils.create_consistencygroup(self.context)
utils.create_volume(
self.context, consistencygroup_id=consistencygroup.id)
body = {"cgsnapshot": {"name": "cg1",
"description":
"CG Snapshot 1",
"consistencygroup_id": consistencygroup.id}}
req = webob.Request.blank('/v2/%s/cgsnapshots' % 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(404, res.status_int)
self.assertEqual(404, res_dict['itemNotFound']['code'])
self.assertEqual('CgSnapshot invalid_id could not be found.',
res_dict['itemNotFound']['message'])
consistencygroup.destroy()
def _test_rebuild_server_disk_config(self, uuid, disk_config,
get_instance_mock):
req = fakes.HTTPRequest.blank('/%s/servers/%s/action' %
(self.project_id, uuid))
req.method = 'POST'
req.content_type = 'application/json'
auto_disk_config = (disk_config == 'AUTO')
instance = fakes.stub_instance_obj(
req.environ['nova.context'],
project_id=req.environ['nova.context'].project_id,
user_id=req.environ['nova.context'].user_id,
auto_disk_config=auto_disk_config)
get_instance_mock.return_value = instance
body = {
"rebuild": {
'imageRef': 'cedef40a-ed67-4d10-800e-17455edce175',
API_DISK_CONFIG: disk_config
}
}
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(self.app)
server_dict = jsonutils.loads(res.body)['server']
self.assertDiskConfig(server_dict, disk_config)
def test_create_invalid_volume_type(self):
volume_type = self._default_volume_type
body = {"encryption": stub_volume_type_encryption()}
# Attempt to create encryption without first creating type
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)
self.assertEqual(0, len(self.notifier.notifications))
self.assertEqual(404, res.status_code)
expected = {
'itemNotFound': {
'code':
404,
'message':
('Volume type %s could not be found.' % volume_type['id'])
}
}
self.assertEqual(expected, res_dict)
def test_invalid_metadata_items_on_create(self, data, snapshot_get_by_id):
snapshot = {
'id': self.req_id,
'expected_attrs': ['metadata']
}
ctx = context.RequestContext(fake.USER_ID, fake.PROJECT_ID, True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(ctx, **snapshot)
snapshot_get_by_id.return_value = snapshot_obj
self.mock_object(cinder.db, 'snapshot_metadata_update',
return_create_snapshot_metadata)
req = fakes.HTTPRequest.blank(self.url)
req.method = 'POST'
req.headers["content-type"] = "application/json"
exc = webob.exc.HTTPBadRequest
if (len(list(data['metadata'].keys())[0]) > 255 or
(list(data['metadata'].values())[0] is not None and
len(list(data['metadata'].values())[0]) > 255)):
exc = webob.exc.HTTPRequestEntityTooLarge
req.body = jsonutils.dump_as_bytes(data)
self.assertRaises(exc, self.controller.create, req, self.req_id, data)
def test_controller_action_extension_late(self):
# Need a dict for the body to convert to a ResponseObject
controller = StubActionController(dict(foo=response_body))
actions = dict(action='POST')
res_ext = base_extensions.ResourceExtension('tweedles',
controller,
member_actions=actions)
ext_controller = StubLateExtensionController(extension_body)
extension = StubControllerExtension()
cont_ext = base_extensions.ControllerExtension(extension, 'tweedles',
ext_controller)
manager = StubExtensionManager(resource_ext=res_ext,
controller_ext=cont_ext)
app = compute.APIRouter(manager)
request = webob.Request.blank("/fake/tweedles/foo/action")
request.method = 'POST'
request.headers['Content-Type'] = 'application/json'
request.body = jsonutils.dump_as_bytes(dict(fooAction=True))
response = request.get_response(app)
self.assertEqual(200, response.status_int)
self.assertEqual(extension_body, response.body)
def test_create_server_with_hints(self):
def fake_create(*args, **kwargs):
self.assertEqual(kwargs['scheduler_hints'], {'group': 'foo'})
return ([self.fake_instance], '')
self.stubs.Set(nova.compute.api.API, 'create', fake_create)
req = self._get_request()
req.method = 'POST'
req.content_type = 'application/json'
body = {
'server': {
'name': 'server_test',
'imageRef': 'cedef40a-ed67-4d10-800e-17455edce175',
'flavorRef': '1',
},
'os:scheduler_hints': {'group': 'foo'},
}
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(self.app)
self.assertEqual(202, res.status_int)
def setUp(self):
super(VolumeAttachTestsV21, self).setUp()
self.stub_out(
'nova.objects.BlockDeviceMappingList'
'.get_by_instance_uuid', fake_bdm_list_get_by_instance_uuid)
self.stubs.Set(compute_api.API, 'get', fake_get_instance)
self.stubs.Set(cinder.API, 'get', fake_get_volume)
self.context = context.get_admin_context()
self.expected_show = {
'volumeAttachment': {
'device': '/dev/fake0',
'serverId': FAKE_UUID,
'id': FAKE_UUID_A,
'volumeId': FAKE_UUID_A
}
}
self.attachments = volumes_v21.VolumeAttachmentController()
self.req = fakes.HTTPRequest.blank(
'/v2/servers/id/os-volume_attachments/uuid')
self.req.body = jsonutils.dump_as_bytes({})
self.req.headers['content-type'] = 'application/json'
self.req.environ['nova.context'] = self.context
def test_attach_vol_shelved_not_supported(self, mock_get_instance):
body = {
'volumeAttachment': {
'volumeId': FAKE_UUID_A,
'device': '/dev/fake'
}
}
inst = fake_instance.fake_instance_obj(self.context,
**{'uuid': FAKE_UUID})
inst.vm_state = vm_states.SHELVED
mock_get_instance.return_value = inst
req = fakes.HTTPRequest.blank('/v2/servers/id/os-volume_attachments',
version='2.19')
req.method = 'POST'
req.body = jsonutils.dump_as_bytes({})
req.headers['content-type'] = 'application/json'
req.environ['nova.context'] = self.context
self.assertRaises(webob.exc.HTTPConflict,
self.attachments.create,
req,
FAKE_UUID,
body=body)
def test_update_config(self):
net_taraffic_0 = mock.Mock()
net_taraffic_0.name = "HTTP client@uplink_0"
net_taraffic_1 = mock.Mock()
net_taraffic_1.name = "HTTP client@uplink_1"
community_list = [net_taraffic_0, net_taraffic_1, Exception]
ixload = http_ixload.IXLOADHttpTest(
jsonutils.dump_as_bytes(self.test_input))
ixload.links_param = {"uplink_0": {"ip": {}, "http_client": {}}}
ixload.test = mock.Mock()
ixload.test.communityList = community_list
ixload.update_network_param = mock.Mock()
ixload.update_http_client_param = mock.Mock()
ixload.update_config()
ixload.update_network_param.assert_called_once_with(net_taraffic_0, {})
ixload.update_http_client_param.assert_called_once_with(
net_taraffic_0, {})
def _metadata_as_json(self, version, path):
metadata = {'uuid': self.uuid}
if self.files:
metadata['files'] = self.files
if self.extra_md:
metadata.update(self.extra_md)
if self.keypair:
metadata['public_keys'] = {
self.keypair.name: self.keypair.public_key,
}
metadata['keys'] = [{
'name': self.keypair.name,
'type': self.keypair.type,
'data': self.keypair.public_key
}]
metadata['hostname'] = self.hostname
metadata['name'] = self.server.name
metadata['availability_zone'] = self.availability_zone
return jsonutils.dump_as_bytes(metadata)
def test_update_network_param(self):
net_traffic = mock.Mock()
ixload = http_ixload.IXLOADHttpTest(
jsonutils.dump_as_bytes(self.test_input))
ixload.update_network_address = mock.Mock()
ixload.update_network_mac_address = mock.Mock()
param = {
"address": "address",
"gateway": "gateway",
"subnet_prefix": "subnet_prefix",
"mac": "mac"
}
ixload.update_network_param(net_traffic, param)
ixload.update_network_address.assert_called_once_with(
net_traffic, "address", "gateway", "subnet_prefix")
ixload.update_network_mac_address.assert_called_once_with(
net_traffic, "mac")
def test_create_server_with_auto_disk_config(self):
req = fakes.HTTPRequest.blank('/fake/servers')
req.method = 'POST'
req.content_type = 'application/json'
body = {'server': {
'name': 'server_test',
'imageRef': 'cedef40a-ed67-4d10-800e-17455edce175',
'flavorRef': '1',
API_DISK_CONFIG: 'AUTO'
}}
old_create = compute_api.API.create
def create(*args, **kwargs):
self.assertIn('auto_disk_config', kwargs)
self.assertTrue(kwargs['auto_disk_config'])
return old_create(*args, **kwargs)
self.stubs.Set(compute_api.API, 'create', create)
req.body = jsonutils.dump_as_bytes(body)
res = req.get_response(self.app)
server_dict = jsonutils.loads(res.body)['server']
self.assertDiskConfig(server_dict, 'AUTO')
def test_accept_transfer_invalid_id_auth_key(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/%s/os-volume-transfer/%s/accept' %
(fake.PROJECT_ID, transfer['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(
res_dict['badRequest']['message'],
'Invalid auth key: Attempt to transfer %s with '
'invalid auth key.' % transfer['id'])
db.transfer_destroy(context.get_admin_context(), transfer['id'])
db.volume_destroy(context.get_admin_context(), volume_id)
def test_create(self, metadata_get, metadata_update):
fake_volume = {'id': self.req_id, 'status': 'available'}
fake_context = mock.Mock()
metadata_get.return_value = {}
metadata_update.side_effect = return_create_volume_metadata
req = fakes.HTTPRequest.blank('/v2/volume_metadata')
req.method = 'POST'
req.content_type = "application/json"
body = {
"metadata": {
"key1": "value1",
"key2": "value2",
"key3": "value3",
}
}
req.body = jsonutils.dump_as_bytes(body)
req.environ['cinder.context'] = fake_context
with mock.patch.object(self.controller.volume_api,
'get') as get_volume:
get_volume.return_value = fake_volume
res_dict = self.controller.create(req, self.req_id, body=body)
self.assertEqual(body, res_dict)
def get_token_from_zbxserver(self, node):
temp_auth_api = copy.deepcopy(zapi.dAUTH_API)
temp_auth_api['params']['user'] = \
self.hostinfo[node]['zbx_info']['zabbix_user']
temp_auth_api['params']['password'] = \
self.hostinfo[node]['zbx_info']['zabbix_pass']
zabbixip = \
self.hostinfo[node]['zbx_info']['zabbix_ip']
zabbixport = \
self.hostinfo[node]['zbx_info']['zabbix_port']
self.URL = "http://" + zabbixip + ":" + \
str(zabbixport) + zapi.URL
if netaddr.valid_ipv6(zabbixip):
self.URL = "http://[" + zabbixip + "]:" + \
str(zabbixport) + zapi.URL
response = requests.post(self.URL,
headers=zapi.HEADERS,
data=jsonutils.dump_as_bytes(temp_auth_api))
response_dict = dict(response.json())
VNFMonitorZabbix.check_error(response_dict)
LOG.info('Success Connect Zabbix Server')
return response_dict['result']
def test_parse_run_test(self):
ports = [1, 2, 3]
test_input = {
"remote_server": "REMOTE_SERVER",
"ixload_cfg": "IXLOAD_CFG",
"result_dir": "RESULT_DIR",
"ixia_chassis": "IXIA_CHASSIS",
"IXIA": {
"card": "CARD",
"ports": ports,
},
'links_param': {}
}
j = jsonutils.dump_as_bytes(test_input)
ixload = http_ixload.IXLOADHttpTest(j)
self.assertDictEqual(ixload.test_input, test_input)
self.assertIsNone(ixload.parse_run_test())
self.assertEqual(ixload.ports_to_reassign, [
["IXIA_CHASSIS", "CARD", 1],
["IXIA_CHASSIS", "CARD", 2],
["IXIA_CHASSIS", "CARD", 3],
])
self.assertEqual({}, ixload.links_param)
