How to test 500.html error page in django development env?

DjangoDevelopment Environment

Django Problem Overview

I am using Django for a project and is already in production.

In the production environment 500.html is rendered whenever a server error occurs.

How do I test the rendering of 500.html in dev environment? Or how do I render 500.html in dev, if I turn-off debug I still get the errors and not 500.html

background: I include some page elements based on a page and some are missing when 500.html is called and want to debug it in dev environment.

Django Solutions

Solution 1 - Django

I prefer not to turn DEBUG off. Instead I put the following snippet in the

if settings.DEBUG:
    urlpatterns += patterns('',
        (r'^500/$', 'your_custom_view_if_you_wrote_one'),
        (r'^404/$', 'django.views.generic.simple.direct_to_template', {'template': '404.html'}),

In the snippet above, the error page uses a custom view, you can easily replace it with Django's direct_to_template view though.

Now you can test 500 and 404 pages by calling their urls: and

Solution 2 - Django

In Django 1.6 django.views.generic.simple.direct_to_template does not exists anymore, these are my settings for special views:


from django.views.generic import TemplateView
from django.views.defaults import page_not_found, server_error

urlpatterns += [
    url(r'^400/$', TemplateView.as_view(template_name='400.html')),
    url(r'^403/$', TemplateView.as_view(template_name='403.html')),
    url(r'^404/$', page_not_found),
    url(r'^500/$', server_error),

Solution 3 - Django

And if you want to use the default Django 500 view instead of your custom view:

if settings.DEBUG:
    urlpatterns += patterns('',
        (r'^500/$', 'django.views.defaults.server_error'),
        (r'^404/$', 'django.views.generic.simple.direct_to_template', {'template': '404.html'}),

Solution 4 - Django

Continuing shanyu's answer, in Django 1.3+ use:

if settings.DEBUG:
    urlpatterns += patterns('',
        (r'^500/$', 'django.views.defaults.server_error'),
        (r'^404/$', 'django.views.defaults.page_not_found'),

Solution 5 - Django

Are both debug settings false?

settings.DEBUG = False
settings.TEMPLATE_DEBUG = False

Solution 6 - Django

How i do and test custom error handlers

Define custom View based on TemplateView

from django.views.generic import TemplateView

class ErrorHandler(TemplateView):

    """ Render error template """

    error_code = 404
    template_name = 'index/error.html'

    def dispatch(self, request, *args, **kwargs):
        """ For error on any methods return just GET """
        return self.get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['error_code'] = self.error_code
        return context

    def render_to_response(self, context, **response_kwargs):
        """ Return correct status code """
        response_kwargs = response_kwargs or {}
        return super().render_to_response(context, **response_kwargs)

Tell django to use custom error handlers


from index.views import ErrorHandler

# error handing handlers - fly binding
for code in (400, 403, 404, 500):
    vars()['handler{}'.format(code)] = ErrorHandler.as_view(error_code=code)

Testcase for custom error handlers


from unittest import mock

from django.test import TestCase
from django.core.exceptions import SuspiciousOperation, PermissionDenied
from django.http import Http404
from index import views

class ErrorHandlersTestCase(TestCase):

    """ Check is correct error handlers work """

    def raise_(exception):
        def wrapped(*args, **kwargs):
            raise exception('Test exception')
        return wrapped

    def test_index_page(self):
        """ Should check is 200 on index page """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, 'index/index.html')

    @mock.patch('index.views.IndexView.get', raise_(Http404))
    def test_404_page(self):
        """ Should check is 404 page correct """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 404)
        self.assertTemplateUsed(response, 'index/error.html')
        self.assertIn('404 Page not found', response.content.decode('utf-8'))

    @mock.patch('index.views.IndexView.get', views.ErrorHandler.as_view(error_code=500))
    def test_500_page(self):
        """ Should check is 500 page correct """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 500)
        self.assertTemplateUsed(response, 'index/error.html')
        self.assertIn('500 Server Error', response.content.decode('utf-8'))

    @mock.patch('index.views.IndexView.get', raise_(SuspiciousOperation))
    def test_400_page(self):
        """ Should check is 400 page correct """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 400)
        self.assertTemplateUsed(response, 'index/error.html')
        self.assertIn('400 Bad request', response.content.decode('utf-8'))

    @mock.patch('index.views.IndexView.get', raise_(PermissionDenied))
    def test_403_page(self):
        """ Should check is 403 page correct """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 403)
        self.assertTemplateUsed(response, 'index/error.html')
        self.assertIn('403 Permission Denied', response.content.decode('utf-8'))

Solution 7 - Django

For Django > 3.0, just set the raise_request_exception value to False.

from django.test import TestCase

class ViewTestClass(TestCase):
    def test_error_page(self):
        self.client.raise_request_exception = False
        response = self.client.get(reverse('error-page'))
        self.assertEqual(response.status_code, 500)
            'some text from the custom 500 page'
            in response.content.decode('utf8'))


NOTE: if the error page raises an exception, that will show up as an ERROR in the test log. You can turn the test logging up to CRITICAL by default to suppress that error.

Solution 8 - Django

handler500 = 'project.apps.core.views.handler500'
handler404 = 'project.apps.core.views.handler404'

from django.template.loader import get_template
from django.template import Context
from django.http import HttpResponseServerError, HttpResponseNotFound

def handler500(request, template_name='500.html'):
    t = get_template(template_name)
    ctx = Context({})
    return HttpResponseServerError(t.render(ctx))

def handler404(request, template_name='404.html'):
    t = get_template(template_name)
    ctx = Context({})
    return HttpResponseNotFound(t.render(ctx))

from django.test import TestCase
from django.test.client import RequestFactory

from project import urls

from ..views import handler404, handler500

class TestErrorPages(TestCase):

    def test_error_handlers(self):
        factory = RequestFactory()
        request = factory.get('/')
        response = handler404(request)
        self.assertEqual(response.status_code, 404)
        self.assertIn('404 Not Found!!', unicode(response))
        response = handler500(request)
        self.assertEqual(response.status_code, 500)
        self.assertIn('500 Internal Server Error', unicode(response))

Solution 9 - Django

Update for Django > 1.6 and without getting

page_not_found() missing 1 required positional argument: 'exception'

Inspired by this answer:

from django.views.defaults import page_not_found, server_error, permission_denied, bad_request
if settings.DEBUG:
    # This allows the error pages to be debugged during development, just visit
    # these url in browser to see how these error pages look like.
    urlpatterns += [
    path('400/', bad_request, kwargs={'exception': Exception('Bad Request!')}),
    path('403/', permission_denied, kwargs={'exception': Exception('Permission Denied')}),
    path('404/', page_not_found, kwargs={'exception': Exception('Page not Found')}),
    path('500/', server_error),

Solution 10 - Django

You can simply define the handler404 and handler500 for errors in your main file as detailed in this answer:

This will return the error that you desire when Django routes to that handler. No custom URL configuration is needed to route to a different URL name.

Solution 11 - Django

In Django versions < 3.0, you should do as follows:

from django.core.signals import got_request_exception
from django.template import TemplateDoesNotExist
from django.test import signals
from django.test.client import Client as DjangoClient, store_rendered_templates
from django.urls import resolve
from django.utils import six
from django.utils.functional import SimpleLazyObject, curry

class Client(DjangoClient):
    """Test client that does not raise Exceptions if requested."""

    def __init__(self, 
                 raise_request_exception=True, **defaults):
        super(Client, self).__init__(enforce_csrf_checks=enforce_csrf_checks, 
        self.raise_request_exception = raise_request_exception

    def request(self, **request):
        The master request method. Composes the environment dictionary
        and passes to the handler, returning the result of the handler.
        Assumes defaults for the query environment, which can be overridden
        using the arguments to the request.
        environ = self._base_environ(**request)

        # Curry a data dictionary into an instance of the template renderer
        # callback function.
        data = {}
        on_template_render = curry(store_rendered_templates, data)
        signal_uid = "template-render-%s" % id(request)
        # Capture exceptions created by the handler.
        exception_uid = "request-exception-%s" % id(request)
                response = self.handler(environ)
            except TemplateDoesNotExist as e:
                # If the view raises an exception, Django will attempt to show
                # the 500.html template. If that template is not available,
                # we should ignore the error in favor of re-raising the
                # underlying exception that caused the 500 error. Any other
                # template found to be missing during view error handling
                # should be reported as-is.
                if e.args != ('500.html',):

            # Look for a signalled exception, clear the current context
            # exception data, then re-raise the signalled exception.
            # Also make sure that the signalled exception is cleared from
            # the local cache!
            response.exc_info = self.exc_info  # Patch exception handling
            if self.exc_info:
                exc_info = self.exc_info
                self.exc_info = None
                if self.raise_request_exception:  # Patch exception handling

            # Save the client and request that stimulated the response.
            response.client = self
            response.request = request

            # Add any rendered template detail to the response.
            response.templates = data.get("templates", [])
            response.context = data.get("context")

            response.json = curry(self._parse_json, response)

            # Attach the ResolverMatch instance to the response
            response.resolver_match = SimpleLazyObject(
                lambda: resolve(request['PATH_INFO'])

            # Flatten a single context. Not really necessary anymore thanks to
            # the __getattr__ flattening in ContextList, but has some edge-case
            # backwards-compatibility implications.
            if response.context and len(response.context) == 1:
                response.context = response.context[0]

            # Update persistent cookie data.
            if response.cookies:

            return response

from unittest import mock

from django.contrib.auth import get_user_model
from django.core.urlresolvers import reverse
from django.test import TestCase, override_settings

from .client import Client  # Important, we use our own Client here!

class TestErrors(TestCase):
    """Test errors."""

    def setUpClass(cls):
        super(TestErrors, cls).setUpClass()
        cls.username = 'admin' = 'admin@localhost'
        cls.password = 'test1234test1234'
        cls.not_found_url = '/i-do-not-exist/'
        cls.internal_server_error_url = reverse('password_reset')

    def setUp(self):
        super(TestErrors, self).setUp()
        User = get_user_model()

        self.client = Client(raise_request_exception=False)

    # Mock in order to trigger Exception and resulting Internal server error
    @mock.patch('django.contrib.auth.views.PasswordResetView.form_class', None)
    def test_errors(self):
        self.client.login(username=self.username, password=self.password)

        with self.subTest("Not found (404)"):
            response = self.client.get(self.not_found_url, follow=True)
            self.assertNotIn('^admin/', str(response.content))

        with self.subTest("Internal server error (500)"):
            response = self.client.get(self.internal_server_error_url, 
            self.assertNotIn('TypeError', str(response.content))

Starting from Django 3.0 you could skip the custom Client definition and just use the code from


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
Questionlud0hView Question on Stackoverflow
Solution 1 - DjangoshanyuView Answer on Stackoverflow
Solution 2 - DjangodaveoncodeView Answer on Stackoverflow
Solution 3 - DjangoehcView Answer on Stackoverflow
Solution 4 - DjangoUdiView Answer on Stackoverflow
Solution 5 - DjangomaersuView Answer on Stackoverflow
Solution 6 - DjangoMaks SkorokhodView Answer on Stackoverflow
Solution 7 - DjangotakjeView Answer on Stackoverflow
Solution 8 - DjangonanvelView Answer on Stackoverflow
Solution 9 - DjangoSofienMView Answer on Stackoverflow
Solution 10 - DjangoAaron LelevierView Answer on Stackoverflow
Solution 11 - DjangoArtur BarseghyanView Answer on Stackoverflow