Merge "Change v3 shelve to v2.1"

doc/v3/api_samples/os-shelve/os-shelve-offload.json

@@ -1,3 +1,3 @@
 {
-    "shelve_offload": null
+    "shelveOffload": null
 }

nova/api/openstack/compute/plugins/v3/shelve.py

@@ -56,7 +56,7 @@ class ShelveController(wsgi.Controller):
         return webob.Response(status_int=202)
 
     @exts.expected_errors((404, 409))
-    @wsgi.action('shelve_offload')
+    @wsgi.action('shelveOffload')
     def _shelve_offload(self, req, id, body):
         """Force removal of a shelved instance from the compute node."""
         context = req.environ["nova.context"]
@@ -70,7 +70,7 @@ class ShelveController(wsgi.Controller):
             raise exc.HTTPConflict(explanation=e.format_message())
         except exception.InstanceInvalidState as state_error:
             common.raise_http_conflict_for_instance_invalid_state(state_error,
-                                                              'shelve_offload')
+                                                              'shelveOffload')
 
         return webob.Response(status_int=202)
 

nova/tests/api/openstack/compute/contrib/test_shelve.py

@@ -16,7 +16,8 @@ import uuid
 
 import webob
 
-from nova.api.openstack.compute.contrib import shelve
+from nova.api.openstack.compute.contrib import shelve as shelve_v2
+from nova.api.openstack.compute.plugins.v3 import shelve as shelve_v21
 from nova.compute import api as compute_api
 from nova import db
 from nova import exception
@@ -37,94 +38,111 @@ def fake_auth_context(context):
     return True
 
 
-class ShelvePolicyTest(test.NoDBTestCase):
+class ShelvePolicyTestV21(test.NoDBTestCase):
+    plugin = shelve_v21
+    prefix = 'v3:os-shelve:'
+    offload = 'shelve_offload'
+
     def setUp(self):
-        super(ShelvePolicyTest, self).setUp()
+        super(ShelvePolicyTestV21, self).setUp()
-        self.controller = shelve.ShelveController()
+        self.controller = self.plugin.ShelveController()
+
+    def _fake_request(self):
+        return fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
 
     def test_shelve_restricted_by_role(self):
-        rules = {'compute_extension:shelve':
+        rules = {'compute_extension:%sshelve' % self.prefix:
                      common_policy.parse_rule('role:admin')}
         policy.set_rules(rules)
 
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(exception.Forbidden, self.controller._shelve,
                 req, str(uuid.uuid4()), {})
 
     def test_shelve_allowed(self):
         rules = {'compute:get': common_policy.parse_rule(''),
-                 'compute_extension:shelve':
+                 'compute_extension:%sshelve' % self.prefix:
                      common_policy.parse_rule('')}
         policy.set_rules(rules)
 
         self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(exception.Forbidden, self.controller._shelve,
                 req, str(uuid.uuid4()), {})
 
     def test_shelve_locked_server(self):
         self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        self.stubs.Set(shelve, 'auth_shelve', fake_auth_context)
+        self.stubs.Set(self.plugin, 'auth_shelve', fake_auth_context)
         self.stubs.Set(compute_api.API, 'shelve',
                        fakes.fake_actions_to_locked_server)
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(webob.exc.HTTPConflict, self.controller._shelve,
                           req, str(uuid.uuid4()), {})
 
     def test_unshelve_restricted_by_role(self):
-        rules = {'compute_extension:unshelve':
+        rules = {'compute_extension:%sunshelve' % self.prefix:
                      common_policy.parse_rule('role:admin')}
         policy.set_rules(rules)
 
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(exception.Forbidden, self.controller._unshelve,
                 req, str(uuid.uuid4()), {})
 
     def test_unshelve_allowed(self):
         rules = {'compute:get': common_policy.parse_rule(''),
-                 'compute_extension:unshelve': common_policy.parse_rule('')}
+                 'compute_extension:%sunshelve' % self.prefix:
+                 common_policy.parse_rule('')}
         policy.set_rules(rules)
 
         self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(exception.Forbidden, self.controller._unshelve,
                 req, str(uuid.uuid4()), {})
 
     def test_unshelve_locked_server(self):
         self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        self.stubs.Set(shelve, 'auth_unshelve', fake_auth_context)
+        self.stubs.Set(self.plugin, 'auth_unshelve', fake_auth_context)
         self.stubs.Set(compute_api.API, 'unshelve',
                        fakes.fake_actions_to_locked_server)
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(webob.exc.HTTPConflict, self.controller._unshelve,
                           req, str(uuid.uuid4()), {})
 
     def test_shelve_offload_restricted_by_role(self):
-        rules = {'compute_extension:shelveOffload':
+        rules = {'compute_extension:%s%s' % (self.prefix, self.offload):
                   common_policy.parse_rule('role:admin')}
         policy.set_rules(rules)
 
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(exception.Forbidden,
                 self.controller._shelve_offload, req, str(uuid.uuid4()), {})
 
     def test_shelve_offload_allowed(self):
         rules = {'compute:get': common_policy.parse_rule(''),
-                 'compute_extension:shelveOffload':
+                 'compute_extension:%s%s' % (self.prefix, self.offload):
                      common_policy.parse_rule('')}
         policy.set_rules(rules)
 
         self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(exception.Forbidden,
                 self.controller._shelve_offload, req, str(uuid.uuid4()), {})
 
     def test_shelve_offload_locked_server(self):
         self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        self.stubs.Set(shelve, 'auth_shelve_offload', fake_auth_context)
+        self.stubs.Set(self.plugin, 'auth_shelve_offload', fake_auth_context)
         self.stubs.Set(compute_api.API, 'shelve_offload',
                        fakes.fake_actions_to_locked_server)
-        req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
+        req = self._fake_request()
         self.assertRaises(webob.exc.HTTPConflict,
                           self.controller._shelve_offload,
                           req, str(uuid.uuid4()), {})
+
+
+class ShelvePolicyTestV2(ShelvePolicyTestV21):
+    plugin = shelve_v2
+    prefix = ''
+    offload = 'shelveOffload'
+
+    def _fake_request(self):
+        return fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')

nova/tests/api/openstack/compute/plugins/v3/test_shelve.py

@@ -1,131 +0,0 @@
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import uuid
-
-import webob
-
-from nova.api.openstack.compute.plugins.v3 import shelve
-from nova.compute import api as compute_api
-from nova import db
-from nova import exception
-from nova.openstack.common import policy as common_policy
-from nova import policy
-from nova import test
-from nova.tests.api.openstack import fakes
-from nova.tests import fake_instance
-
-
-def fake_instance_get_by_uuid(context, instance_id,
-                              columns_to_join=None, use_slave=False):
-    return fake_instance.fake_db_instance(
-        **{'name': 'fake', 'project_id': '%s_unequal' % context.project_id})
-
-
-def fake_auth_context(context):
-    return True
-
-
-class ShelvePolicyTest(test.NoDBTestCase):
-    def setUp(self):
-        super(ShelvePolicyTest, self).setUp()
-        self.controller = shelve.ShelveController()
-
-    def test_shelve_restricted_by_role(self):
-        rules = {'compute_extension:v3:os-shelve:shelve':
-                     common_policy.parse_rule('role:admin')}
-        policy.set_rules(rules)
-
-        req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
-        self.assertRaises(exception.Forbidden, self.controller._shelve,
-                req, str(uuid.uuid4()), {})
-
-    def test_shelve_allowed(self):
-        rules = {'compute:get': common_policy.parse_rule(''),
-                 'compute_extension:v3:os-shelve:shelve':
-                     common_policy.parse_rule('')}
-        policy.set_rules(rules)
-
-        self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
-        self.assertRaises(exception.Forbidden, self.controller._shelve,
-                req, str(uuid.uuid4()), {})
-
-    def test_shelve_locked_server(self):
-        self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        self.stubs.Set(shelve, 'auth_shelve', fake_auth_context)
-        self.stubs.Set(compute_api.API, 'shelve',
-                       fakes.fake_actions_to_locked_server)
-        req = fakes.HTTPRequestV3.blank('/123/servers/12/os-shelve')
-        self.assertRaises(webob.exc.HTTPConflict, self.controller._shelve,
-                          req, str(uuid.uuid4()), {})
-
-    def test_unshelve_restricted_by_role(self):
-        rules = {'compute_extension:v3:os-shelve:unshelve':
-                     common_policy.parse_rule('role:admin')}
-        policy.set_rules(rules)
-
-        req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
-        self.assertRaises(exception.Forbidden, self.controller._unshelve,
-                req, str(uuid.uuid4()), {})
-
-    def test_unshelve_allowed(self):
-        rules = {'compute:get': common_policy.parse_rule(''),
-                 'compute_extension:v3:os-shelve:unshelve':
-                     common_policy.parse_rule('')}
-        policy.set_rules(rules)
-
-        self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
-        self.assertRaises(exception.Forbidden, self.controller._unshelve,
-                req, str(uuid.uuid4()), {})
-
-    def test_unshelve_locked_server(self):
-        self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        self.stubs.Set(shelve, 'auth_unshelve', fake_auth_context)
-        self.stubs.Set(compute_api.API, 'unshelve',
-                       fakes.fake_actions_to_locked_server)
-        req = fakes.HTTPRequestV3.blank('/123/servers/12/os-shelve')
-        self.assertRaises(webob.exc.HTTPConflict, self.controller._unshelve,
-                          req, str(uuid.uuid4()), {})
-
-    def test_shelve_offload_restricted_by_role(self):
-        rules = {'compute_extension:v3:os-shelve:shelve_offload':
-                     common_policy.parse_rule('role:admin')}
-        policy.set_rules(rules)
-
-        req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
-        self.assertRaises(exception.Forbidden,
-                self.controller._shelve_offload, req, str(uuid.uuid4()), {})
-
-    def test_shelve_offload_allowed(self):
-        rules = {'compute:get': common_policy.parse_rule(''),
-                 'compute_extension:v3:shelve_offload':
-                     common_policy.parse_rule('')}
-        policy.set_rules(rules)
-
-        self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
-        self.assertRaises(exception.Forbidden,
-                self.controller._shelve_offload, req, str(uuid.uuid4()), {})
-
-    def test_shelve_offload_locked_server(self):
-        self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
-        self.stubs.Set(shelve, 'auth_shelve_offload', fake_auth_context)
-        self.stubs.Set(compute_api.API, 'shelve_offload',
-                       fakes.fake_actions_to_locked_server)
-        req = fakes.HTTPRequestV3.blank('/123/servers/12/os-shelve')
-        self.assertRaises(webob.exc.HTTPConflict,
-                          self.controller._shelve_offload,
-                          req, str(uuid.uuid4()), {})

nova/tests/integrated/v3/test_shelve.py

@@ -42,7 +42,7 @@ class ShelveJsonTest(test_servers.ServersSampleBase):
     def test_shelve_offload(self):
         uuid = self._post_server()
         self._test_server_action(uuid, 'os-shelve', 'shelve')
-        self._test_server_action(uuid, 'os-shelve-offload', 'shelve_offload')
+        self._test_server_action(uuid, 'os-shelve-offload', 'shelveOffload')
 
     def test_unshelve(self):
         uuid = self._post_server()