Viewing github.com/django/django-stable-4.1.x/tests/generic_views/test

```
import time
```

from django.core.exceptions import ImproperlyConfigured

```
from django.http import HttpResponse
```

from django.test import RequestFactory, SimpleTestCase, override_settings

from django.test.utils import require_jinja2

```
from django.urls import resolve
```

from django.views.generic import RedirectView, TemplateView, View

```
from . import views
```
```
class SimpleView(View):
```
```
    """
```
```
    A simple view with a docstring.
```
```
    """
```
```
    def get(self, request):
```

        return HttpResponse("This is a simple view")

```
class SimplePostView(SimpleView):
```
```
    post = SimpleView.get
```
```
class PostOnlyView(View):
```
```
    def post(self, request):
```

        return HttpResponse("This view only accepts POST")

```
class CustomizableView(SimpleView):
```
```
    parameter = {}
```
```
def decorator(view):
```
```
    view.is_decorated = True
```
```
    return view
```

class DecoratedDispatchView(SimpleView):

```
    @decorator
```

    def dispatch(self, request, *args, **kwargs):

        return super().dispatch(request, *args, **kwargs)

```
class AboutTemplateView(TemplateView):
```
```
    def get(self, request):
```

        return self.render_to_response({})

```
    def get_template_names(self):
```

        return ["generic_views/about.html"]

class AboutTemplateAttributeView(TemplateView):

    template_name = "generic_views/about.html"

```
    def get(self, request):
```

        return self.render_to_response(context={})

```
class InstanceView(View):
```
```
    def get(self, request):
```
```
        return self
```
```
class ViewTest(SimpleTestCase):
```
```
    rf = RequestFactory()
```

    def _assert_simple(self, response):

        self.assertEqual(response.status_code, 200)

        self.assertEqual(response.content, b"This is a simple view")

```
    def test_no_init_kwargs(self):
```
```
        """
```

        A view can't be accidentally instantiated before deployment

```
        """
```

        msg = "This method is available only on the class, not on instances."

        with self.assertRaisesMessage(AttributeError, msg):

            SimpleView(key="value").as_view()

```
    def test_no_init_args(self):
```
```
        """
```

        A view can't be accidentally instantiated before deployment

```
        """
```

        msg = "as_view() takes 1 positional argument but 2 were given"

        with self.assertRaisesMessage(TypeError, msg):

            SimpleView.as_view("value")

    def test_pathological_http_method(self):

```
        """
```

        The edge case of an HTTP request that spoofs an existing method name is

```
        caught.
```
```
        """
```
```
        self.assertEqual(
```
```
            SimpleView.as_view()(
```

                self.rf.get("/", REQUEST_METHOD="DISPATCH")

```
            ).status_code,
```
```
            405,
```
```
        )
```
```
    def test_get_only(self):
```
```
        """
```

        Test a view which only allows GET doesn't allow other methods.

```
        """
```

        self._assert_simple(SimpleView.as_view()(self.rf.get("/")))

        self.assertEqual(SimpleView.as_view()(self.rf.post("/")).status_code, 405)

```
        self.assertEqual(
```

            SimpleView.as_view()(self.rf.get("/", REQUEST_METHOD="FAKE")).status_code,

```
            405,
```
```
        )
```
```
    def test_get_and_head(self):
```
```
        """
```

        Test a view which supplies a GET method also responds correctly to HEAD.

```
        """
```

        self._assert_simple(SimpleView.as_view()(self.rf.get("/")))

        response = SimpleView.as_view()(self.rf.head("/"))

        self.assertEqual(response.status_code, 200)

```
    def test_setup_get_and_head(self):
```
```
        view_instance = SimpleView()
```

        self.assertFalse(hasattr(view_instance, "head"))

        view_instance.setup(self.rf.get("/"))

        self.assertTrue(hasattr(view_instance, "head"))

        self.assertEqual(view_instance.head, view_instance.get)

```
    def test_head_no_get(self):
```
```
        """
```

        Test a view which supplies no GET method responds to HEAD with HTTP 405.

```
        """
```

        response = PostOnlyView.as_view()(self.rf.head("/"))

        self.assertEqual(response.status_code, 405)

```
    def test_get_and_post(self):
```
```
        """
```

        Test a view which only allows both GET and POST.

```
        """
```

        self._assert_simple(SimplePostView.as_view()(self.rf.get("/")))

        self._assert_simple(SimplePostView.as_view()(self.rf.post("/")))

```
        self.assertEqual(
```
```
            SimplePostView.as_view()(
```

                self.rf.get("/", REQUEST_METHOD="FAKE")

```
            ).status_code,
```
```
            405,
```
```
        )
```

    def test_invalid_keyword_argument(self):

```
        """
```

        View arguments must be predefined on the class and can't

```
        be named like an HTTP method.
```
```
        """
```
```
        msg = (
```

            "The method name %s is not accepted as a keyword argument to "

```
            "SimpleView()."
```
```
        )
```

        # Check each of the allowed method names

        for method in SimpleView.http_method_names:

            with self.assertRaisesMessage(TypeError, msg % method):

                SimpleView.as_view(**{method: "value"})

        # Check the case view argument is ok if predefined on the class...

        CustomizableView.as_view(parameter="value")

        # ...but raises errors otherwise.

```
        msg = (
```

            "CustomizableView() received an invalid keyword 'foobar'. "

            "as_view only accepts arguments that are already attributes of "

```
            "the class."
```
```
        )
```

        with self.assertRaisesMessage(TypeError, msg):

            CustomizableView.as_view(foobar="value")

    def test_calling_more_than_once(self):

```
        """
```

        Test a view can only be called once.

```
        """
```
```
        request = self.rf.get("/")
```
```
        view = InstanceView.as_view()
```

        self.assertNotEqual(view(request), view(request))

```
    def test_class_attributes(self):
```
```
        """
```

        The callable returned from as_view() has proper special attributes.

```
        """
```
```
        cls = SimpleView
```
```
        view = cls.as_view()
```

        self.assertEqual(view.__doc__, cls.__doc__)

        self.assertEqual(view.__name__, "view")

        self.assertEqual(view.__module__, cls.__module__)

        self.assertEqual(view.__qualname__, f"{cls.as_view.__qualname__}.<locals>.view")

        self.assertEqual(view.__annotations__, cls.dispatch.__annotations__)

        self.assertFalse(hasattr(view, "__wrapped__"))

    def test_dispatch_decoration(self):

```
        """
```

        Attributes set by decorators on the dispatch method

        are also present on the closure.

```
        """
```

        self.assertTrue(DecoratedDispatchView.as_view().is_decorated)

```
    def test_options(self):
```
```
        """
```

        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(200, response.status_code)

        self.assertTrue(response.headers["Allow"])

    def test_options_for_get_view(self):

```
        """
```

        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):

```
        """
```

        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):

```
        """
```

        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.headers["Allow"].split(", "))

        self.assertEqual(set(expected_methods + ("OPTIONS",)), response_allows)

    def test_args_kwargs_request_on_self(self):

```
        """
```

        Test a view only has args, kwargs & request once `as_view`

```
        has been called.
```
```
        """
```
```
        bare_view = InstanceView()
```

        view = InstanceView.as_view()(self.rf.get("/"))

        for attribute in ("args", "kwargs", "request"):

            self.assertNotIn(attribute, dir(bare_view))

            self.assertIn(attribute, dir(view))

```
    def test_overridden_setup(self):
```
```
        class SetAttributeMixin:
```

            def setup(self, request, *args, **kwargs):

```
                self.attr = True
```

                super().setup(request, *args, **kwargs)

        class CheckSetupView(SetAttributeMixin, SimpleView):

            def dispatch(self, request, *args, **kwargs):

                assert hasattr(self, "attr")

                return super().dispatch(request, *args, **kwargs)

        response = CheckSetupView.as_view()(self.rf.get("/"))

        self.assertEqual(response.status_code, 200)

    def test_not_calling_parent_setup_error(self):

```
        class TestView(View):
```

            def setup(self, request, *args, **kwargs):

                pass  # Not calling super().setup()

```
        msg = (
```

            "TestView instance has no 'request' attribute. Did you override "

            "setup() and forget to call super()?"

```
        )
```

        with self.assertRaisesMessage(AttributeError, msg):

            TestView.as_view()(self.rf.get("/"))

    def test_setup_adds_args_kwargs_request(self):

```
        request = self.rf.get("/")
```
```
        args = ("arg 1", "arg 2")
```

        kwargs = {"kwarg_1": 1, "kwarg_2": "year"}

```
        view = View()
```

        view.setup(request, *args, **kwargs)

        self.assertEqual(request, view.request)

        self.assertEqual(args, view.args)

        self.assertEqual(kwargs, view.kwargs)

    def test_direct_instantiation(self):

```
        """
```

        It should be possible to use the view by directly instantiating it

        without going through .as_view() (#21564).

```
        """
```
```
        view = PostOnlyView()
```

        response = view.dispatch(self.rf.head("/"))

        self.assertEqual(response.status_code, 405)

@override_settings(ROOT_URLCONF="generic_views.urls")

class TemplateViewTest(SimpleTestCase):

```
    rf = RequestFactory()
```
```
    def _assert_about(self, response):
```
```
        response.render()
```

        self.assertContains(response, "<h1>About</h1>")

```
    def test_get(self):
```
```
        """
```

        Test a view that simply renders a template on GET

```
        """
```

        self._assert_about(AboutTemplateView.as_view()(self.rf.get("/about/")))

```
    def test_head(self):
```
```
        """
```

        Test a TemplateView responds correctly to HEAD

```
        """
```

        response = AboutTemplateView.as_view()(self.rf.head("/about/"))

        self.assertEqual(response.status_code, 200)

    def test_get_template_attribute(self):

```
        """
```

        Test a view that renders a template on GET with the template name as

```
        an attribute on the class.
```
```
        """
```

        self._assert_about(AboutTemplateAttributeView.as_view()(self.rf.get("/about/")))

    def test_get_generic_template(self):

```
        """
```

        Test a completely generic view that renders a template on GET

        with the template name as an argument at instantiation.

```
        """
```
```
        self._assert_about(
```

            TemplateView.as_view(template_name="generic_views/about.html")(

```
                self.rf.get("/about/")
```
```
            )
```
```
        )
```

    def test_template_name_required(self):

```
        """
```

        A template view must provide a template name.

```
        """
```
```
        msg = (
```

            "TemplateResponseMixin requires either a definition of "

            "'template_name' or an implementation of 'get_template_names()'"

```
        )
```

        with self.assertRaisesMessage(ImproperlyConfigured, msg):

            self.client.get("/template/no_template/")

```
    @require_jinja2
```
```
    def test_template_engine(self):
```
```
        """
```

        A template view may provide a template engine.

```
        """
```

        request = self.rf.get("/using/")

        view = TemplateView.as_view(template_name="generic_views/using.html")

        self.assertEqual(view(request).render().content, b"DTL\n")

```
        view = TemplateView.as_view(
```

            template_name="generic_views/using.html", template_engine="django"

```
        )
```

        self.assertEqual(view(request).render().content, b"DTL\n")

```
        view = TemplateView.as_view(
```

            template_name="generic_views/using.html", template_engine="jinja2"

```
        )
```

        self.assertEqual(view(request).render().content, b"Jinja2\n")

```
    def test_template_params(self):
```
```
        """
```

        A generic template view passes kwargs as context.

```
        """
```

        response = self.client.get("/template/simple/bar/")

        self.assertEqual(response.status_code, 200)

        self.assertEqual(response.context["foo"], "bar")

        self.assertIsInstance(response.context["view"], View)

    def test_extra_template_params(self):

```
        """
```

        A template view can be customized to return extra context.

```
        """
```

        response = self.client.get("/template/custom/bar/")

        self.assertEqual(response.status_code, 200)

        self.assertEqual(response.context["foo"], "bar")

        self.assertEqual(response.context["key"], "value")

        self.assertIsInstance(response.context["view"], View)

```
    def test_cached_views(self):
```
```
        """
```
```
        A template view can be cached
```
```
        """
```

        response = self.client.get("/template/cached/bar/")

        self.assertEqual(response.status_code, 200)

```
        time.sleep(1.0)
```

        response2 = self.client.get("/template/cached/bar/")

        self.assertEqual(response2.status_code, 200)

        self.assertEqual(response.content, response2.content)

```
        time.sleep(2.0)
```

        # Let the cache expire and test again

        response2 = self.client.get("/template/cached/bar/")

        self.assertEqual(response2.status_code, 200)

        self.assertNotEqual(response.content, response2.content)

```
    def test_content_type(self):
```

        response = self.client.get("/template/content_type/")

        self.assertEqual(response.headers["Content-Type"], "text/plain")

```
    def test_resolve_view(self):
```

        match = resolve("/template/content_type/")

        self.assertIs(match.func.view_class, TemplateView)

        self.assertEqual(match.func.view_initkwargs["content_type"], "text/plain")

    def test_resolve_login_required_view(self):

        match = resolve("/template/login_required/")

        self.assertIs(match.func.view_class, TemplateView)

```
    def test_extra_context(self):
```

        response = self.client.get("/template/extra_context/")

        self.assertEqual(response.context["title"], "Title")

@override_settings(ROOT_URLCONF="generic_views.urls")

class RedirectViewTest(SimpleTestCase):

```
    rf = RequestFactory()
```
```
    def test_no_url(self):
```

        "Without any configuration, returns HTTP 410 GONE"

        response = RedirectView.as_view()(self.rf.get("/foo/"))

        self.assertEqual(response.status_code, 410)

```
    def test_default_redirect(self):
```

        "Default is a temporary redirect"

        response = RedirectView.as_view(url="/bar/")(self.rf.get("/foo/"))

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

```
    def test_permanent_redirect(self):
```

        "Permanent redirects are an option"

        response = RedirectView.as_view(url="/bar/", permanent=True)(

```
            self.rf.get("/foo/")
```
```
        )
```

        self.assertEqual(response.status_code, 301)

        self.assertEqual(response.url, "/bar/")

```
    def test_temporary_redirect(self):
```

        "Temporary redirects are an option"

        response = RedirectView.as_view(url="/bar/", permanent=False)(

```
            self.rf.get("/foo/")
```
```
        )
```

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

```
    def test_include_args(self):
```

        "GET arguments can be included in the redirected URL"

        response = RedirectView.as_view(url="/bar/")(self.rf.get("/foo/"))

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

        response = RedirectView.as_view(url="/bar/", query_string=True)(

            self.rf.get("/foo/?pork=spam")

```
        )
```

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/?pork=spam")

    def test_include_urlencoded_args(self):

        "GET arguments can be URL-encoded when included in the redirected URL"

        response = RedirectView.as_view(url="/bar/", query_string=True)(

            self.rf.get("/foo/?unicode=%E2%9C%93")

```
        )
```

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/?unicode=%E2%9C%93")

    def test_parameter_substitution(self):

        "Redirection URLs can be parameterized"

        response = RedirectView.as_view(url="/bar/%(object_id)d/")(

            self.rf.get("/foo/42/"), object_id=42

```
        )
```

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/42/")

```
    def test_named_url_pattern(self):
```

        "Named pattern parameter should reverse to the matching pattern"

        response = RedirectView.as_view(pattern_name="artist_detail")(

```
            self.rf.get("/foo/"), pk=1
```
```
        )
```

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.headers["Location"], "/detail/artist/1/")

    def test_named_url_pattern_using_args(self):

        response = RedirectView.as_view(pattern_name="artist_detail")(

```
            self.rf.get("/foo/"), 1
```
```
        )
```

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.headers["Location"], "/detail/artist/1/")

```
    def test_redirect_POST(self):
```

        "Default is a temporary redirect"

        response = RedirectView.as_view(url="/bar/")(self.rf.post("/foo/"))

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

```
    def test_redirect_HEAD(self):
```

        "Default is a temporary redirect"

        response = RedirectView.as_view(url="/bar/")(self.rf.head("/foo/"))

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

```
    def test_redirect_OPTIONS(self):
```

        "Default is a temporary redirect"

        response = RedirectView.as_view(url="/bar/")(self.rf.options("/foo/"))

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

```
    def test_redirect_PUT(self):
```

        "Default is a temporary redirect"

        response = RedirectView.as_view(url="/bar/")(self.rf.put("/foo/"))

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

```
    def test_redirect_PATCH(self):
```

        "Default is a temporary redirect"

        response = RedirectView.as_view(url="/bar/")(self.rf.patch("/foo/"))

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

```
    def test_redirect_DELETE(self):
```

        "Default is a temporary redirect"

        response = RedirectView.as_view(url="/bar/")(self.rf.delete("/foo/"))

        self.assertEqual(response.status_code, 302)

        self.assertEqual(response.url, "/bar/")

    def test_redirect_when_meta_contains_no_query_string(self):

```
        "regression for #16705"
```

        # we can't use self.rf.get because it always sets QUERY_STRING

        response = RedirectView.as_view(url="/bar/")(self.rf.request(PATH_INFO="/foo/"))

        self.assertEqual(response.status_code, 302)

    def test_direct_instantiation(self):

```
        """
```

        It should be possible to use the view without going through .as_view()

```
        (#21564).
```
```
        """
```
```
        view = RedirectView()
```

        response = view.dispatch(self.rf.head("/foo/"))

        self.assertEqual(response.status_code, 410)

class GetContextDataTest(SimpleTestCase):

    def test_get_context_data_super(self):

        test_view = views.CustomContextView()

        context = test_view.get_context_data(kwarg_test="kwarg_value")

        # the test_name key is inserted by the test classes parent

        self.assertIn("test_name", context)

        self.assertEqual(context["kwarg_test"], "kwarg_value")

        self.assertEqual(context["custom_key"], "custom_value")

        # test that kwarg overrides values assigned higher up

        context = test_view.get_context_data(test_name="test_value")

        self.assertEqual(context["test_name"], "test_value")

    def test_object_at_custom_name_in_context_data(self):

        # Checks 'pony' key presence in dict returned by get_context_date

        test_view = views.CustomSingleObjectView()

        test_view.context_object_name = "pony"

        context = test_view.get_context_data()

        self.assertEqual(context["pony"], test_view.object)

    def test_object_in_get_context_data(self):

        # Checks 'object' key presence in dict returned by get_context_date #20234

        test_view = views.CustomSingleObjectView()

        context = test_view.get_context_data()

        self.assertEqual(context["object"], test_view.object)

class UseMultipleObjectMixinTest(SimpleTestCase):

```
    rf = RequestFactory()
```

    def test_use_queryset_from_view(self):

        test_view = views.CustomMultipleObjectMixinView()

        test_view.get(self.rf.get("/"))

        # Don't pass queryset as argument

        context = test_view.get_context_data()

        self.assertEqual(context["object_list"], test_view.queryset)

```
    def test_overwrite_queryset(self):
```

        test_view = views.CustomMultipleObjectMixinView()

        test_view.get(self.rf.get("/"))

        queryset = [{"name": "Lennon"}, {"name": "Ono"}]

        self.assertNotEqual(test_view.queryset, queryset)

        # Overwrite the view's queryset with queryset from kwarg

        context = test_view.get_context_data(object_list=queryset)

        self.assertEqual(context["object_list"], queryset)

class SingleObjectTemplateResponseMixinTest(SimpleTestCase):

    def test_template_mixin_without_template(self):

```
        """
```

        We want to makes sure that if you use a template mixin, but forget the

        template, it still tells you it's ImproperlyConfigured instead of

```
        TemplateDoesNotExist.
```
```
        """
```

        view = views.TemplateResponseWithoutTemplate()

```
        msg = (
```

            "TemplateResponseMixin requires either a definition of "

            "'template_name' or an implementation of 'get_template_names()'"

```
        )
```

        with self.assertRaisesMessage(ImproperlyConfigured, msg):

```
            view.get_template_names()
```