Add files using upload-large-folder tool

5e07a1f verified 9 months ago

22.2 kB

import sys
import unittest

from django.conf import settings
from django.contrib import admin
from django.contrib.admindocs import utils, views
from django.contrib.admindocs.views import get_return_data_type, simplify_regex
from django.contrib.sites.models import Site
from django.db import models
from django.db.models import fields
from django.test import SimpleTestCase, modify_settings, override_settings
from django.test.utils import captured_stderr
from django.urls import include, path, reverse
from django.utils.functional import SimpleLazyObject

from .models import Company, Person
from .tests import AdminDocsTestCase, TestDataMixin


@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
class AdminDocViewTests(TestDataMixin, AdminDocsTestCase):
    def setUp(self):
        self.client.force_login(self.superuser)

    def test_index(self):
        response = self.client.get(reverse("django-admindocs-docroot"))
        self.assertContains(response, "<h1>Documentation</h1>", html=True)
        self.assertContains(
            response,
            '<div id="site-name"><a href="/admin/">Django administration</a></div>',
        )
        self.client.logout()
        response = self.client.get(reverse("django-admindocs-docroot"), follow=True)
        # Should display the login screen
        self.assertContains(
            response, '<input type="hidden" name="next" value="/admindocs/">', html=True
        )

    def test_bookmarklets(self):
        response = self.client.get(reverse("django-admindocs-bookmarklets"))
        self.assertContains(response, "/admindocs/views/")

    def test_templatetag_index(self):
        response = self.client.get(reverse("django-admindocs-tags"))
        self.assertContains(
            response, '<h3 id="built_in-extends">extends</h3>', html=True
        )

    def test_templatefilter_index(self):
        response = self.client.get(reverse("django-admindocs-filters"))
        self.assertContains(response, '<h3 id="built_in-first">first</h3>', html=True)

    def test_view_index(self):
        response = self.client.get(reverse("django-admindocs-views-index"))
        self.assertContains(
            response,
            '<h3><a href="/admindocs/views/django.contrib.admindocs.views.'
            'BaseAdminDocsView/">/admindocs/</a></h3>',
            html=True,
        )
        self.assertContains(response, "Views by namespace test")
        self.assertContains(response, "Name: <code>test:func</code>.")
        self.assertContains(
            response,
            '<h3><a href="/admindocs/views/admin_docs.views.XViewCallableObject/">'
            "/xview/callable_object_without_xview/</a></h3>",
            html=True,
        )

    def test_view_index_with_method(self):
        """
        Views that are methods are listed correctly.
        """
        response = self.client.get(reverse("django-admindocs-views-index"))
        self.assertContains(
            response,
            "<h3>"
            '<a href="/admindocs/views/django.contrib.admin.sites.AdminSite.index/">'
            "/admin/</a></h3>",
            html=True,
        )

    def test_view_detail(self):
        url = reverse(
            "django-admindocs-views-detail",
            args=["django.contrib.admindocs.views.BaseAdminDocsView"],
        )
        response = self.client.get(url)
        # View docstring
        self.assertContains(response, "Base view for admindocs views.")

    @override_settings(ROOT_URLCONF="admin_docs.namespace_urls")
    def test_namespaced_view_detail(self):
        url = reverse(
            "django-admindocs-views-detail", args=["admin_docs.views.XViewClass"]
        )
        response = self.client.get(url)
        self.assertContains(response, "<h1>admin_docs.views.XViewClass</h1>")

    def test_view_detail_illegal_import(self):
        url = reverse(
            "django-admindocs-views-detail",
            args=["urlpatterns_reverse.nonimported_module.view"],
        )
        response = self.client.get(url)
        self.assertEqual(response.status_code, 404)
        self.assertNotIn("urlpatterns_reverse.nonimported_module", sys.modules)

    def test_view_detail_as_method(self):
        """
        Views that are methods can be displayed.
        """
        url = reverse(
            "django-admindocs-views-detail",
            args=["django.contrib.admin.sites.AdminSite.index"],
        )
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_model_index(self):
        response = self.client.get(reverse("django-admindocs-models-index"))
        self.assertContains(
            response,
            '<h2 id="app-auth">Authentication and Authorization (django.contrib.auth)'
            "</h2>",
            html=True,
        )

    def test_template_detail(self):
        response = self.client.get(
            reverse(
                "django-admindocs-templates", args=["admin_doc/template_detail.html"]
            )
        )
        self.assertContains(
            response,
            "<h1>Template: <q>admin_doc/template_detail.html</q></h1>",
            html=True,
        )

    def test_missing_docutils(self):
        utils.docutils_is_available = False
        try:
            response = self.client.get(reverse("django-admindocs-docroot"))
            self.assertContains(
                response,
                "<h3>The admin documentation system requires Python’s "
                '<a href="https://docutils.sourceforge.io/">docutils</a> '
                "library.</h3>"
                "<p>Please ask your administrators to install "
                '<a href="https://pypi.org/project/docutils/">docutils</a>.</p>',
                html=True,
            )
            self.assertContains(
                response,
                '<div id="site-name"><a href="/admin/">Django administration</a></div>',
            )
        finally:
            utils.docutils_is_available = True

    @modify_settings(INSTALLED_APPS={"remove": "django.contrib.sites"})
    @override_settings(SITE_ID=None)  # will restore SITE_ID after the test
    def test_no_sites_framework(self):
        """
        Without the sites framework, should not access SITE_ID or Site
        objects. Deleting settings is fine here as UserSettingsHolder is used.
        """
        Site.objects.all().delete()
        del settings.SITE_ID
        response = self.client.get(reverse("django-admindocs-views-index"))
        self.assertContains(response, "View documentation")

    def test_callable_urlconf(self):
        """
        Index view should correctly resolve view patterns when ROOT_URLCONF is
        not a string.
        """

        def urlpatterns():
            return (
                path("admin/doc/", include("django.contrib.admindocs.urls")),
                path("admin/", admin.site.urls),
            )

        with self.settings(ROOT_URLCONF=SimpleLazyObject(urlpatterns)):
            response = self.client.get(reverse("django-admindocs-views-index"))
            self.assertEqual(response.status_code, 200)


@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
class AdminDocViewDefaultEngineOnly(TestDataMixin, AdminDocsTestCase):
    def setUp(self):
        self.client.force_login(self.superuser)

    def test_template_detail_path_traversal(self):
        cases = ["/etc/passwd", "../passwd"]
        for fpath in cases:
            with self.subTest(path=fpath):
                response = self.client.get(
                    reverse("django-admindocs-templates", args=[fpath]),
                )
                self.assertEqual(response.status_code, 400)


@override_settings(
    TEMPLATES=[
        {
            "NAME": "ONE",
            "BACKEND": "django.template.backends.django.DjangoTemplates",
            "APP_DIRS": True,
        },
        {
            "NAME": "TWO",
            "BACKEND": "django.template.backends.django.DjangoTemplates",
            "APP_DIRS": True,
        },
    ]
)
@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
class AdminDocViewWithMultipleEngines(AdminDocViewTests):
    def test_templatefilter_index(self):
        # Overridden because non-trivial TEMPLATES settings aren't supported
        # but the page shouldn't crash (#24125).
        response = self.client.get(reverse("django-admindocs-filters"))
        self.assertContains(response, "<title>Template filters</title>", html=True)

    def test_templatetag_index(self):
        # Overridden because non-trivial TEMPLATES settings aren't supported
        # but the page shouldn't crash (#24125).
        response = self.client.get(reverse("django-admindocs-tags"))
        self.assertContains(response, "<title>Template tags</title>", html=True)


@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
class TestModelDetailView(TestDataMixin, AdminDocsTestCase):
    def setUp(self):
        self.client.force_login(self.superuser)
        with captured_stderr() as self.docutils_stderr:
            self.response = self.client.get(
                reverse("django-admindocs-models-detail", args=["admin_docs", "Person"])
            )

    def test_method_excludes(self):
        """
        Methods that begin with strings defined in
        ``django.contrib.admindocs.views.MODEL_METHODS_EXCLUDE``
        shouldn't be displayed in the admin docs.
        """
        self.assertContains(self.response, "<td>get_full_name</td>")
        self.assertNotContains(self.response, "<td>_get_full_name</td>")
        self.assertNotContains(self.response, "<td>add_image</td>")
        self.assertNotContains(self.response, "<td>delete_image</td>")
        self.assertNotContains(self.response, "<td>set_status</td>")
        self.assertNotContains(self.response, "<td>save_changes</td>")

    def test_methods_with_arguments(self):
        """
        Methods that take arguments should also displayed.
        """
        self.assertContains(self.response, "<h3>Methods with arguments</h3>")
        self.assertContains(self.response, "<td>rename_company</td>")
        self.assertContains(self.response, "<td>dummy_function</td>")
        self.assertContains(self.response, "<td>suffix_company_name</td>")

    def test_methods_with_arguments_display_arguments(self):
        """
        Methods with arguments should have their arguments displayed.
        """
        self.assertContains(self.response, "<td>new_name</td>")

    def test_methods_with_arguments_display_arguments_default_value(self):
        """
        Methods with keyword arguments should have their arguments displayed.
        """
        self.assertContains(self.response, "<td>suffix=&#x27;ltd&#x27;</td>")

    def test_methods_with_multiple_arguments_display_arguments(self):
        """
        Methods with multiple arguments should have all their arguments
        displayed, but omitting 'self'.
        """
        self.assertContains(
            self.response, "<td>baz, rox, *some_args, **some_kwargs</td>"
        )

    def test_instance_of_property_methods_are_displayed(self):
        """Model properties are displayed as fields."""
        self.assertContains(self.response, "<td>a_property</td>")

    def test_instance_of_cached_property_methods_are_displayed(self):
        """Model cached properties are displayed as fields."""
        self.assertContains(self.response, "<td>a_cached_property</td>")

    def test_method_data_types(self):
        company = Company.objects.create(name="Django")
        person = Person.objects.create(
            first_name="Human", last_name="User", company=company
        )
        self.assertEqual(
            get_return_data_type(person.get_status_count.__name__), "Integer"
        )
        self.assertEqual(get_return_data_type(person.get_groups_list.__name__), "List")

    def test_descriptions_render_correctly(self):
        """
        The ``description`` field should render correctly for each field type.
        """
        # help text in fields
        self.assertContains(
            self.response, "<td>first name - The person's first name</td>"
        )
        self.assertContains(
            self.response, "<td>last name - The person's last name</td>"
        )

        # method docstrings
        self.assertContains(self.response, "<p>Get the full name of the person</p>")

        link = '<a class="reference external" href="/admindocs/models/%s/">%s</a>'
        markup = "<p>the related %s object</p>"
        company_markup = markup % (link % ("admin_docs.company", "admin_docs.Company"))

        # foreign keys
        self.assertContains(self.response, company_markup)

        # foreign keys with help text
        self.assertContains(self.response, "%s\n - place of work" % company_markup)

        # many to many fields
        self.assertContains(
            self.response,
            "number of related %s objects"
            % (link % ("admin_docs.group", "admin_docs.Group")),
        )
        self.assertContains(
            self.response,
            "all related %s objects"
            % (link % ("admin_docs.group", "admin_docs.Group")),
        )

        # "raw" and "include" directives are disabled
        self.assertContains(
            self.response,
            "<p>&quot;raw&quot; directive disabled.</p>",
        )
        self.assertContains(
            self.response, ".. raw:: html\n    :file: admin_docs/evilfile.txt"
        )
        self.assertContains(
            self.response,
            "<p>&quot;include&quot; directive disabled.</p>",
        )
        self.assertContains(self.response, ".. include:: admin_docs/evilfile.txt")
        out = self.docutils_stderr.getvalue()
        self.assertIn('"raw" directive disabled', out)
        self.assertIn('"include" directive disabled', out)

    def test_model_with_many_to_one(self):
        link = '<a class="reference external" href="/admindocs/models/%s/">%s</a>'
        response = self.client.get(
            reverse("django-admindocs-models-detail", args=["admin_docs", "company"])
        )
        self.assertContains(
            response,
            "number of related %s objects"
            % (link % ("admin_docs.person", "admin_docs.Person")),
        )
        self.assertContains(
            response,
            "all related %s objects"
            % (link % ("admin_docs.person", "admin_docs.Person")),
        )

    def test_model_with_no_backward_relations_render_only_relevant_fields(self):
        """
        A model with ``related_name`` of `+` shouldn't show backward
        relationship links.
        """
        response = self.client.get(
            reverse("django-admindocs-models-detail", args=["admin_docs", "family"])
        )
        fields = response.context_data.get("fields")
        self.assertEqual(len(fields), 2)

    def test_model_docstring_renders_correctly(self):
        summary = (
            '<h2 class="subhead"><p>Stores information about a person, related to '
            '<a class="reference external" href="/admindocs/models/myapp.company/">'
            "myapp.Company</a>.</p></h2>"
        )
        subheading = "<p><strong>Notes</strong></p>"
        body = (
            '<p>Use <tt class="docutils literal">save_changes()</tt> when saving this '
            "object.</p>"
        )
        model_body = (
            '<dl class="docutils"><dt><tt class="'
            'docutils literal">company</tt></dt><dd>Field storing <a class="'
            'reference external" href="/admindocs/models/myapp.company/">'
            "myapp.Company</a> where the person works.</dd></dl>"
        )
        self.assertContains(self.response, "DESCRIPTION")
        self.assertContains(self.response, summary, html=True)
        self.assertContains(self.response, subheading, html=True)
        self.assertContains(self.response, body, html=True)
        self.assertContains(self.response, model_body, html=True)

    def test_model_detail_title(self):
        self.assertContains(self.response, "<h1>admin_docs.Person</h1>", html=True)

    def test_app_not_found(self):
        response = self.client.get(
            reverse("django-admindocs-models-detail", args=["doesnotexist", "Person"])
        )
        self.assertEqual(response.context["exception"], "App 'doesnotexist' not found")
        self.assertEqual(response.status_code, 404)

    def test_model_not_found(self):
        response = self.client.get(
            reverse(
                "django-admindocs-models-detail", args=["admin_docs", "doesnotexist"]
            )
        )
        self.assertEqual(
            response.context["exception"],
            "Model 'doesnotexist' not found in app 'admin_docs'",
        )
        self.assertEqual(response.status_code, 404)


class CustomField(models.Field):
    description = "A custom field type"


class DescriptionLackingField(models.Field):
    pass


class TestFieldType(unittest.TestCase):
    def test_field_name(self):
        with self.assertRaises(AttributeError):
            views.get_readable_field_data_type("NotAField")

    def test_builtin_fields(self):
        self.assertEqual(
            views.get_readable_field_data_type(fields.BooleanField()),
            "Boolean (Either True or False)",
        )

    def test_char_fields(self):
        self.assertEqual(
            views.get_readable_field_data_type(fields.CharField(max_length=255)),
            "String (up to 255)",
        )
        self.assertEqual(
            views.get_readable_field_data_type(fields.CharField()),
            "String (unlimited)",
        )

    def test_custom_fields(self):
        self.assertEqual(
            views.get_readable_field_data_type(CustomField()), "A custom field type"
        )
        self.assertEqual(
            views.get_readable_field_data_type(DescriptionLackingField()),
            "Field of type: DescriptionLackingField",
        )


class AdminDocViewFunctionsTests(SimpleTestCase):
    def test_simplify_regex(self):
        tests = (
            # Named and unnamed groups.
            (r"^(?P<a>\w+)/b/(?P<c>\w+)/$", "/<a>/b/<c>/"),
            (r"^(?P<a>\w+)/b/(?P<c>\w+)$", "/<a>/b/<c>"),
            (r"^(?P<a>\w+)/b/(?P<c>\w+)", "/<a>/b/<c>"),
            (r"^(?P<a>\w+)/b/(\w+)$", "/<a>/b/<var>"),
            (r"^(?P<a>\w+)/b/(\w+)", "/<a>/b/<var>"),
            (r"^(?P<a>\w+)/b/((x|y)\w+)$", "/<a>/b/<var>"),
            (r"^(?P<a>\w+)/b/((x|y)\w+)", "/<a>/b/<var>"),
            (r"^(?P<a>(x|y))/b/(?P<c>\w+)$", "/<a>/b/<c>"),
            (r"^(?P<a>(x|y))/b/(?P<c>\w+)", "/<a>/b/<c>"),
            (r"^(?P<a>(x|y))/b/(?P<c>\w+)ab", "/<a>/b/<c>ab"),
            (r"^(?P<a>(x|y)(\(|\)))/b/(?P<c>\w+)ab", "/<a>/b/<c>ab"),
            # Non-capturing groups.
            (r"^a(?:\w+)b", "/ab"),
            (r"^a(?:(x|y))", "/a"),
            (r"^(?:\w+(?:\w+))a", "/a"),
            (r"^a(?:\w+)/b(?:\w+)", "/a/b"),
            (r"(?P<a>\w+)/b/(?:\w+)c(?:\w+)", "/<a>/b/c"),
            (r"(?P<a>\w+)/b/(\w+)/(?:\w+)c(?:\w+)", "/<a>/b/<var>/c"),
            # Single and repeated metacharacters.
            (r"^a", "/a"),
            (r"^^a", "/a"),
            (r"^^^a", "/a"),
            (r"a$", "/a"),
            (r"a$$", "/a"),
            (r"a$$$", "/a"),
            (r"a?", "/a"),
            (r"a??", "/a"),
            (r"a???", "/a"),
            (r"a*", "/a"),
            (r"a**", "/a"),
            (r"a***", "/a"),
            (r"a+", "/a"),
            (r"a++", "/a"),
            (r"a+++", "/a"),
            (r"\Aa", "/a"),
            (r"\A\Aa", "/a"),
            (r"\A\A\Aa", "/a"),
            (r"a\Z", "/a"),
            (r"a\Z\Z", "/a"),
            (r"a\Z\Z\Z", "/a"),
            (r"\ba", "/a"),
            (r"\b\ba", "/a"),
            (r"\b\b\ba", "/a"),
            (r"a\B", "/a"),
            (r"a\B\B", "/a"),
            (r"a\B\B\B", "/a"),
            # Multiple mixed metacharacters.
            (r"^a/?$", "/a/"),
            (r"\Aa\Z", "/a"),
            (r"\ba\B", "/a"),
            # Escaped single metacharacters.
            (r"\^a", r"/^a"),
            (r"\\^a", r"/\\a"),
            (r"\\\^a", r"/\\^a"),
            (r"\\\\^a", r"/\\\\a"),
            (r"\\\\\^a", r"/\\\\^a"),
            (r"a\$", r"/a$"),
            (r"a\\$", r"/a\\"),
            (r"a\\\$", r"/a\\$"),
            (r"a\\\\$", r"/a\\\\"),
            (r"a\\\\\$", r"/a\\\\$"),
            (r"a\?", r"/a?"),
            (r"a\\?", r"/a\\"),
            (r"a\\\?", r"/a\\?"),
            (r"a\\\\?", r"/a\\\\"),
            (r"a\\\\\?", r"/a\\\\?"),
            (r"a\*", r"/a*"),
            (r"a\\*", r"/a\\"),
            (r"a\\\*", r"/a\\*"),
            (r"a\\\\*", r"/a\\\\"),
            (r"a\\\\\*", r"/a\\\\*"),
            (r"a\+", r"/a+"),
            (r"a\\+", r"/a\\"),
            (r"a\\\+", r"/a\\+"),
            (r"a\\\\+", r"/a\\\\"),
            (r"a\\\\\+", r"/a\\\\+"),
            (r"\\Aa", r"/\Aa"),
            (r"\\\Aa", r"/\\a"),
            (r"\\\\Aa", r"/\\\Aa"),
            (r"\\\\\Aa", r"/\\\\a"),
            (r"\\\\\\Aa", r"/\\\\\Aa"),
            (r"a\\Z", r"/a\Z"),
            (r"a\\\Z", r"/a\\"),
            (r"a\\\\Z", r"/a\\\Z"),
            (r"a\\\\\Z", r"/a\\\\"),
            (r"a\\\\\\Z", r"/a\\\\\Z"),
            # Escaped mixed metacharacters.
            (r"^a\?$", r"/a?"),
            (r"^a\\?$", r"/a\\"),
            (r"^a\\\?$", r"/a\\?"),
            (r"^a\\\\?$", r"/a\\\\"),
            (r"^a\\\\\?$", r"/a\\\\?"),
            # Adjacent escaped metacharacters.
            (r"^a\?\$", r"/a?$"),
            (r"^a\\?\\$", r"/a\\\\"),
            (r"^a\\\?\\\$", r"/a\\?\\$"),
            (r"^a\\\\?\\\\$", r"/a\\\\\\\\"),
            (r"^a\\\\\?\\\\\$", r"/a\\\\?\\\\$"),
            # Complex examples with metacharacters and (un)named groups.
            (r"^\b(?P<slug>\w+)\B/(\w+)?", "/<slug>/<var>"),
            (r"^\A(?P<slug>\w+)\Z", "/<slug>"),
        )
        for pattern, output in tests:
            with self.subTest(pattern=pattern):
                self.assertEqual(simplify_regex(pattern), output)

	import sys
	import unittest

	from django.conf import settings
	from django.contrib import admin
	from django.contrib.admindocs import utils, views
	from django.contrib.admindocs.views import get_return_data_type, simplify_regex
	from django.contrib.sites.models import Site
	from django.db import models
	from django.db.models import fields
	from django.test import SimpleTestCase, modify_settings, override_settings
	from django.test.utils import captured_stderr
	from django.urls import include, path, reverse
	from django.utils.functional import SimpleLazyObject

	from .models import Company, Person
	from .tests import AdminDocsTestCase, TestDataMixin


	@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
	class AdminDocViewTests(TestDataMixin, AdminDocsTestCase):
	def setUp(self):
	self.client.force_login(self.superuser)

	def test_index(self):
	response = self.client.get(reverse("django-admindocs-docroot"))
	self.assertContains(response, "<h1>Documentation</h1>", html=True)
	self.assertContains(
	response,
	'<div id="site-name"><a href="/admin/">Django administration</a></div>',
	)
	self.client.logout()
	response = self.client.get(reverse("django-admindocs-docroot"), follow=True)
	# Should display the login screen
	self.assertContains(
	response, '<input type="hidden" name="next" value="/admindocs/">', html=True
	)

	def test_bookmarklets(self):
	response = self.client.get(reverse("django-admindocs-bookmarklets"))
	self.assertContains(response, "/admindocs/views/")

	def test_templatetag_index(self):
	response = self.client.get(reverse("django-admindocs-tags"))
	self.assertContains(
	response, '<h3 id="built_in-extends">extends</h3>', html=True
	)

	def test_templatefilter_index(self):
	response = self.client.get(reverse("django-admindocs-filters"))
	self.assertContains(response, '<h3 id="built_in-first">first</h3>', html=True)

	def test_view_index(self):
	response = self.client.get(reverse("django-admindocs-views-index"))
	self.assertContains(
	response,
	'<h3><a href="/admindocs/views/django.contrib.admindocs.views.'
	'BaseAdminDocsView/">/admindocs/</a></h3>',
	html=True,
	)
	self.assertContains(response, "Views by namespace test")
	self.assertContains(response, "Name: <code>test:func</code>.")
	self.assertContains(
	response,
	'<h3><a href="/admindocs/views/admin_docs.views.XViewCallableObject/">'
	"/xview/callable_object_without_xview/</a></h3>",
	html=True,
	)

	def test_view_index_with_method(self):
	"""
	Views that are methods are listed correctly.
	"""
	response = self.client.get(reverse("django-admindocs-views-index"))
	self.assertContains(
	response,
	"<h3>"
	'<a href="/admindocs/views/django.contrib.admin.sites.AdminSite.index/">'
	"/admin/</a></h3>",
	html=True,
	)

	def test_view_detail(self):
	url = reverse(
	"django-admindocs-views-detail",
	args=["django.contrib.admindocs.views.BaseAdminDocsView"],
	)
	response = self.client.get(url)
	# View docstring
	self.assertContains(response, "Base view for admindocs views.")

	@override_settings(ROOT_URLCONF="admin_docs.namespace_urls")
	def test_namespaced_view_detail(self):
	url = reverse(
	"django-admindocs-views-detail", args=["admin_docs.views.XViewClass"]
	)
	response = self.client.get(url)
	self.assertContains(response, "<h1>admin_docs.views.XViewClass</h1>")

	def test_view_detail_illegal_import(self):
	url = reverse(
	"django-admindocs-views-detail",
	args=["urlpatterns_reverse.nonimported_module.view"],
	)
	response = self.client.get(url)
	self.assertEqual(response.status_code, 404)
	self.assertNotIn("urlpatterns_reverse.nonimported_module", sys.modules)

	def test_view_detail_as_method(self):
	"""
	Views that are methods can be displayed.
	"""
	url = reverse(
	"django-admindocs-views-detail",
	args=["django.contrib.admin.sites.AdminSite.index"],
	)
	response = self.client.get(url)
	self.assertEqual(response.status_code, 200)

	def test_model_index(self):
	response = self.client.get(reverse("django-admindocs-models-index"))
	self.assertContains(
	response,
	'<h2 id="app-auth">Authentication and Authorization (django.contrib.auth)'
	"</h2>",
	html=True,
	)

	def test_template_detail(self):
	response = self.client.get(
	reverse(
	"django-admindocs-templates", args=["admin_doc/template_detail.html"]
	)
	)
	self.assertContains(
	response,
	"<h1>Template: <q>admin_doc/template_detail.html</q></h1>",
	html=True,
	)

	def test_missing_docutils(self):
	utils.docutils_is_available = False
	try:
	response = self.client.get(reverse("django-admindocs-docroot"))
	self.assertContains(
	response,
	"<h3>The admin documentation system requires Python’s "
	'<a href="https://docutils.sourceforge.io/">docutils</a> '
	"library.</h3>"
	"<p>Please ask your administrators to install "
	'<a href="https://pypi.org/project/docutils/">docutils</a>.</p>',
	html=True,
	)
	self.assertContains(
	response,
	'<div id="site-name"><a href="/admin/">Django administration</a></div>',
	)
	finally:
	utils.docutils_is_available = True

	@modify_settings(INSTALLED_APPS={"remove": "django.contrib.sites"})
	@override_settings(SITE_ID=None) # will restore SITE_ID after the test
	def test_no_sites_framework(self):
	"""
	Without the sites framework, should not access SITE_ID or Site
	objects. Deleting settings is fine here as UserSettingsHolder is used.
	"""
	Site.objects.all().delete()
	del settings.SITE_ID
	response = self.client.get(reverse("django-admindocs-views-index"))
	self.assertContains(response, "View documentation")

	def test_callable_urlconf(self):
	"""
	Index view should correctly resolve view patterns when ROOT_URLCONF is
	not a string.
	"""

	def urlpatterns():
	return (
	path("admin/doc/", include("django.contrib.admindocs.urls")),
	path("admin/", admin.site.urls),
	)

	with self.settings(ROOT_URLCONF=SimpleLazyObject(urlpatterns)):
	response = self.client.get(reverse("django-admindocs-views-index"))
	self.assertEqual(response.status_code, 200)


	@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
	class AdminDocViewDefaultEngineOnly(TestDataMixin, AdminDocsTestCase):
	def setUp(self):
	self.client.force_login(self.superuser)

	def test_template_detail_path_traversal(self):
	cases = ["/etc/passwd", "../passwd"]
	for fpath in cases:
	with self.subTest(path=fpath):
	response = self.client.get(
	reverse("django-admindocs-templates", args=[fpath]),
	)
	self.assertEqual(response.status_code, 400)


	@override_settings(
	TEMPLATES=[
	{
	"NAME": "ONE",
	"BACKEND": "django.template.backends.django.DjangoTemplates",
	"APP_DIRS": True,
	},
	{
	"NAME": "TWO",
	"BACKEND": "django.template.backends.django.DjangoTemplates",
	"APP_DIRS": True,
	},
	]
	)
	@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
	class AdminDocViewWithMultipleEngines(AdminDocViewTests):
	def test_templatefilter_index(self):
	# Overridden because non-trivial TEMPLATES settings aren't supported
	# but the page shouldn't crash (#24125).
	response = self.client.get(reverse("django-admindocs-filters"))
	self.assertContains(response, "<title>Template filters</title>", html=True)

	def test_templatetag_index(self):
	# Overridden because non-trivial TEMPLATES settings aren't supported
	# but the page shouldn't crash (#24125).
	response = self.client.get(reverse("django-admindocs-tags"))
	self.assertContains(response, "<title>Template tags</title>", html=True)


	@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.")
	class TestModelDetailView(TestDataMixin, AdminDocsTestCase):
	def setUp(self):
	self.client.force_login(self.superuser)
	with captured_stderr() as self.docutils_stderr:
	self.response = self.client.get(
	reverse("django-admindocs-models-detail", args=["admin_docs", "Person"])
	)

	def test_method_excludes(self):
	"""
	Methods that begin with strings defined in
	``django.contrib.admindocs.views.MODEL_METHODS_EXCLUDE``
	shouldn't be displayed in the admin docs.
	"""
	self.assertContains(self.response, "<td>get_full_name</td>")
	self.assertNotContains(self.response, "<td>_get_full_name</td>")
	self.assertNotContains(self.response, "<td>add_image</td>")
	self.assertNotContains(self.response, "<td>delete_image</td>")
	self.assertNotContains(self.response, "<td>set_status</td>")
	self.assertNotContains(self.response, "<td>save_changes</td>")

	def test_methods_with_arguments(self):
	"""
	Methods that take arguments should also displayed.
	"""
	self.assertContains(self.response, "<h3>Methods with arguments</h3>")
	self.assertContains(self.response, "<td>rename_company</td>")
	self.assertContains(self.response, "<td>dummy_function</td>")
	self.assertContains(self.response, "<td>suffix_company_name</td>")

	def test_methods_with_arguments_display_arguments(self):
	"""
	Methods with arguments should have their arguments displayed.
	"""
	self.assertContains(self.response, "<td>new_name</td>")

	def test_methods_with_arguments_display_arguments_default_value(self):
	"""
	Methods with keyword arguments should have their arguments displayed.
	"""
	self.assertContains(self.response, "<td>suffix='ltd'</td>")

	def test_methods_with_multiple_arguments_display_arguments(self):
	"""
	Methods with multiple arguments should have all their arguments
	displayed, but omitting 'self'.
	"""
	self.assertContains(
	self.response, "<td>baz, rox, some_args, *some_kwargs</td>"
	)

	def test_instance_of_property_methods_are_displayed(self):
	"""Model properties are displayed as fields."""
	self.assertContains(self.response, "<td>a_property</td>")

	def test_instance_of_cached_property_methods_are_displayed(self):
	"""Model cached properties are displayed as fields."""
	self.assertContains(self.response, "<td>a_cached_property</td>")

	def test_method_data_types(self):
	company = Company.objects.create(name="Django")
	person = Person.objects.create(
	first_name="Human", last_name="User", company=company
	)
	self.assertEqual(
	get_return_data_type(person.get_status_count.__name__), "Integer"
	)
	self.assertEqual(get_return_data_type(person.get_groups_list.__name__), "List")

	def test_descriptions_render_correctly(self):
	"""
	The ``description`` field should render correctly for each field type.
	"""
	# help text in fields
	self.assertContains(
	self.response, "<td>first name - The person's first name</td>"
	)
	self.assertContains(
	self.response, "<td>last name - The person's last name</td>"
	)

	# method docstrings
	self.assertContains(self.response, "<p>Get the full name of the person</p>")

	link = '<a class="reference external" href="/admindocs/models/%s/">%s</a>'
	markup = "<p>the related %s object</p>"
	company_markup = markup % (link % ("admin_docs.company", "admin_docs.Company"))

	# foreign keys
	self.assertContains(self.response, company_markup)

	# foreign keys with help text
	self.assertContains(self.response, "%s\n - place of work" % company_markup)

	# many to many fields
	self.assertContains(
	self.response,
	"number of related %s objects"
	% (link % ("admin_docs.group", "admin_docs.Group")),
	)
	self.assertContains(
	self.response,
	"all related %s objects"
	% (link % ("admin_docs.group", "admin_docs.Group")),
	)

	# "raw" and "include" directives are disabled
	self.assertContains(
	self.response,
	"<p>"raw" directive disabled.</p>",
	)
	self.assertContains(
	self.response, ".. raw:: html\n :file: admin_docs/evilfile.txt"
	)
	self.assertContains(
	self.response,
	"<p>"include" directive disabled.</p>",
	)
	self.assertContains(self.response, ".. include:: admin_docs/evilfile.txt")
	out = self.docutils_stderr.getvalue()
	self.assertIn('"raw" directive disabled', out)
	self.assertIn('"include" directive disabled', out)

	def test_model_with_many_to_one(self):
	link = '<a class="reference external" href="/admindocs/models/%s/">%s</a>'
	response = self.client.get(
	reverse("django-admindocs-models-detail", args=["admin_docs", "company"])
	)
	self.assertContains(
	response,
	"number of related %s objects"
	% (link % ("admin_docs.person", "admin_docs.Person")),
	)
	self.assertContains(
	response,
	"all related %s objects"
	% (link % ("admin_docs.person", "admin_docs.Person")),
	)

	def test_model_with_no_backward_relations_render_only_relevant_fields(self):
	"""
	A model with ``related_name`` of `+` shouldn't show backward
	relationship links.
	"""
	response = self.client.get(
	reverse("django-admindocs-models-detail", args=["admin_docs", "family"])
	)
	fields = response.context_data.get("fields")
	self.assertEqual(len(fields), 2)

	def test_model_docstring_renders_correctly(self):
	summary = (
	'<h2 class="subhead"><p>Stores information about a person, related to '
	'<a class="reference external" href="/admindocs/models/myapp.company/">'
	"myapp.Company</a>.</p></h2>"
	)
	subheading = "<p><strong>Notes</strong></p>"
	body = (
	'<p>Use <tt class="docutils literal">save_changes()</tt> when saving this '
	"object.</p>"
	)
	model_body = (
	'<dl class="docutils"><dt><tt class="'
	'docutils literal">company</tt></dt><dd>Field storing <a class="'
	'reference external" href="/admindocs/models/myapp.company/">'
	"myapp.Company</a> where the person works.</dd></dl>"
	)
	self.assertContains(self.response, "DESCRIPTION")
	self.assertContains(self.response, summary, html=True)
	self.assertContains(self.response, subheading, html=True)
	self.assertContains(self.response, body, html=True)
	self.assertContains(self.response, model_body, html=True)

	def test_model_detail_title(self):
	self.assertContains(self.response, "<h1>admin_docs.Person</h1>", html=True)

	def test_app_not_found(self):
	response = self.client.get(
	reverse("django-admindocs-models-detail", args=["doesnotexist", "Person"])
	)
	self.assertEqual(response.context["exception"], "App 'doesnotexist' not found")
	self.assertEqual(response.status_code, 404)

	def test_model_not_found(self):
	response = self.client.get(
	reverse(
	"django-admindocs-models-detail", args=["admin_docs", "doesnotexist"]
	)
	)
	self.assertEqual(
	response.context["exception"],
	"Model 'doesnotexist' not found in app 'admin_docs'",
	)
	self.assertEqual(response.status_code, 404)


	class CustomField(models.Field):
	description = "A custom field type"


	class DescriptionLackingField(models.Field):
	pass


	class TestFieldType(unittest.TestCase):
	def test_field_name(self):
	with self.assertRaises(AttributeError):
	views.get_readable_field_data_type("NotAField")

	def test_builtin_fields(self):
	self.assertEqual(
	views.get_readable_field_data_type(fields.BooleanField()),
	"Boolean (Either True or False)",
	)

	def test_char_fields(self):
	self.assertEqual(
	views.get_readable_field_data_type(fields.CharField(max_length=255)),
	"String (up to 255)",
	)
	self.assertEqual(
	views.get_readable_field_data_type(fields.CharField()),
	"String (unlimited)",
	)

	def test_custom_fields(self):
	self.assertEqual(
	views.get_readable_field_data_type(CustomField()), "A custom field type"
	)
	self.assertEqual(
	views.get_readable_field_data_type(DescriptionLackingField()),
	"Field of type: DescriptionLackingField",
	)


	class AdminDocViewFunctionsTests(SimpleTestCase):
	def test_simplify_regex(self):
	tests = (
	# Named and unnamed groups.
	(r"^(?P<a>\w+)/b/(?P<c>\w+)/$", "/<a>/b/<c>/"),
	(r"^(?P<a>\w+)/b/(?P<c>\w+)$", "/<a>/b/<c>"),
	(r"^(?P<a>\w+)/b/(?P<c>\w+)", "/<a>/b/<c>"),
	(r"^(?P<a>\w+)/b/(\w+)$", "/<a>/b/<var>"),
	(r"^(?P<a>\w+)/b/(\w+)", "/<a>/b/<var>"),
	(r"^(?P<a>\w+)/b/((x\|y)\w+)$", "/<a>/b/<var>"),
	(r"^(?P<a>\w+)/b/((x\|y)\w+)", "/<a>/b/<var>"),
	(r"^(?P<a>(x\|y))/b/(?P<c>\w+)$", "/<a>/b/<c>"),
	(r"^(?P<a>(x\|y))/b/(?P<c>\w+)", "/<a>/b/<c>"),
	(r"^(?P<a>(x\|y))/b/(?P<c>\w+)ab", "/<a>/b/<c>ab"),
	(r"^(?P<a>(x\|y)(\(\|\)))/b/(?P<c>\w+)ab", "/<a>/b/<c>ab"),
	# Non-capturing groups.
	(r"^a(?:\w+)b", "/ab"),
	(r"^a(?:(x\|y))", "/a"),
	(r"^(?:\w+(?:\w+))a", "/a"),
	(r"^a(?:\w+)/b(?:\w+)", "/a/b"),
	(r"(?P<a>\w+)/b/(?:\w+)c(?:\w+)", "/<a>/b/c"),
	(r"(?P<a>\w+)/b/(\w+)/(?:\w+)c(?:\w+)", "/<a>/b/<var>/c"),
	# Single and repeated metacharacters.
	(r"^a", "/a"),
	(r"^^a", "/a"),
	(r"^^^a", "/a"),
	(r"a$", "/a"),
	(r"a$$", "/a"),
	(r"a$$$", "/a"),
	(r"a?", "/a"),
	(r"a??", "/a"),
	(r"a???", "/a"),
	(r"a*", "/a"),
	(r"a**", "/a"),
	(r"a***", "/a"),
	(r"a+", "/a"),
	(r"a++", "/a"),
	(r"a+++", "/a"),
	(r"\Aa", "/a"),
	(r"\A\Aa", "/a"),
	(r"\A\A\Aa", "/a"),
	(r"a\Z", "/a"),
	(r"a\Z\Z", "/a"),
	(r"a\Z\Z\Z", "/a"),
	(r"\ba", "/a"),
	(r"\b\ba", "/a"),
	(r"\b\b\ba", "/a"),
	(r"a\B", "/a"),
	(r"a\B\B", "/a"),
	(r"a\B\B\B", "/a"),
	# Multiple mixed metacharacters.
	(r"^a/?$", "/a/"),
	(r"\Aa\Z", "/a"),
	(r"\ba\B", "/a"),
	# Escaped single metacharacters.
	(r"\^a", r"/^a"),
	(r"\\^a", r"/\\a"),
	(r"\\\^a", r"/\\^a"),
	(r"\\\\^a", r"/\\\\a"),
	(r"\\\\\^a", r"/\\\\^a"),
	(r"a\$", r"/a$"),
	(r"a\\$", r"/a\\"),
	(r"a\\\$", r"/a\\$"),
	(r"a\\\\$", r"/a\\\\"),
	(r"a\\\\\$", r"/a\\\\$"),
	(r"a\?", r"/a?"),
	(r"a\\?", r"/a\\"),
	(r"a\\\?", r"/a\\?"),
	(r"a\\\\?", r"/a\\\\"),
	(r"a\\\\\?", r"/a\\\\?"),
	(r"a\", r"/a"),
	(r"a\\*", r"/a\\"),
	(r"a\\\", r"/a\\"),
	(r"a\\\\*", r"/a\\\\"),
	(r"a\\\\\", r"/a\\\\"),
	(r"a\+", r"/a+"),
	(r"a\\+", r"/a\\"),
	(r"a\\\+", r"/a\\+"),
	(r"a\\\\+", r"/a\\\\"),
	(r"a\\\\\+", r"/a\\\\+"),
	(r"\\Aa", r"/\Aa"),
	(r"\\\Aa", r"/\\a"),
	(r"\\\\Aa", r"/\\\Aa"),
	(r"\\\\\Aa", r"/\\\\a"),
	(r"\\\\\\Aa", r"/\\\\\Aa"),
	(r"a\\Z", r"/a\Z"),
	(r"a\\\Z", r"/a\\"),
	(r"a\\\\Z", r"/a\\\Z"),
	(r"a\\\\\Z", r"/a\\\\"),
	(r"a\\\\\\Z", r"/a\\\\\Z"),
	# Escaped mixed metacharacters.
	(r"^a\?$", r"/a?"),
	(r"^a\\?$", r"/a\\"),
	(r"^a\\\?$", r"/a\\?"),
	(r"^a\\\\?$", r"/a\\\\"),
	(r"^a\\\\\?$", r"/a\\\\?"),
	# Adjacent escaped metacharacters.
	(r"^a\?\$", r"/a?$"),
	(r"^a\\?\\$", r"/a\\\\"),
	(r"^a\\\?\\\$", r"/a\\?\\$"),
	(r"^a\\\\?\\\\$", r"/a\\\\\\\\"),
	(r"^a\\\\\?\\\\\$", r"/a\\\\?\\\\$"),
	# Complex examples with metacharacters and (un)named groups.
	(r"^\b(?P<slug>\w+)\B/(\w+)?", "/<slug>/<var>"),
	(r"^\A(?P<slug>\w+)\Z", "/<slug>"),
	)
	for pattern, output in tests:
	with self.subTest(pattern=pattern):
	self.assertEqual(simplify_regex(pattern), output)