Completes coverage of quantum.api.v2.resource

Moved current resource testcases to new test script
Created test cases

Fixes bug #1085456

Change-Id: I9ff5ba6a44c32ba4cf04b6a75ea7fd30fc769d2c

quantum/tests/unit/test_api_v2.py

@@ -25,7 +25,6 @@
 from quantum.api.extensions import PluginAwareExtensionManager
 from quantum.api.v2 import attributes
 from quantum.api.v2 import base
-from quantum.api.v2 import resource as wsgi_resource
 from quantum.api.v2 import router
 from quantum.common import config
 from quantum.common import exceptions as q_exc
@@ -64,50 +63,6 @@ def _get_path(resource, id=None, action=None, fmt=None):
     return path
 
 
-class V2WsgiResourceTestCase(unittest.TestCase):
-    def test_unmapped_quantum_error(self):
-        controller = mock.MagicMock()
-        controller.test.side_effect = q_exc.QuantumException()
-
-        resource = webtest.TestApp(wsgi_resource.Resource(controller))
-
-        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
-        res = resource.get('', extra_environ=environ, expect_errors=True)
-        self.assertEqual(res.status_int, exc.HTTPInternalServerError.code)
-
-    def test_mapped_quantum_error(self):
-        controller = mock.MagicMock()
-        controller.test.side_effect = q_exc.QuantumException()
-
-        faults = {q_exc.QuantumException: exc.HTTPGatewayTimeout}
-        resource = webtest.TestApp(wsgi_resource.Resource(controller,
-                                                          faults=faults))
-
-        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
-        res = resource.get('', extra_environ=environ, expect_errors=True)
-        self.assertEqual(res.status_int, exc.HTTPGatewayTimeout.code)
-
-    def test_http_error(self):
-        controller = mock.MagicMock()
-        controller.test.side_effect = exc.HTTPGatewayTimeout()
-
-        resource = webtest.TestApp(wsgi_resource.Resource(controller))
-
-        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
-        res = resource.get('', extra_environ=environ, expect_errors=True)
-        self.assertEqual(res.status_int, exc.HTTPGatewayTimeout.code)
-
-    def test_unhandled_error(self):
-        controller = mock.MagicMock()
-        controller.test.side_effect = Exception()
-
-        resource = webtest.TestApp(wsgi_resource.Resource(controller))
-
-        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
-        res = resource.get('', extra_environ=environ, expect_errors=True)
-        self.assertEqual(res.status_int, exc.HTTPInternalServerError.code)
-
-
 class ResourceIndexTestCase(unittest.TestCase):
     def test_index_json(self):
         index = webtest.TestApp(router.Index({'foo': 'bar'}))

quantum/tests/unit/test_api_v2_resource.py

@@ -0,0 +1,130 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2012 Intel Corporation.
+# 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.
+#
+# @author: Zhongyue Luo, Intel Corporation.
+#
+
+import unittest2 as unittest
+
+import mock
+from webob import exc
+import webtest
+
+from quantum.api.v2 import resource as wsgi_resource
+from quantum.common import exceptions as q_exc
+from quantum import context
+
+
+class RequestTestCase(unittest.TestCase):
+    def setUp(self):
+        self.req = wsgi_resource.Request({'foo': 'bar'})
+
+    def test_best_match_content_type(self):
+        self.assertEqual(self.req.best_match_content_type(),
+                         'application/json')
+
+    def test_context_with_quantum_context(self):
+        ctxt = context.Context('fake_user', 'fake_tenant')
+        self.req.environ['quantum.context'] = ctxt
+        self.assertEqual(self.req.context, ctxt)
+
+    def test_context_without_quantum_context(self):
+        self.assertTrue(self.req.context.is_admin)
+
+
+class ResourceTestCase(unittest.TestCase):
+    def test_unmapped_quantum_error(self):
+        controller = mock.MagicMock()
+        controller.test.side_effect = q_exc.QuantumException()
+
+        resource = webtest.TestApp(wsgi_resource.Resource(controller))
+
+        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
+        res = resource.get('', extra_environ=environ, expect_errors=True)
+        self.assertEqual(res.status_int, exc.HTTPInternalServerError.code)
+
+    def test_mapped_quantum_error(self):
+        controller = mock.MagicMock()
+        controller.test.side_effect = q_exc.QuantumException()
+
+        faults = {q_exc.QuantumException: exc.HTTPGatewayTimeout}
+        resource = webtest.TestApp(wsgi_resource.Resource(controller,
+                                                          faults=faults))
+
+        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
+        res = resource.get('', extra_environ=environ, expect_errors=True)
+        self.assertEqual(res.status_int, exc.HTTPGatewayTimeout.code)
+
+    def test_http_error(self):
+        controller = mock.MagicMock()
+        controller.test.side_effect = exc.HTTPGatewayTimeout()
+
+        resource = webtest.TestApp(wsgi_resource.Resource(controller))
+
+        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
+        res = resource.get('', extra_environ=environ, expect_errors=True)
+        self.assertEqual(res.status_int, exc.HTTPGatewayTimeout.code)
+
+    def test_unhandled_error(self):
+        controller = mock.MagicMock()
+        controller.test.side_effect = Exception()
+
+        resource = webtest.TestApp(wsgi_resource.Resource(controller))
+
+        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
+        res = resource.get('', extra_environ=environ, expect_errors=True)
+        self.assertEqual(res.status_int, exc.HTTPInternalServerError.code)
+
+    def test_status_200(self):
+        controller = mock.MagicMock()
+        controller.test = lambda request: {'foo': 'bar'}
+
+        resource = webtest.TestApp(wsgi_resource.Resource(controller))
+
+        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
+        res = resource.get('', extra_environ=environ, expect_errors=True)
+        self.assertEqual(res.status_int, 200)
+
+    def test_status_204(self):
+        controller = mock.MagicMock()
+        controller.test = lambda request: {'foo': 'bar'}
+
+        resource = webtest.TestApp(wsgi_resource.Resource(controller))
+
+        environ = {'wsgiorg.routing_args': (None, {'action': 'delete'})}
+        res = resource.delete('', extra_environ=environ, expect_errors=True)
+        self.assertEqual(res.status_int, 204)
+
+    def test_no_route_args(self):
+        controller = mock.MagicMock()
+
+        resource = webtest.TestApp(wsgi_resource.Resource(controller))
+
+        environ = {}
+        res = resource.get('', extra_environ=environ, expect_errors=True)
+        self.assertEqual(res.status_int, exc.HTTPInternalServerError.code)
+
+    def test_post_with_body(self):
+        controller = mock.MagicMock()
+        controller.test = lambda request, body: {'foo': 'bar'}
+
+        resource = webtest.TestApp(wsgi_resource.Resource(controller))
+
+        environ = {'wsgiorg.routing_args': (None, {'action': 'test'})}
+        res = resource.post('', params='{"key": "val"}',
+                            extra_environ=environ, expect_errors=True)
+        self.assertEqual(res.status_int, 200)