def fake_start_stop_not_ready(self, context, instance):
raise exception.InstanceNotReady(instance_id=instance["uuid"])
def test_get_spice_console_not_ready(self):
body = {'os-getSPICEConsole': {'type': 'spice-html5'}}
self._check_console_failure(
self.controller.get_spice_console, webob.exc.HTTPConflict, body,
'get_spice_console',
exception.InstanceNotReady(instance_id=fakes.FAKE_UUID))
def fake_get_console_output_not_ready(self, _context, _instance, tail_length):
raise exception.InstanceNotReady(instance_id=_instance["uuid"])
def fake_get_rdp_console_not_ready(self, _context, instance, _console_type):
raise exception.InstanceNotReady(instance_id=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)
def test_assisted_delete_instance_not_ready(self):
api_error = exception.InstanceNotReady(instance_id=FAKE_UUID)
self._test_assisted_delete_instance_conflict(api_error)
def test_get_diagnostics_raise_instance_not_ready(self):
req = self._get_request()
with mock.patch.object(compute_api.API, self.mock_diagnostics_method,
side_effect=exception.InstanceNotReady('fake message')):
res = req.get_response(self.router)
self.assertEqual(409, res.status_int)
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 ServerDiagnosticsTestV21(test.NoDBTestCase):
def _setup_router(self):
self.router = compute.APIRouterV21(init_only=('servers',
'os-server-diagnostics'))
def _get_request(self):
return fakes.HTTPRequest.blank('/fake/servers/%s/diagnostics' % UUID)
def setUp(self):
super(ServerDiagnosticsTestV21, self).setUp()
self._setup_router()
@mock.patch.object(compute_api.API, 'get_diagnostics',
fake_get_diagnostics)
@mock.patch.object(compute_api.API, 'get', fake_instance_get)
def test_get_diagnostics(self):
req = self._get_request()
res = req.get_response(self.router)
output = jsonutils.loads(res.body)
self.assertEqual(output, {'data': 'Some diagnostic info'})
@mock.patch.object(compute_api.API, 'get_diagnostics',
fake_get_diagnostics)
@mock.patch.object(compute_api.API,
'get',
side_effect=exception.InstanceNotFound(instance_id=UUID)
)
def test_get_diagnostics_with_non_existed_instance(self, mock_get):
req = self._get_request()
res = req.get_response(self.router)
self.assertEqual(res.status_int, 404)
@mock.patch.object(
compute_api.API,
'get_diagnostics',
side_effect=exception.InstanceInvalidState('fake message'))
@mock.patch.object(compute_api.API, 'get', fake_instance_get)
def test_get_diagnostics_raise_conflict_on_invalid_state(
self, mock_get_diagnostics):
req = self._get_request()
res = req.get_response(self.router)
self.assertEqual(409, res.status_int)
@mock.patch.object(compute_api.API,
'get_diagnostics',
side_effect=exception.InstanceNotReady('fake message'))
@mock.patch.object(compute_api.API, 'get', fake_instance_get)
def test_get_diagnostics_raise_instance_not_ready(self,
mock_get_diagnostics):
req = self._get_request()
res = req.get_response(self.router)
self.assertEqual(409, res.status_int)
@mock.patch.object(compute_api.API,
'get_diagnostics',
side_effect=NotImplementedError)
@mock.patch.object(compute_api.API, 'get', fake_instance_get)
def test_get_diagnostics_raise_no_notimplementederror(
self, mock_get_diagnostics):
req = self._get_request()
res = req.get_response(self.router)
self.assertEqual(501, res.status_int)
