Merged with trunk (after faults change to return correct content-type)

2 files changed, 105 insertions, 28 deletions

diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index a05e97021..bc97639a0 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -61,6 +61,7 @@ class Fault(webob.exc.HTTPException):
         serializer = wsgi.Serializer(metadata, default_xmlns)
         content_type = req.best_match_content_type()
         self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
+        self.wrapped_exc.content_type = content_type
         return self.wrapped_exc
 
 
diff --git a/nova/tests/api/openstack/test_faults.py b/nova/tests/api/openstack/test_faults.py
index 505e7e308..b3433f45f 100644
--- a/nova/tests/api/openstack/test_faults.py
+++ b/nova/tests/api/openstack/test_faults.py
@@ -15,6 +15,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import json
+
 import webob
 import webob.dec
 import webob.exc
@@ -25,41 +27,115 @@ from nova.api.openstack import faults
 
 
 class TestFaults(test.TestCase):
+    """Tests covering `nova.api.openstack.faults:Fault` class."""
 
-    def test_fault_parts(self):
-        req = webob.Request.blank('/.xml')
-        f = faults.Fault(webob.exc.HTTPBadRequest(explanation='scram'))
-        resp = req.get_response(f)
-
-        first_three_words = resp.body.strip().split()[:3]
-        self.assertEqual(first_three_words,
-                         ['<badRequest',
-                          'code="400"',
-                          'xmlns="%s">' % common.XML_NS_V10])
-        body_without_spaces = ''.join(resp.body.split())
-        self.assertTrue('<message>scram</message>' in body_without_spaces)
-
-    def test_retry_header(self):
-        req = webob.Request.blank('/.xml')
-        exc = webob.exc.HTTPRequestEntityTooLarge(explanation='sorry',
-                                                  headers={'Retry-After': 4})
-        f = faults.Fault(exc)
-        resp = req.get_response(f)
-        first_three_words = resp.body.strip().split()[:3]
-        self.assertEqual(first_three_words,
-                         ['<overLimit',
-                          'code="413"',
-                          'xmlns="%s">' % common.XML_NS_V10])
-        body_sans_spaces = ''.join(resp.body.split())
-        self.assertTrue('<message>sorry</message>' in body_sans_spaces)
-        self.assertTrue('<retryAfter>4</retryAfter>' in body_sans_spaces)
-        self.assertEqual(resp.headers['Retry-After'], 4)
+    def _prepare_xml(self, xml_string):
+        """Remove characters from string which hinder XML equality testing."""
+        xml_string = xml_string.replace("  ", "")
+        xml_string = xml_string.replace("\n", "")
+        xml_string = xml_string.replace("\t", "")
+        return xml_string
+
+    def test_400_fault_xml(self):
+        """Test fault serialized to XML via file-extension and/or header."""
+        requests = [
+            webob.Request.blank('/.xml'),
+            webob.Request.blank('/', headers={"Accept": "application/xml"}),
+        ]
+
+        for request in requests:
+            fault = faults.Fault(webob.exc.HTTPBadRequest(explanation='scram'))
+            response = request.get_response(fault)
+
+            expected = self._prepare_xml("""
+                <badRequest code="400">
+                    <message>scram</message>
+                </badRequest>
+            """)
+            actual = self._prepare_xml(response.body)
+
+            self.assertEqual(response.content_type, "application/xml")
+            self.assertEqual(expected, actual)
+
+    def test_400_fault_json(self):
+        """Test fault serialized to JSON via file-extension and/or header."""
+        requests = [
+            webob.Request.blank('/.json'),
+            webob.Request.blank('/', headers={"Accept": "application/json"}),
+        ]
+
+        for request in requests:
+            fault = faults.Fault(webob.exc.HTTPBadRequest(explanation='scram'))
+            response = request.get_response(fault)
+
+            expected = {
+                "badRequest": {
+                    "message": "scram",
+                    "code": 400,
+                },
+            }
+            actual = json.loads(response.body)
+
+            self.assertEqual(response.content_type, "application/json")
+            self.assertEqual(expected, actual)
+
+    def test_413_fault_xml(self):
+        requests = [
+            webob.Request.blank('/.xml'),
+            webob.Request.blank('/', headers={"Accept": "application/xml"}),
+        ]
+
+        for request in requests:
+            exc = webob.exc.HTTPRequestEntityTooLarge
+            fault = faults.Fault(exc(explanation='sorry',
+                        headers={'Retry-After': 4}))
+            response = request.get_response(fault)
+
+            expected = self._prepare_xml("""
+                <overLimit code="413">
+                    <message>sorry</message>
+                    <retryAfter>4</retryAfter>
+                </overLimit>
+            """)
+            actual = self._prepare_xml(response.body)
+
+            self.assertEqual(expected, actual)
+            self.assertEqual(response.content_type, "application/xml")
+            self.assertEqual(response.headers['Retry-After'], 4)
+
+    def test_413_fault_json(self):
+        """Test fault serialized to JSON via file-extension and/or header."""
+        requests = [
+            webob.Request.blank('/.json'),
+            webob.Request.blank('/', headers={"Accept": "application/json"}),
+        ]
+
+        for request in requests:
+            exc = webob.exc.HTTPRequestEntityTooLarge
+            fault = faults.Fault(exc(explanation='sorry',
+                        headers={'Retry-After': 4}))
+            response = request.get_response(fault)
+
+            expected = {
+                "overLimit": {
+                    "message": "sorry",
+                    "code": 413,
+                    "retryAfter": 4,
+                },
+            }
+            actual = json.loads(response.body)
+
+            self.assertEqual(response.content_type, "application/json")
+            self.assertEqual(expected, actual)
 
     def test_raise(self):
+        """Ensure the ability to raise `Fault`s in WSGI-ified methods."""
         @webob.dec.wsgify
         def raiser(req):
             raise faults.Fault(webob.exc.HTTPNotFound(explanation='whut?'))
+
         req = webob.Request.blank('/.xml')
         resp = req.get_response(raiser)
+        self.assertEqual(resp.content_type, "application/xml")
         self.assertEqual(resp.status_int, 404)
         self.assertTrue('whut?' in resp.body)