Ticket #17449: patch17449.diff

docs/ref/request-response.txt

@@ -761 +761 @@
     Like :class:`HttpResponse`, but uses a 405 status code. Takes a single,
     required argument: a list of permitted methods (e.g. ``['GET', 'POST']``).
 
+.. class:: HttpResponseOptions
+
+    Like :class:`HttpResponse`, but uses a 204 status code and provides
+    an ``Allow`` response header. Takes a single, required argument: a list
+    of permitted methods (e.g., ``['GET', 'POST']``) used to populate
+    the ``Allow`` header.
+
 .. class:: HttpResponseGone
 
     Acts just like :class:`HttpResponse` but uses a 410 status code.

django/http/__init__.py

@@ -720 +720 @@
             raise Exception("This %s instance cannot tell its position" % self.__class__)
         return sum([len(str(chunk)) for chunk in self._container])
 
+class HttpResponseOptions(HttpResponse):
+    status_code = 204
+
+    def __init__(self, permitted_methods):
+        super(HttpResponseOptions, self).__init__()
+        self['Allow'] = ', '.join(permitted_methods)
+        self['Content-Length'] = '0'
+
 class HttpResponseRedirect(HttpResponse):
     status_code = 302
 

django/views/generic/base.py

@@ -43 +43 @@
 
         def view(request, *args, **kwargs):
             self = cls(**initkwargs)
+            if hasattr(self, 'get') and not hasattr(self, 'head'):
+                self.head = self.get
             return self.dispatch(request, *args, **kwargs)
 
         # take name and docstring from class
@@ -67 +69 @@
         return handler(request, *args, **kwargs)
 
     def http_method_not_allowed(self, request, *args, **kwargs):
-        allowed_methods = [m for m in self.http_method_names if hasattr(self, m)]
+        allowed_methods = [m.upper() for m in self.http_method_names
+                if hasattr(self, m)]
         logger.warning('Method Not Allowed (%s): %s' % (request.method, request.path),
             extra={
                 'status_code': 405,
@@ -76 +79 @@
         )
         return http.HttpResponseNotAllowed(allowed_methods)
 
-    def head(self, *args, **kwargs):
-        return self.get(*args, **kwargs)
+    def options(self, request, *args, **kwargs):
+        allowed_methods = [m.upper() for m in self.http_method_names
+                if hasattr(self, m)]
+        return http.HttpResponseOptions(allowed_methods)
 
 
 class TemplateResponseMixin(object):

tests/regressiontests/generic_views/base.py

@@ -55 +55 @@
         return self
 
 
+class PostOnlyView(View):
+    def post(self, request):
+        return HttpResponse('This view only accepts POST')
+
+
 class ViewTest(unittest.TestCase):
     rf = RequestFactory()
 
@@ -157 +162 @@
         """
         self.assertTrue(DecoratedDispatchView.as_view().is_decorated)
 
+    def test_head_no_get(self):
+        """
+        Test that a view class with no get responds to a HEAD request with HTTP
+        405.
+        """
+        request = self.rf.head('/')
+        view = PostOnlyView.as_view()
+        self.assertEqual(405, view(request).status_code)
 
+    def test_options(self):
+        """
+        Test that views respond to HTTP OPTIONS requests with an Allow header
+        appropriate for the methods implemented by the view class.
+        """
+        request = self.rf.options('/')
+        view = SimpleView.as_view()
+        response = view(request)
+        self.assertEqual(204, response.status_code)
+        self.assertTrue(response['Allow'])
+
+    def test_options_for_get_view(self):
+        """
+        Test that a view implementing GET allows GET and HEAD.
+        """
+        request = self.rf.options('/')
+        view = SimpleView.as_view()
+        response = view(request)
+        self._assert_allows(response, 'GET', 'HEAD')
+
+    def test_options_for_get_and_post_view(self):
+        """
+        Test that a view implementing GET and POST allows GET, HEAD, and POST.
+        """
+        request = self.rf.options('/')
+        view = SimplePostView.as_view()
+        response = view(request)
+        self._assert_allows(response, 'GET', 'HEAD', 'POST')
+
+    def test_options_for_post_view(self):
+        """
+        Test that a view implementing POST allows POST.
+        """
+        request = self.rf.options('/')
+        view = PostOnlyView.as_view()
+        response = view(request)
+        self._assert_allows(response, 'POST')
+
+    def _assert_allows(self, response, *expected_methods):
+        "Assert allowed HTTP methods reported in the Allow response header"
+        response_allows = set(response['Allow'].split(', '))
+        self.assertEqual(set(expected_methods + ('OPTIONS',)), response_allows)
+
 class TemplateViewTest(TestCase):
     urls = 'regressiontests.generic_views.urls'