def fake_attach_interface_to_locked_server(self, context,
instance, network_id, port_id, requested_ip, tag=None):
raise exception.InstanceIsLocked(instance_uuid=FAKE_UUID1)
class BadStateServerMetaDataTestV21(test.TestCase):
def setUp(self):
super(BadStateServerMetaDataTestV21, self).setUp()
self.stub_out('nova.db.main.api.instance_metadata_get',
return_server_metadata)
self.stub_out(
'nova.compute.api.API.get',
fakes.fake_compute_get(
**{
'uuid': '0cc3346e-9fef-4445-abe6-5d2b2690ec64',
'name': 'fake',
'vm_state': vm_states.BUILDING
}))
self.stub_out('nova.db.main.api.instance_metadata_delete',
delete_server_metadata)
self._set_up_resources()
def _set_up_resources(self):
self.controller = server_metadata_v21.ServerMetadataController()
self.uuid = uuids.fake
self.url = '/%s/servers/%s/metadata' % (fakes.FAKE_PROJECT_ID,
self.uuid)
def _get_request(self, param_url=''):
return fakes.HTTPRequestV21.blank(self.url + param_url)
def test_invalid_state_on_delete(self):
req = self._get_request('/key2')
req.method = 'DELETE'
self.assertRaises(webob.exc.HTTPConflict, self.controller.delete, req,
self.uuid, 'key2')
def test_invalid_state_on_update_metadata(self):
self.stub_out('nova.db.main.api.instance_metadata_update',
return_create_instance_metadata)
req = self._get_request()
req.method = 'POST'
req.content_type = 'application/json'
expected = {
'metadata': {
'key1': 'updatedvalue',
'key29': 'newkey',
}
}
req.body = jsonutils.dump_as_bytes(expected)
self.assertRaises(webob.exc.HTTPConflict,
self.controller.update_all,
req,
self.uuid,
body=expected)
@mock.patch.object(nova.compute.api.API,
'update_instance_metadata',
side_effect=exception.InstanceIsLocked(instance_uuid=0))
def test_instance_lock_update_metadata(self, mock_update):
req = self._get_request()
req.method = 'POST'
req.content_type = 'application/json'
expected = {
'metadata': {
'keydummy': 'newkey',
}
}
req.body = jsonutils.dump_as_bytes(expected)
self.assertRaises(webob.exc.HTTPConflict,
self.controller.update_all,
req,
self.uuid,
body=expected)
def fake_detach_interface_from_locked_server(self, context,
instance, port_id):
raise exception.InstanceIsLocked(instance_uuid=FAKE_UUID1)
def fake_actions_to_locked_server(self, context, instance, *args, **kwargs):
raise exc.InstanceIsLocked(instance_uuid=instance['uuid'])
def fake_rescue(*args, **kwargs):
raise exception.InstanceIsLocked('fake message')
class BadStateServerMetaDataTestV21(test.TestCase):
def setUp(self):
super(BadStateServerMetaDataTestV21, self).setUp()
fakes.stub_out_key_pair_funcs(self.stubs)
self.stubs.Set(nova.db, 'instance_metadata_get',
return_server_metadata)
self.stubs.Set(compute_rpcapi.ComputeAPI, 'change_instance_metadata',
fake_change_instance_metadata)
self.stubs.Set(nova.db, 'instance_get', self._return_server_in_build)
self.stubs.Set(nova.db, 'instance_get_by_uuid',
self._return_server_in_build_by_uuid)
self.stubs.Set(nova.db, 'instance_metadata_delete',
delete_server_metadata)
self._set_up_resources()
def _set_up_resources(self):
self.controller = server_metadata_v21.ServerMetadataController()
self.uuid = str(uuid.uuid4())
self.url = '/fake/servers/%s/metadata' % self.uuid
def _get_request(self, param_url=''):
return fakes.HTTPRequestV3.blank(self.url + param_url)
def test_invalid_state_on_delete(self):
req = self._get_request('/key2')
req.method = 'DELETE'
self.assertRaises(webob.exc.HTTPConflict, self.controller.delete, req,
self.uuid, 'key2')
def test_invalid_state_on_update_metadata(self):
self.stubs.Set(nova.db, 'instance_metadata_update',
return_create_instance_metadata)
req = self._get_request()
req.method = 'POST'
req.content_type = 'application/json'
expected = {
'metadata': {
'key1': 'updatedvalue',
'key29': 'newkey',
}
}
req.body = jsonutils.dumps(expected)
self.assertRaises(webob.exc.HTTPConflict,
self.controller.update_all,
req,
self.uuid,
body=expected)
def _return_server_in_build(self,
context,
server_id,
columns_to_join=None):
return fake_instance.fake_db_instance(
**{
'id': server_id,
'uuid': '0cc3346e-9fef-4445-abe6-5d2b2690ec64',
'name': 'fake',
'locked': False,
'vm_state': vm_states.BUILDING
})
def _return_server_in_build_by_uuid(self,
context,
server_uuid,
columns_to_join=None,
use_slave=False):
return fake_instance.fake_db_instance(
**{
'id': 1,
'uuid': '0cc3346e-9fef-4445-abe6-5d2b2690ec64',
'name': 'fake',
'locked': False,
'vm_state': vm_states.BUILDING
})
@mock.patch.object(nova.compute.api.API,
'update_instance_metadata',
side_effect=exception.InstanceIsLocked(instance_uuid=0))
def test_instance_lock_update_metadata(self, mock_update):
req = self._get_request()
req.method = 'POST'
req.content_type = 'application/json'
expected = {
'metadata': {
'keydummy': 'newkey',
}
}
req.body = jsonutils.dumps(expected)
self.assertRaises(webob.exc.HTTPConflict,
self.controller.update_all,
req,
self.uuid,
body=expected)
def fake_unrescue_from_locked_server(self, context, instance):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
class DeferredDeleteExtensionTestV21(test.NoDBTestCase):
ext_ver = dd_v21.DeferredDeleteController
def setUp(self):
super(DeferredDeleteExtensionTestV21, self).setUp()
self.fake_input_dict = {}
self.fake_uuid = 'fake_uuid'
self.fake_context = context.RequestContext('fake',
fakes.FAKE_PROJECT_ID)
self.fake_req = FakeRequest(self.fake_context)
self.extension = self.ext_ver()
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(compute_api.API, 'force_delete')
def test_force_delete(self, mock_force_delete, mock_get):
instance = fake_instance.fake_instance_obj(
self.fake_req.environ['nova.context'])
mock_get.return_value = instance
res = self.extension._force_delete(self.fake_req, self.fake_uuid,
self.fake_input_dict)
# NOTE: on v2.1, http status code is set as wsgi_code of API
# method instead of status_int in a response object.
if isinstance(self.extension, dd_v21.DeferredDeleteController):
status_int = self.extension._force_delete.wsgi_code
else:
status_int = res.status_int
self.assertEqual(202, status_int)
mock_get.assert_called_once_with(self.fake_context,
self.fake_uuid,
expected_attrs=None,
cell_down_support=False)
mock_force_delete.assert_called_once_with(self.fake_context, instance)
@mock.patch.object(compute_api.API, 'get')
def test_force_delete_instance_not_found(self, mock_get):
mock_get.side_effect = exception.InstanceNotFound(
instance_id='instance-0000')
self.assertRaises(webob.exc.HTTPNotFound, self.extension._force_delete,
self.fake_req, self.fake_uuid, self.fake_input_dict)
mock_get.assert_called_once_with(self.fake_context,
self.fake_uuid,
expected_attrs=None,
cell_down_support=False)
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(
compute_api.API,
'force_delete',
side_effect=exception.InstanceIsLocked(instance_uuid='fake_uuid'))
def test_force_delete_instance_locked(self, mock_force_delete, mock_get):
req = fakes.HTTPRequest.blank('/v2/%s/servers/fake_uuid/action' %
fakes.FAKE_PROJECT_ID)
ex = self.assertRaises(webob.exc.HTTPConflict,
self.extension._force_delete, req, 'fake_uuid',
'')
self.assertIn('Instance fake_uuid is locked', ex.explanation)
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(
compute_api.API,
'force_delete',
side_effect=exception.InstanceNotFound(instance_id='fake_uuid'))
def test_force_delete_instance_notfound(self, mock_force_delete, mock_get):
req = fakes.HTTPRequest.blank('/v2/%s/servers/fake_uuid/action' %
fakes.FAKE_PROJECT_ID)
ex = self.assertRaises(webob.exc.HTTPNotFound,
self.extension._force_delete, req, 'fake_uuid',
'')
self.assertIn('Instance fake_uuid could not be found', ex.explanation)
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(compute_api.API, 'restore')
def test_restore(self, mock_restore, mock_get):
instance = fake_instance.fake_instance_obj(
self.fake_req.environ['nova.context'])
mock_get.return_value = instance
res = self.extension._restore(self.fake_req, self.fake_uuid,
self.fake_input_dict)
# NOTE: on v2.1, http status code is set as wsgi_code of API
# method instead of status_int in a response object.
if isinstance(self.extension, dd_v21.DeferredDeleteController):
status_int = self.extension._restore.wsgi_code
else:
status_int = res.status_int
self.assertEqual(202, status_int)
mock_get.assert_called_once_with(self.fake_context,
self.fake_uuid,
expected_attrs=None,
cell_down_support=False)
mock_restore.assert_called_once_with(self.fake_context, instance)
@mock.patch.object(compute_api.API, 'get')
def test_restore_instance_not_found(self, mock_get):
mock_get.side_effect = exception.InstanceNotFound(
instance_id='instance-0000')
self.assertRaises(webob.exc.HTTPNotFound, self.extension._restore,
self.fake_req, self.fake_uuid, self.fake_input_dict)
mock_get.assert_called_once_with(self.fake_context,
self.fake_uuid,
expected_attrs=None,
cell_down_support=False)
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(compute_api.API, 'restore')
def test_restore_raises_conflict_on_invalid_state(self, mock_restore,
mock_get):
instance = fake_instance.fake_instance_obj(
self.fake_req.environ['nova.context'])
mock_get.return_value = instance
mock_restore.side_effect = exception.InstanceInvalidState(
attr='fake_attr',
state='fake_state',
method='fake_method',
instance_uuid='fake')
self.assertRaises(webob.exc.HTTPConflict, self.extension._restore,
self.fake_req, self.fake_uuid, self.fake_input_dict)
mock_get.assert_called_once_with(self.fake_context,
self.fake_uuid,
expected_attrs=None,
cell_down_support=False)
mock_restore.assert_called_once_with(self.fake_context, instance)
class DeferredDeleteExtensionTestV21(test.NoDBTestCase):
ext_ver = dd_v21.DeferredDeleteController
def setUp(self):
super(DeferredDeleteExtensionTestV21, self).setUp()
self.fake_input_dict = {}
self.fake_uuid = 'fake_uuid'
self.fake_context = context.RequestContext('fake', 'fake')
self.fake_req = FakeRequest(self.fake_context)
self.extension = self.ext_ver()
def test_force_delete(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
self.mox.StubOutWithMock(compute_api.API, 'force_delete')
instance = fake_instance.fake_instance_obj(
self.fake_req.environ['nova.context'])
compute_api.API.get(self.fake_context,
self.fake_uuid,
expected_attrs=None).AndReturn(instance)
compute_api.API.force_delete(self.fake_context, instance)
self.mox.ReplayAll()
res = self.extension._force_delete(self.fake_req, self.fake_uuid,
self.fake_input_dict)
# NOTE: on v2.1, http status code is set as wsgi_code of API
# method instead of status_int in a response object.
if isinstance(self.extension, dd_v21.DeferredDeleteController):
status_int = self.extension._force_delete.wsgi_code
else:
status_int = res.status_int
self.assertEqual(202, status_int)
def test_force_delete_instance_not_found(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
compute_api.API.get(
self.fake_context, self.fake_uuid, expected_attrs=None).AndRaise(
exception.InstanceNotFound(instance_id='instance-0000'))
self.mox.ReplayAll()
self.assertRaises(webob.exc.HTTPNotFound, self.extension._force_delete,
self.fake_req, self.fake_uuid, self.fake_input_dict)
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(
compute_api.API,
'force_delete',
side_effect=exception.InstanceIsLocked(instance_uuid='fake_uuid'))
def test_force_delete_instance_locked(self, mock_force_delete, mock_get):
req = fakes.HTTPRequest.blank('/v2/fake/servers/fake_uuid/action')
ex = self.assertRaises(webob.exc.HTTPConflict,
self.extension._force_delete, req, 'fake_uuid',
'')
self.assertIn('Instance fake_uuid is locked', ex.explanation)
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(
compute_api.API,
'force_delete',
side_effect=exception.InstanceNotFound(instance_id='fake_uuid'))
def test_force_delete_instance_notfound(self, mock_force_delete, mock_get):
req = fakes.HTTPRequest.blank('/v2/fake/servers/fake_uuid/action')
ex = self.assertRaises(webob.exc.HTTPNotFound,
self.extension._force_delete, req, 'fake_uuid',
'')
self.assertIn('Instance fake_uuid could not be found', ex.explanation)
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(
compute_api.API,
'force_delete',
side_effect=exception.InstanceUnknownCell(instance_uuid='fake_uuid'))
def test_force_delete_instance_cellunknown(self, mock_force_delete,
mock_get):
req = fakes.HTTPRequest.blank('/v2/fake/servers/fake_uuid/action')
ex = self.assertRaises(webob.exc.HTTPNotFound,
self.extension._force_delete, req, 'fake_uuid',
'')
self.assertIn('Cell is not known for instance fake_uuid',
ex.explanation)
def test_restore(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
self.mox.StubOutWithMock(compute_api.API, 'restore')
fake_instance = 'fake_instance'
compute_api.API.get(self.fake_context,
self.fake_uuid,
expected_attrs=None).AndReturn(fake_instance)
compute_api.API.restore(self.fake_context, fake_instance)
self.mox.ReplayAll()
res = self.extension._restore(self.fake_req, self.fake_uuid,
self.fake_input_dict)
# NOTE: on v2.1, http status code is set as wsgi_code of API
# method instead of status_int in a response object.
if isinstance(self.extension, dd_v21.DeferredDeleteController):
status_int = self.extension._restore.wsgi_code
else:
status_int = res.status_int
self.assertEqual(202, status_int)
def test_restore_instance_not_found(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
compute_api.API.get(
self.fake_context, self.fake_uuid, expected_attrs=None).AndRaise(
exception.InstanceNotFound(instance_id='instance-0000'))
self.mox.ReplayAll()
self.assertRaises(webob.exc.HTTPNotFound, self.extension._restore,
self.fake_req, self.fake_uuid, self.fake_input_dict)
def test_restore_raises_conflict_on_invalid_state(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
self.mox.StubOutWithMock(compute_api.API, 'restore')
fake_instance = 'fake_instance'
exc = exception.InstanceInvalidState(attr='fake_attr',
state='fake_state',
method='fake_method',
instance_uuid='fake')
compute_api.API.get(self.fake_context,
self.fake_uuid,
expected_attrs=None).AndReturn(fake_instance)
compute_api.API.restore(self.fake_context, fake_instance).AndRaise(exc)
self.mox.ReplayAll()
self.assertRaises(webob.exc.HTTPConflict, self.extension._restore,
self.fake_req, self.fake_uuid, self.fake_input_dict)
def fake_volume_actions_to_locked_server(self, context, instance, volume):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
class ServerStartStopTestV21(test.TestCase):
start_policy = "os_compute_api:servers:start"
stop_policy = "os_compute_api:servers:stop"
def setUp(self):
super(ServerStartStopTestV21, self).setUp()
self._setup_controller()
self.req = fakes.HTTPRequest.blank('')
self.stub_out('nova.db.instance_get_by_uuid',
fakes.fake_instance_get())
def _setup_controller(self):
ext_info = extension_info.LoadedExtensionInfo()
self.controller = server_v21.ServersController(extension_info=ext_info)
@mock.patch.object(compute_api.API, 'start')
def test_start(self, start_mock):
body = dict(start="")
self.controller._start_server(self.req, uuids.instance, body)
start_mock.assert_called_once_with(mock.ANY, mock.ANY)
def test_start_policy_failed(self):
rules = {self.start_policy: "project_id:non_fake"}
policy.set_rules(oslo_policy.Rules.from_dict(rules))
body = dict(start="")
exc = self.assertRaises(exception.PolicyNotAuthorized,
self.controller._start_server, self.req,
uuids.instance, body)
self.assertIn(self.start_policy, exc.format_message())
@mock.patch.object(
compute_api.API,
'start',
side_effect=exception.InstanceNotReady(instance_id=uuids.instance))
def test_start_not_ready(self, start_mock):
body = dict(start="")
self.assertRaises(webob.exc.HTTPConflict,
self.controller._start_server, self.req,
uuids.instance, body)
@mock.patch.object(
compute_api.API,
'start',
side_effect=exception.InstanceIsLocked(instance_uuid=uuids.instance))
def test_start_locked_server(self, start_mock):
body = dict(start="")
self.assertRaises(webob.exc.HTTPConflict,
self.controller._start_server, self.req,
uuids.instance, body)
@mock.patch.object(
compute_api.API,
'start',
side_effect=exception.InstanceIsLocked(instance_uuid=uuids.instance))
def test_start_invalid_state(self, start_mock):
body = dict(start="")
ex = self.assertRaises(webob.exc.HTTPConflict,
self.controller._start_server, self.req,
uuids.instance, body)
self.assertIn('is locked', six.text_type(ex))
@mock.patch.object(compute_api.API, 'stop')
def test_stop(self, stop_mock):
body = dict(stop="")
self.controller._stop_server(self.req, uuids.instance, body)
stop_mock.assert_called_once_with(mock.ANY, mock.ANY)
def test_stop_policy_failed(self):
rules = {self.stop_policy: "project_id:non_fake"}
policy.set_rules(oslo_policy.Rules.from_dict(rules))
body = dict(stop="")
exc = self.assertRaises(exception.PolicyNotAuthorized,
self.controller._stop_server, self.req,
uuids.instance, body)
self.assertIn(self.stop_policy, exc.format_message())
@mock.patch.object(
compute_api.API,
'stop',
side_effect=exception.InstanceNotReady(instance_id=uuids.instance))
def test_stop_not_ready(self, stop_mock):
body = dict(stop="")
self.assertRaises(webob.exc.HTTPConflict, self.controller._stop_server,
self.req, uuids.instance, body)
@mock.patch.object(
compute_api.API,
'stop',
side_effect=exception.InstanceIsLocked(instance_uuid=uuids.instance))
def test_stop_locked_server(self, stop_mock):
body = dict(stop="")
ex = self.assertRaises(webob.exc.HTTPConflict,
self.controller._stop_server, self.req,
uuids.instance, body)
self.assertIn('is locked', six.text_type(ex))
@mock.patch.object(
compute_api.API,
'stop',
side_effect=exception.InstanceIsLocked(instance_uuid=uuids.instance))
def test_stop_invalid_state(self, stop_mock):
body = dict(start="")
self.assertRaises(webob.exc.HTTPConflict, self.controller._stop_server,
self.req, uuids.instance, body)
@mock.patch.object(
db,
'instance_get_by_uuid',
side_effect=exception.InstanceNotFound(instance_id=uuids.instance))
def test_start_with_bogus_id(self, get_mock):
body = dict(start="")
self.assertRaises(webob.exc.HTTPNotFound,
self.controller._start_server, self.req,
uuids.instance, body)
@mock.patch.object(
db,
'instance_get_by_uuid',
side_effect=exception.InstanceNotFound(instance_id=uuids.instance))
def test_stop_with_bogus_id(self, get_mock):
body = dict(stop="")
self.assertRaises(webob.exc.HTTPNotFound, self.controller._stop_server,
self.req, uuids.instance, body)
class RescueTestV21(test.NoDBTestCase):
image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6'
def setUp(self):
super(RescueTestV21, self).setUp()
self.stub_out("nova.compute.api.API.get", fake_compute_get)
self.stub_out("nova.compute.api.API.rescue", rescue)
self.stub_out("nova.compute.api.API.unrescue", unrescue)
self.controller = self._set_up_controller()
self.fake_req = fakes.HTTPRequest.blank('')
def _set_up_controller(self):
return rescue_v21.RescueController()
def _allow_bfv_rescue(self):
return api_version_request.is_supported(self.fake_req, '2.87')
@ddt.data(
exception.InstanceIsLocked(instance_uuid=uuids.instance),
exception.InvalidVolume(reason='foo'),
)
@mock.patch.object(compute.api.API, 'rescue')
def test_rescue__http_conflict_error(self, exc, mock_rescue):
"""Test that exceptions are translated into HTTP Conflict errors."""
mock_rescue.side_effect = exc
body = {"rescue": {"adminPass": "******"}}
self.assertRaises(webob.exc.HTTPConflict,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
self.assertTrue(mock_rescue.called)
@ddt.data(
exception.OperationNotSupportedForVTPM(instance_uuid=uuids.instance,
operation='foo'),
exception.OperationNotSupportedForVDPAInterface(
instance_uuid=uuids.instance, operation='foo'),
)
@mock.patch.object(compute.api.API, 'rescue')
def test_rescue_raise_badrequest_for_not_supported_features(
self, exc, mock_rescue):
"""Test that exceptions are translated into HTTP BadRequest errors."""
mock_rescue.side_effect = exc
body = {"rescue": {"adminPass": "******"}}
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
self.assertTrue(mock_rescue.called)
def test_rescue_with_preset_password(self):
body = {"rescue": {"adminPass": "******"}}
resp = self.controller._rescue(self.fake_req, UUID, body=body)
self.assertEqual("AABBCC112233", resp['adminPass'])
def test_rescue_generates_password(self):
body = dict(rescue=None)
resp = self.controller._rescue(self.fake_req, UUID, body=body)
self.assertEqual(CONF.password_length, len(resp['adminPass']))
@mock.patch.object(compute.api.API, "rescue")
def test_rescue_of_rescued_instance(self, mock_rescue):
mock_rescue.side_effect = exception.InstanceInvalidState(
'fake message')
body = dict(rescue=None)
self.assertRaises(webob.exc.HTTPConflict,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
self.assertTrue(mock_rescue.called)
def test_unrescue(self):
body = dict(unrescue=None)
resp = self.controller._unrescue(self.fake_req, UUID, body=body)
# NOTE: on v2.1, http status code is set as wsgi_code of API
# method instead of status_int in a response object.
if isinstance(self.controller, rescue_v21.RescueController):
status_int = self.controller._unrescue.wsgi_code
else:
status_int = resp.status_int
self.assertEqual(202, status_int)
@mock.patch.object(compute.api.API, "unrescue")
def test_unrescue_from_locked_server(self, mock_unrescue):
mock_unrescue.side_effect = exception.InstanceIsLocked(
instance_uuid=UUID)
body = dict(unrescue=None)
self.assertRaises(webob.exc.HTTPConflict,
self.controller._unrescue,
self.fake_req,
UUID,
body=body)
self.assertTrue(mock_unrescue.called)
@mock.patch.object(compute.api.API, "unrescue")
def test_unrescue_of_active_instance(self, mock_unrescue):
mock_unrescue.side_effect = exception.InstanceInvalidState(
'fake message')
body = dict(unrescue=None)
self.assertRaises(webob.exc.HTTPConflict,
self.controller._unrescue,
self.fake_req,
UUID,
body=body)
self.assertTrue(mock_unrescue.called)
@mock.patch.object(compute.api.API, "rescue")
def test_rescue_raises_unrescuable(self, mock_rescue):
mock_rescue.side_effect = exception.InstanceNotRescuable(
'fake message')
body = dict(rescue=None)
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
self.assertTrue(mock_rescue.called)
@mock.patch.object(
compute.api.API,
"rescue",
side_effect=exception.UnsupportedRescueImage(image='fake'))
def test_rescue_raises_unsupported_image(self, mock_rescue):
body = dict(rescue=None)
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
self.assertTrue(mock_rescue.called)
def test_rescue_with_bad_image_specified(self):
body = {
"rescue": {
"adminPass": "******",
"rescue_image_ref": "img-id"
}
}
self.assertRaises(exception.ValidationError,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
def test_rescue_with_imageRef_as_full_url(self):
image_href = ('http://localhost/v2/fake/images/'
'76fa36fc-c930-4bf3-8c8a-ea2a2420deb6')
body = {
"rescue": {
"adminPass": "******",
"rescue_image_ref": image_href
}
}
self.assertRaises(exception.ValidationError,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
def test_rescue_with_imageRef_as_empty_string(self):
body = {"rescue": {"adminPass": "******", "rescue_image_ref": ''}}
self.assertRaises(exception.ValidationError,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
@mock.patch('nova.compute.api.API.rescue')
@mock.patch('nova.api.openstack.common.get_instance')
def test_rescue_with_image_specified(self, get_instance_mock,
mock_compute_api_rescue):
instance = fake_instance.fake_instance_obj(
self.fake_req.environ['nova.context'])
get_instance_mock.return_value = instance
body = {
"rescue": {
"adminPass": "******",
"rescue_image_ref": self.image_uuid
}
}
resp_json = self.controller._rescue(self.fake_req, UUID, body=body)
self.assertEqual("ABC123", resp_json['adminPass'])
mock_compute_api_rescue.assert_called_with(
mock.ANY,
instance,
rescue_password=u'ABC123',
rescue_image_ref=self.image_uuid,
allow_bfv_rescue=self._allow_bfv_rescue())
@mock.patch('nova.compute.api.API.rescue')
@mock.patch('nova.api.openstack.common.get_instance')
def test_rescue_without_image_specified(self, get_instance_mock,
mock_compute_api_rescue):
instance = fake_instance.fake_instance_obj(
self.fake_req.environ['nova.context'])
get_instance_mock.return_value = instance
body = {"rescue": {"adminPass": "******"}}
resp_json = self.controller._rescue(self.fake_req, UUID, body=body)
self.assertEqual("ABC123", resp_json['adminPass'])
mock_compute_api_rescue.assert_called_with(
mock.ANY,
instance,
rescue_password=u'ABC123',
rescue_image_ref=None,
allow_bfv_rescue=self._allow_bfv_rescue())
def test_rescue_with_none(self):
body = dict(rescue=None)
resp = self.controller._rescue(self.fake_req, UUID, body=body)
self.assertEqual(CONF.password_length, len(resp['adminPass']))
def test_rescue_with_empty_dict(self):
body = dict(rescue=dict())
resp = self.controller._rescue(self.fake_req, UUID, body=body)
self.assertEqual(CONF.password_length, len(resp['adminPass']))
def test_rescue_disable_password(self):
self.flags(enable_instance_password=False, group='api')
body = dict(rescue=None)
resp_json = self.controller._rescue(self.fake_req, UUID, body=body)
self.assertNotIn('adminPass', resp_json)
def test_rescue_with_invalid_property(self):
body = {"rescue": {"test": "test"}}
self.assertRaises(exception.ValidationError,
self.controller._rescue,
self.fake_req,
UUID,
body=body)
class ServerStartStopTestV21(test.TestCase):
def setUp(self):
super(ServerStartStopTestV21, self).setUp()
self._setup_controller()
self.req = fakes.HTTPRequest.blank('')
self.useFixture(nova_fixtures.SingleCellSimple())
self.stub_out('nova.db.instance_get_by_uuid',
fakes.fake_instance_get())
def _setup_controller(self):
ext_info = extension_info.LoadedExtensionInfo()
self.controller = server_v21.ServersController(extension_info=ext_info)
@mock.patch.object(compute_api.API, 'start')
def test_start(self, start_mock):
body = dict(start="")
self.controller._start_server(self.req, uuids.instance, body)
start_mock.assert_called_once_with(mock.ANY, mock.ANY)
@mock.patch.object(
compute_api.API,
'start',
side_effect=exception.InstanceNotReady(instance_id=uuids.instance))
def test_start_not_ready(self, start_mock):
body = dict(start="")
self.assertRaises(webob.exc.HTTPConflict,
self.controller._start_server, self.req,
uuids.instance, body)
@mock.patch.object(
compute_api.API,
'start',
side_effect=exception.InstanceIsLocked(instance_uuid=uuids.instance))
def test_start_locked_server(self, start_mock):
body = dict(start="")
self.assertRaises(webob.exc.HTTPConflict,
self.controller._start_server, self.req,
uuids.instance, body)
@mock.patch.object(
compute_api.API,
'start',
side_effect=exception.InstanceIsLocked(instance_uuid=uuids.instance))
def test_start_invalid_state(self, start_mock):
body = dict(start="")
ex = self.assertRaises(webob.exc.HTTPConflict,
self.controller._start_server, self.req,
uuids.instance, body)
self.assertIn('is locked', six.text_type(ex))
@mock.patch.object(compute_api.API, 'stop')
def test_stop(self, stop_mock):
body = dict(stop="")
self.controller._stop_server(self.req, uuids.instance, body)
stop_mock.assert_called_once_with(mock.ANY, mock.ANY)
@mock.patch.object(
compute_api.API,
'stop',
side_effect=exception.InstanceNotReady(instance_id=uuids.instance))
def test_stop_not_ready(self, stop_mock):
body = dict(stop="")
self.assertRaises(webob.exc.HTTPConflict, self.controller._stop_server,
self.req, uuids.instance, body)
@mock.patch.object(
compute_api.API,
'stop',
side_effect=exception.InstanceIsLocked(instance_uuid=uuids.instance))
def test_stop_locked_server(self, stop_mock):
body = dict(stop="")
ex = self.assertRaises(webob.exc.HTTPConflict,
self.controller._stop_server, self.req,
uuids.instance, body)
self.assertIn('is locked', six.text_type(ex))
@mock.patch.object(
compute_api.API,
'stop',
side_effect=exception.InstanceIsLocked(instance_uuid=uuids.instance))
def test_stop_invalid_state(self, stop_mock):
body = dict(start="")
self.assertRaises(webob.exc.HTTPConflict, self.controller._stop_server,
self.req, uuids.instance, body)
@mock.patch.object(
db,
'instance_get_by_uuid',
side_effect=exception.InstanceNotFound(instance_id=uuids.instance))
def test_start_with_bogus_id(self, get_mock):
body = dict(start="")
self.assertRaises(webob.exc.HTTPNotFound,
self.controller._start_server, self.req,
uuids.instance, body)
@mock.patch.object(
db,
'instance_get_by_uuid',
side_effect=exception.InstanceNotFound(instance_id=uuids.instance))
def test_stop_with_bogus_id(self, get_mock):
body = dict(stop="")
self.assertRaises(webob.exc.HTTPNotFound, self.controller._stop_server,
self.req, uuids.instance, body)
class ShelveControllerTest(test.NoDBTestCase):
plugin = shelve_v21
def setUp(self):
super().setUp()
self.controller = self.plugin.ShelveController()
self.req = fakes.HTTPRequest.blank('')
@ddt.data(
exception.InstanceIsLocked(instance_uuid=uuids.instance),
exception.UnexpectedTaskStateError(instance_uuid=uuids.instance,
expected=None,
actual=task_states.SHELVING),
)
@mock.patch('nova.compute.api.API.shelve')
@mock.patch('nova.api.openstack.common.get_instance')
def test_shelve__http_conflict_error(
self,
exc,
mock_get_instance,
mock_shelve,
):
mock_get_instance.return_value = (fake_instance.fake_instance_obj(
self.req.environ['nova.context']))
mock_shelve.side_effect = exc
self.assertRaises(webob.exc.HTTPConflict, self.controller._shelve,
self.req, uuids.fake, {})
@ddt.data(
exception.ForbiddenWithAccelerators(),
exception.OperationNotSupportedForVTPM(instance_uuid=uuids.instance,
operation='foo'),
exception.OperationNotSupportedForVDPAInterface(
instance_uuid=uuids.instance, operation='foo'),
)
@mock.patch('nova.compute.api.API.shelve')
@mock.patch('nova.api.openstack.common.get_instance')
def test_shelve_raise_badrequest_for_not_supported_feature(
self,
exc,
mock_get_instance,
mock_shelve,
):
mock_get_instance.return_value = (fake_instance.fake_instance_obj(
self.req.environ['nova.context']))
mock_shelve.side_effect = exc
self.assertRaises(webob.exc.HTTPBadRequest, self.controller._shelve,
self.req, uuids.fake, {})
@mock.patch('nova.api.openstack.common.get_instance')
def test_unshelve_locked_server(self, get_instance_mock):
get_instance_mock.return_value = (fake_instance.fake_instance_obj(
self.req.environ['nova.context']))
self.stub_out('nova.compute.api.API.unshelve',
fakes.fake_actions_to_locked_server)
self.assertRaises(webob.exc.HTTPConflict,
self.controller._unshelve,
self.req,
uuids.fake,
body={'unshelve': {}})
@mock.patch('nova.api.openstack.common.get_instance')
def test_shelve_offload_locked_server(self, get_instance_mock):
get_instance_mock.return_value = (fake_instance.fake_instance_obj(
self.req.environ['nova.context']))
self.stub_out('nova.compute.api.API.shelve_offload',
fakes.fake_actions_to_locked_server)
self.assertRaises(webob.exc.HTTPConflict,
self.controller._shelve_offload, self.req,
uuids.fake, {})
def fake_attach_volume_to_locked_server(self,
context,
instance,
volume_id,
device=None):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
def fake_start_stop_locked_server(self, context, instance):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
def fake_compute_api_raises_instance_is_locked(*args, **kwargs):
raise exception.InstanceIsLocked(instance_uuid='')
def fake_start_stop_invalid_state(self, context, instance):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
def fake_swap_volume_for_locked_server(self, context, instance,
old_volume, new_volume):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
def test_force_complete_instance_is_locked(self):
self._test_force_complete_failed_with_exception(
exception.InstanceIsLocked(instance_uuid=''),
webob.exc.HTTPConflict)
def fake_rescue_from_locked_server(self,
context,
instance,
rescue_password=None,
rescue_image_ref=None):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
class BadStateServerMetaDataTest(BaseTest):
def setUp(self):
super(BadStateServerMetaDataTest, self).setUp()
self.stubs.Set(nova.db, 'instance_get', self._return_server_in_build)
self.stubs.Set(nova.db, 'instance_get_by_uuid',
self._return_server_in_build_by_uuid)
self.stubs.Set(nova.db, 'instance_metadata_delete',
delete_server_metadata)
def test_invalid_state_on_delete(self):
req = fakes.HTTPRequestV3.blank(self.url + '/key2')
req.method = 'DELETE'
self.assertRaises(webob.exc.HTTPConflict, self.controller.delete, req,
self.uuid, 'key2')
def test_invalid_state_on_update_metadata(self):
self.stubs.Set(nova.db, 'instance_metadata_update',
return_create_instance_metadata)
req = fakes.HTTPRequestV3.blank(self.url)
req.method = 'POST'
req.content_type = 'application/json'
expected = {
'metadata': {
'key1': 'updatedvalue',
'key29': 'newkey',
}
}
req.body = jsonutils.dumps(expected)
self.assertRaises(webob.exc.HTTPConflict, self.controller.update_all,
req, self.uuid, expected)
def _return_server_in_build(self,
context,
server_id,
columns_to_join=None):
return fake_instance.fake_db_instance(
**{
'id': server_id,
'uuid': '0cc3346e-9fef-4445-abe6-5d2b2690ec64',
'name': 'fake',
'locked': False,
'vm_state': vm_states.BUILDING
})
def _return_server_in_build_by_uuid(self,
context,
server_uuid,
columns_to_join=None,
use_slave=False):
return fake_instance.fake_db_instance(
**{
'id': 1,
'uuid': '0cc3346e-9fef-4445-abe6-5d2b2690ec64',
'name': 'fake',
'locked': False,
'vm_state': vm_states.BUILDING
})
@mock.patch.object(nova.compute.api.API,
'update_instance_metadata',
side_effect=exception.InstanceIsLocked(instance_uuid=0))
def test_instance_lock_update_metadata(self, mock_update):
req = fakes.HTTPRequest.blank(self.url)
req.method = 'POST'
req.content_type = 'application/json'
expected = {'metadata': {'keydummy': 'newkey'}}
req.body = jsonutils.dumps(expected)
self.assertRaises(webob.exc.HTTPConflict, self.controller.update_all,
req, self.uuid, expected)
def fake_detach_volume_from_locked_server(self, context,
instance, volume):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
class DeferredDeleteExtensionTestV21(test.NoDBTestCase):
ext_ver = dd_v21.DeferredDeleteController
def setUp(self):
super(DeferredDeleteExtensionTestV21, self).setUp()
self.fake_input_dict = {}
self.fake_uuid = 'fake_uuid'
self.fake_context = context.RequestContext('fake', 'fake')
self.fake_req = FakeRequest(self.fake_context)
self.extension = self.ext_ver()
def test_force_delete(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
self.mox.StubOutWithMock(compute_api.API, 'force_delete')
fake_instance = 'fake_instance'
compute_api.API.get(self.fake_context,
self.fake_uuid,
expected_attrs=None,
want_objects=True).AndReturn(fake_instance)
compute_api.API.force_delete(self.fake_context, fake_instance)
self.mox.ReplayAll()
res = self.extension._force_delete(self.fake_req, self.fake_uuid,
self.fake_input_dict)
self.assertEqual(res.status_int, 202)
def test_force_delete_instance_not_found(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
compute_api.API.get(
self.fake_context,
self.fake_uuid,
expected_attrs=None,
want_objects=True).AndRaise(
exception.InstanceNotFound(instance_id='instance-0000'))
self.mox.ReplayAll()
self.assertRaises(webob.exc.HTTPNotFound, self.extension._force_delete,
self.fake_req, self.fake_uuid, self.fake_input_dict)
@mock.patch.object(compute_api.API, 'get')
@mock.patch.object(
compute_api.API,
'force_delete',
side_effect=exception.InstanceIsLocked(instance_uuid='fake_uuid'))
def test_force_delete_instance_locked(self, mock_force_delete, mock_get):
req = fakes.HTTPRequestV3.blank('/servers/fake_uuid/action')
ex = self.assertRaises(webob.exc.HTTPConflict,
self.extension._force_delete, req, 'fake_uuid',
'')
self.assertIn('Instance fake_uuid is locked', ex.explanation)
def test_restore(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
self.mox.StubOutWithMock(compute_api.API, 'restore')
fake_instance = 'fake_instance'
compute_api.API.get(self.fake_context,
self.fake_uuid,
expected_attrs=None,
want_objects=True).AndReturn(fake_instance)
compute_api.API.restore(self.fake_context, fake_instance)
self.mox.ReplayAll()
res = self.extension._restore(self.fake_req, self.fake_uuid,
self.fake_input_dict)
self.assertEqual(res.status_int, 202)
def test_restore_instance_not_found(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
compute_api.API.get(
self.fake_context,
self.fake_uuid,
expected_attrs=None,
want_objects=True).AndRaise(
exception.InstanceNotFound(instance_id='instance-0000'))
self.mox.ReplayAll()
self.assertRaises(webob.exc.HTTPNotFound, self.extension._restore,
self.fake_req, self.fake_uuid, self.fake_input_dict)
def test_restore_raises_conflict_on_invalid_state(self):
self.mox.StubOutWithMock(compute_api.API, 'get')
self.mox.StubOutWithMock(compute_api.API, 'restore')
fake_instance = 'fake_instance'
exc = exception.InstanceInvalidState(attr='fake_attr',
state='fake_state',
method='fake_method',
instance_uuid='fake')
compute_api.API.get(self.fake_context,
self.fake_uuid,
expected_attrs=None,
want_objects=True).AndReturn(fake_instance)
compute_api.API.restore(self.fake_context, fake_instance).AndRaise(exc)
self.mox.ReplayAll()
self.assertRaises(webob.exc.HTTPConflict, self.extension._restore,
self.fake_req, self.fake_uuid, self.fake_input_dict)
