openstack/nova
Code Issues Proposed changes

Merge "Remove mox used in tests/unit/api/openstack/compute/test_server_start_stop"

Browse Source
This commit is contained in:
Jenkins
2016-05-23 15:38:03 +00:00
committed by Gerrit Code Review
parent e44afa527a 56ac441855
commit 50d1e3ae25
1 changed files with 42 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
nova/tests/unit/api/openstack/compute/test_server_start_stop.py
View File

@@ -12,7 +12,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from mox3 import mox
import mock
import six
import webob
@@ -22,6 +22,7 @@ from nova.api.openstack.compute import extension_info
from nova.api.openstack.compute import servers \
as server_v21
from nova.compute import api as compute_api
from nova import db
from nova import exception
from nova import policy
from nova import test
@@ -29,30 +30,6 @@ from nova.tests.unit.api.openstack import fakes
from nova.tests import uuidsentinel as uuids
def fake_instance_get(context, instance_id,
columns_to_join=None, use_slave=False):
result = fakes.stub_instance(id=1, uuid=instance_id)
result['created_at'] = None
result['deleted_at'] = None
result['updated_at'] = None
result['deleted'] = 0
result['info_cache'] = {'network_info': '[]',
'instance_uuid': result['uuid']}
return result
def fake_start_stop_not_ready(self, context, instance):
raise exception.InstanceNotReady(instance_id=instance["uuid"])
def fake_start_stop_locked_server(self, context, instance):
raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
def fake_start_stop_invalid_state(self, context, instance):
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"
@@ -61,104 +38,110 @@ class ServerStartStopTestV21(test.TestCase):
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)
def test_start(self):
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
self.mox.StubOutWithMock(compute_api.API, 'start')
compute_api.API.start(mox.IgnoreArg(), mox.IgnoreArg())
self.mox.ReplayAll()
@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))
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
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())
def test_start_not_ready(self):
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
self.stubs.Set(compute_api.API, 'start', fake_start_stop_not_ready)
@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)
def test_start_locked_server(self):
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
self.stubs.Set(compute_api.API, 'start', fake_start_stop_locked_server)
@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)
def test_start_invalid_state(self):
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
self.stubs.Set(compute_api.API, 'start', fake_start_stop_invalid_state)
@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))
def test_stop(self):
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
self.mox.StubOutWithMock(compute_api.API, 'stop')
compute_api.API.stop(mox.IgnoreArg(), mox.IgnoreArg())
self.mox.ReplayAll()
@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))
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
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())
def test_stop_not_ready(self):
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
self.stubs.Set(compute_api.API, 'stop', fake_start_stop_not_ready)
@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)
def test_stop_locked_server(self):
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
self.stubs.Set(compute_api.API, 'stop', fake_start_stop_locked_server)
@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))
def test_stop_invalid_state(self):
self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get)
self.stubs.Set(compute_api.API, 'stop', fake_start_stop_invalid_state)
@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)
def test_start_with_bogus_id(self):
@mock.patch.object(db, 'instance_get_by_uuid',
side_effect=exception.InstanceNotFound(
instance_uuid=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)
def test_stop_with_bogus_id(self):
@mock.patch.object(db, 'instance_get_by_uuid',
side_effect=exception.InstanceNotFound(
instance_uuid=uuids.InstanceNotFound))
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)