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)