| 1 |
import sys |
| 2 |
import unittest |
| 3 |
|
| 4 |
from django.conf import settings |
| 5 |
from django.contrib import admin |
| 6 |
from django.contrib.admindocs import utils, views |
| 7 |
from django.contrib.admindocs.views import get_return_data_type, simplify_regex |
| 8 |
from django.contrib.auth.models import Permission, User |
| 9 |
from django.contrib.contenttypes.models import ContentType |
| 10 |
from django.contrib.sites.models import Site |
| 11 |
from django.db import models |
| 12 |
from django.db.models import fields |
| 13 |
from django.test import SimpleTestCase, modify_settings, override_settings |
| 14 |
from django.test.utils import captured_stderr |
| 15 |
from django.urls import include, path, reverse |
| 16 |
from django.utils.functional import SimpleLazyObject |
| 17 |
|
| 18 |
from .models import Company, Person |
| 19 |
from .tests import AdminDocsTestCase, TestDataMixin |
| 20 |
|
| 21 |
|
| 22 |
@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.") |
| 23 |
class AdminDocViewTests(TestDataMixin, AdminDocsTestCase): |
| 24 |
def setUp(self): |
| 25 |
self.client.force_login(self.superuser) |
| 26 |
|
| 27 |
def test_index(self): |
| 28 |
response = self.client.get(reverse("django-admindocs-docroot")) |
| 29 |
self.assertContains(response, "<h1>Documentation</h1>", html=True) |
| 30 |
self.assertContains( |
| 31 |
response, |
| 32 |
'<div id="site-name"><a href="/admin/">Django administration</a></div>', |
| 33 |
) |
| 34 |
self.client.logout() |
| 35 |
response = self.client.get(reverse("django-admindocs-docroot"), follow=True) |
| 36 |
# Should display the login screen |
| 37 |
self.assertContains( |
| 38 |
response, '<input type="hidden" name="next" value="/admindocs/">', html=True |
| 39 |
) |
| 40 |
|
| 41 |
def test_bookmarklets(self): |
| 42 |
response = self.client.get(reverse("django-admindocs-bookmarklets")) |
| 43 |
self.assertContains(response, "/admindocs/views/") |
| 44 |
|
| 45 |
def test_templatetag_index(self): |
| 46 |
response = self.client.get(reverse("django-admindocs-tags")) |
| 47 |
self.assertContains( |
| 48 |
response, '<h3 id="built_in-extends">extends</h3>', html=True |
| 49 |
) |
| 50 |
|
| 51 |
def test_templatefilter_index(self): |
| 52 |
response = self.client.get(reverse("django-admindocs-filters")) |
| 53 |
self.assertContains(response, '<h3 id="built_in-first">first</h3>', html=True) |
| 54 |
|
| 55 |
def test_view_index(self): |
| 56 |
response = self.client.get(reverse("django-admindocs-views-index")) |
| 57 |
self.assertContains( |
| 58 |
response, |
| 59 |
'<h3><a href="/admindocs/views/django.contrib.admindocs.views.' |
| 60 |
'BaseAdminDocsView/">/admindocs/</a></h3>', |
| 61 |
html=True, |
| 62 |
) |
| 63 |
self.assertContains(response, "Views by namespace test") |
| 64 |
self.assertContains(response, "Name: <code>test:func</code>.") |
| 65 |
self.assertContains( |
| 66 |
response, |
| 67 |
'<h3><a href="/admindocs/views/admin_docs.views.XViewCallableObject/">' |
| 68 |
"/xview/callable_object_without_xview/</a></h3>", |
| 69 |
html=True, |
| 70 |
) |
| 71 |
|
| 72 |
def test_view_index_with_method(self): |
| 73 |
""" |
| 74 |
Views that are methods are listed correctly. |
| 75 |
""" |
| 76 |
response = self.client.get(reverse("django-admindocs-views-index")) |
| 77 |
self.assertContains( |
| 78 |
response, |
| 79 |
"<h3>" |
| 80 |
'<a href="/admindocs/views/django.contrib.admin.sites.AdminSite.index/">' |
| 81 |
"/admin/</a></h3>", |
| 82 |
html=True, |
| 83 |
) |
| 84 |
|
| 85 |
def test_view_detail(self): |
| 86 |
url = reverse( |
| 87 |
"django-admindocs-views-detail", |
| 88 |
args=["django.contrib.admindocs.views.BaseAdminDocsView"], |
| 89 |
) |
| 90 |
response = self.client.get(url) |
| 91 |
# View docstring |
| 92 |
self.assertContains(response, "Base view for admindocs views.") |
| 93 |
|
| 94 |
def testview_docstring_links(self): |
| 95 |
summary = ( |
| 96 |
'<h2 class="subhead">This is a view for ' |
| 97 |
'<a class="reference external" href="/admindocs/models/myapp.company/">' |
| 98 |
"myapp.Company</a></h2>" |
| 99 |
) |
| 100 |
url = reverse( |
| 101 |
"django-admindocs-views-detail", args=["admin_docs.views.CompanyView"] |
| 102 |
) |
| 103 |
response = self.client.get(url) |
| 104 |
self.assertContains(response, summary, html=True) |
| 105 |
|
| 106 |
@override_settings(ROOT_URLCONF="admin_docs.namespace_urls") |
| 107 |
def test_namespaced_view_detail(self): |
| 108 |
url = reverse( |
| 109 |
"django-admindocs-views-detail", args=["admin_docs.views.XViewClass"] |
| 110 |
) |
| 111 |
response = self.client.get(url) |
| 112 |
self.assertContains(response, "<h1>admin_docs.views.XViewClass</h1>") |
| 113 |
|
| 114 |
def test_view_detail_illegal_import(self): |
| 115 |
url = reverse( |
| 116 |
"django-admindocs-views-detail", |
| 117 |
args=["urlpatterns_reverse.nonimported_module.view"], |
| 118 |
) |
| 119 |
response = self.client.get(url) |
| 120 |
self.assertEqual(response.status_code, 404) |
| 121 |
self.assertNotIn("urlpatterns_reverse.nonimported_module", sys.modules) |
| 122 |
|
| 123 |
def test_view_detail_as_method(self): |
| 124 |
""" |
| 125 |
Views that are methods can be displayed. |
| 126 |
""" |
| 127 |
url = reverse( |
| 128 |
"django-admindocs-views-detail", |
| 129 |
args=["django.contrib.admin.sites.AdminSite.index"], |
| 130 |
) |
| 131 |
response = self.client.get(url) |
| 132 |
self.assertEqual(response.status_code, 200) |
| 133 |
|
| 134 |
def test_model_index(self): |
| 135 |
response = self.client.get(reverse("django-admindocs-models-index")) |
| 136 |
self.assertContains( |
| 137 |
response, |
| 138 |
'<h2 id="app-auth">Authentication and Authorization (django.contrib.auth)' |
| 139 |
"</h2>", |
| 140 |
html=True, |
| 141 |
) |
| 142 |
|
| 143 |
def test_template_detail(self): |
| 144 |
response = self.client.get( |
| 145 |
reverse( |
| 146 |
"django-admindocs-templates", args=["admin_doc/template_detail.html"] |
| 147 |
) |
| 148 |
) |
| 149 |
self.assertContains( |
| 150 |
response, |
| 151 |
"<h1>Template: <q>admin_doc/template_detail.html</q></h1>", |
| 152 |
html=True, |
| 153 |
) |
| 154 |
|
| 155 |
def test_template_detail_loader(self): |
| 156 |
response = self.client.get( |
| 157 |
reverse("django-admindocs-templates", args=["view_for_loader_test.html"]) |
| 158 |
) |
| 159 |
self.assertContains(response, "view_for_loader_test.html</code></li>") |
| 160 |
|
| 161 |
def test_missing_docutils(self): |
| 162 |
utils.docutils_is_available = False |
| 163 |
try: |
| 164 |
response = self.client.get(reverse("django-admindocs-docroot")) |
| 165 |
self.assertContains( |
| 166 |
response, |
| 167 |
"<h3>The admin documentation system requires Python’s " |
| 168 |
'<a href="https://docutils.sourceforge.io/">docutils</a> ' |
| 169 |
"library.</h3>" |
| 170 |
"<p>Please ask your administrators to install " |
| 171 |
'<a href="https://pypi.org/project/docutils/">docutils</a>.</p>', |
| 172 |
html=True, |
| 173 |
) |
| 174 |
self.assertContains( |
| 175 |
response, |
| 176 |
'<div id="site-name"><a href="/admin/">Django administration</a></div>', |
| 177 |
) |
| 178 |
finally: |
| 179 |
utils.docutils_is_available = True |
| 180 |
|
| 181 |
@modify_settings(INSTALLED_APPS={"remove": "django.contrib.sites"}) |
| 182 |
@override_settings(SITE_ID=None) # will restore SITE_ID after the test |
| 183 |
def test_no_sites_framework(self): |
| 184 |
""" |
| 185 |
Without the sites framework, should not access SITE_ID or Site |
| 186 |
objects. Deleting settings is fine here as UserSettingsHolder is used. |
| 187 |
""" |
| 188 |
Site.objects.all().delete() |
| 189 |
del settings.SITE_ID |
| 190 |
response = self.client.get(reverse("django-admindocs-views-index")) |
| 191 |
self.assertContains(response, "View documentation") |
| 192 |
|
| 193 |
def test_callable_urlconf(self): |
| 194 |
""" |
| 195 |
Index view should correctly resolve view patterns when ROOT_URLCONF is |
| 196 |
not a string. |
| 197 |
""" |
| 198 |
|
| 199 |
def urlpatterns(): |
| 200 |
return ( |
| 201 |
path("admin/doc/", include("django.contrib.admindocs.urls")), |
| 202 |
path("admin/", admin.site.urls), |
| 203 |
) |
| 204 |
|
| 205 |
with self.settings(ROOT_URLCONF=SimpleLazyObject(urlpatterns)): |
| 206 |
response = self.client.get(reverse("django-admindocs-views-index")) |
| 207 |
self.assertEqual(response.status_code, 200) |
| 208 |
|
| 209 |
|
| 210 |
@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.") |
| 211 |
class AdminDocViewDefaultEngineOnly(TestDataMixin, AdminDocsTestCase): |
| 212 |
def setUp(self): |
| 213 |
self.client.force_login(self.superuser) |
| 214 |
|
| 215 |
def test_template_detail_path_traversal(self): |
| 216 |
cases = ["/etc/passwd", "../passwd"] |
| 217 |
for fpath in cases: |
| 218 |
with self.subTest(path=fpath): |
| 219 |
response = self.client.get( |
| 220 |
reverse("django-admindocs-templates", args=[fpath]), |
| 221 |
) |
| 222 |
self.assertEqual(response.status_code, 400) |
| 223 |
|
| 224 |
|
| 225 |
@override_settings( |
| 226 |
TEMPLATES=[ |
| 227 |
{ |
| 228 |
"NAME": "ONE", |
| 229 |
"BACKEND": "django.template.backends.django.DjangoTemplates", |
| 230 |
"APP_DIRS": True, |
| 231 |
}, |
| 232 |
{ |
| 233 |
"NAME": "TWO", |
| 234 |
"BACKEND": "django.template.backends.django.DjangoTemplates", |
| 235 |
"APP_DIRS": True, |
| 236 |
}, |
| 237 |
] |
| 238 |
) |
| 239 |
@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.") |
| 240 |
class AdminDocViewWithMultipleEngines(AdminDocViewTests): |
| 241 |
def test_templatefilter_index(self): |
| 242 |
# Overridden because non-trivial TEMPLATES settings aren't supported |
| 243 |
# but the page shouldn't crash (#24125). |
| 244 |
response = self.client.get(reverse("django-admindocs-filters")) |
| 245 |
self.assertContains(response, "<title>Template filters</title>", html=True) |
| 246 |
|
| 247 |
def test_templatetag_index(self): |
| 248 |
# Overridden because non-trivial TEMPLATES settings aren't supported |
| 249 |
# but the page shouldn't crash (#24125). |
| 250 |
response = self.client.get(reverse("django-admindocs-tags")) |
| 251 |
self.assertContains(response, "<title>Template tags</title>", html=True) |
| 252 |
|
| 253 |
|
| 254 |
@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.") |
| 255 |
class TestModelDetailView(TestDataMixin, AdminDocsTestCase): |
| 256 |
def setUp(self): |
| 257 |
self.client.force_login(self.superuser) |
| 258 |
with captured_stderr() as self.docutils_stderr: |
| 259 |
self.response = self.client.get( |
| 260 |
reverse("django-admindocs-models-detail", args=["admin_docs", "Person"]) |
| 261 |
) |
| 262 |
|
| 263 |
def test_table_headers(self): |
| 264 |
tests = [ |
| 265 |
("Method", 1), |
| 266 |
("Arguments", 1), |
| 267 |
("Description", 2), |
| 268 |
("Field", 1), |
| 269 |
("Type", 1), |
| 270 |
("Method", 1), |
| 271 |
] |
| 272 |
for table_header, count in tests: |
| 273 |
self.assertContains( |
| 274 |
self.response, f'<th scope="col">{table_header}</th>', count=count |
| 275 |
) |
| 276 |
|
| 277 |
def test_method_excludes(self): |
| 278 |
""" |
| 279 |
Methods that begin with strings defined in |
| 280 |
``django.contrib.admindocs.views.MODEL_METHODS_EXCLUDE`` |
| 281 |
shouldn't be displayed in the admin docs. |
| 282 |
""" |
| 283 |
self.assertContains(self.response, "<td>get_full_name</td>") |
| 284 |
self.assertNotContains(self.response, "<td>_get_full_name</td>") |
| 285 |
self.assertNotContains(self.response, "<td>add_image</td>") |
| 286 |
self.assertNotContains(self.response, "<td>delete_image</td>") |
| 287 |
self.assertNotContains(self.response, "<td>set_status</td>") |
| 288 |
self.assertNotContains(self.response, "<td>save_changes</td>") |
| 289 |
|
| 290 |
def test_methods_with_arguments(self): |
| 291 |
""" |
| 292 |
Methods that take arguments should also displayed. |
| 293 |
""" |
| 294 |
self.assertContains(self.response, "<h3>Methods with arguments</h3>") |
| 295 |
self.assertContains(self.response, "<td>rename_company</td>") |
| 296 |
self.assertContains(self.response, "<td>dummy_function</td>") |
| 297 |
self.assertContains(self.response, "<td>dummy_function_keyword_only_arg</td>") |
| 298 |
self.assertContains(self.response, "<td>all_kinds_arg_function</td>") |
| 299 |
self.assertContains(self.response, "<td>suffix_company_name</td>") |
| 300 |
|
| 301 |
def test_methods_with_arguments_display_arguments(self): |
| 302 |
""" |
| 303 |
Methods with arguments should have their arguments displayed. |
| 304 |
""" |
| 305 |
self.assertContains(self.response, "<td>new_name</td>") |
| 306 |
self.assertContains(self.response, "<td>keyword_only_arg</td>") |
| 307 |
|
| 308 |
def test_methods_with_arguments_display_arguments_default_value(self): |
| 309 |
""" |
| 310 |
Methods with keyword arguments should have their arguments displayed. |
| 311 |
""" |
| 312 |
self.assertContains(self.response, "<td>suffix='ltd'</td>") |
| 313 |
|
| 314 |
def test_methods_with_multiple_arguments_display_arguments(self): |
| 315 |
""" |
| 316 |
Methods with multiple arguments should have all their arguments |
| 317 |
displayed, but omitting 'self'. |
| 318 |
""" |
| 319 |
self.assertContains( |
| 320 |
self.response, "<td>baz, rox, *some_args, **some_kwargs</td>" |
| 321 |
) |
| 322 |
self.assertContains(self.response, "<td>position_only_arg, arg, kwarg</td>") |
| 323 |
|
| 324 |
def test_instance_of_property_methods_are_displayed(self): |
| 325 |
"""Model properties are displayed as fields.""" |
| 326 |
self.assertContains(self.response, "<td>a_property</td>") |
| 327 |
|
| 328 |
def test_instance_of_cached_property_methods_are_displayed(self): |
| 329 |
"""Model cached properties are displayed as fields.""" |
| 330 |
self.assertContains(self.response, "<td>a_cached_property</td>") |
| 331 |
|
| 332 |
def test_method_data_types(self): |
| 333 |
company = Company.objects.create(name="Django") |
| 334 |
person = Person.objects.create( |
| 335 |
first_name="Human", last_name="User", company=company |
| 336 |
) |
| 337 |
self.assertEqual( |
| 338 |
get_return_data_type(person.get_status_count.__name__), "Integer" |
| 339 |
) |
| 340 |
self.assertEqual(get_return_data_type(person.get_groups_list.__name__), "List") |
| 341 |
|
| 342 |
def test_descriptions_render_correctly(self): |
| 343 |
""" |
| 344 |
The ``description`` field should render correctly for each field type. |
| 345 |
""" |
| 346 |
# help text in fields |
| 347 |
self.assertContains( |
| 348 |
self.response, "<td>first name - The person's first name</td>" |
| 349 |
) |
| 350 |
self.assertContains( |
| 351 |
self.response, "<td>last name - The person's last name</td>" |
| 352 |
) |
| 353 |
|
| 354 |
# method docstrings |
| 355 |
self.assertContains(self.response, "<p>Get the full name of the person</p>") |
| 356 |
|
| 357 |
link = '<a class="reference external" href="/admindocs/models/%s/">%s</a>' |
| 358 |
markup = "<p>the related %s object</p>" |
| 359 |
company_markup = markup % (link % ("admin_docs.company", "admin_docs.Company")) |
| 360 |
|
| 361 |
# foreign keys |
| 362 |
self.assertContains(self.response, company_markup) |
| 363 |
|
| 364 |
# foreign keys with help text |
| 365 |
self.assertContains(self.response, "%s\n - place of work" % company_markup) |
| 366 |
|
| 367 |
# many to many fields |
| 368 |
self.assertContains( |
| 369 |
self.response, |
| 370 |
"number of related %s objects" |
| 371 |
% (link % ("admin_docs.group", "admin_docs.Group")), |
| 372 |
) |
| 373 |
self.assertContains( |
| 374 |
self.response, |
| 375 |
"all related %s objects" |
| 376 |
% (link % ("admin_docs.group", "admin_docs.Group")), |
| 377 |
) |
| 378 |
|
| 379 |
# "raw" and "include" directives are disabled |
| 380 |
self.assertContains( |
| 381 |
self.response, |
| 382 |
"<p>"raw" directive disabled.</p>", |
| 383 |
) |
| 384 |
self.assertContains( |
| 385 |
self.response, ".. raw:: html\n :file: admin_docs/evilfile.txt" |
| 386 |
) |
| 387 |
self.assertContains( |
| 388 |
self.response, |
| 389 |
"<p>"include" directive disabled.</p>", |
| 390 |
) |
| 391 |
self.assertContains(self.response, ".. include:: admin_docs/evilfile.txt") |
| 392 |
out = self.docutils_stderr.getvalue() |
| 393 |
self.assertIn('"raw" directive disabled', out) |
| 394 |
self.assertIn('"include" directive disabled', out) |
| 395 |
|
| 396 |
def test_model_with_many_to_one(self): |
| 397 |
link = '<a class="reference external" href="/admindocs/models/%s/">%s</a>' |
| 398 |
response = self.client.get( |
| 399 |
reverse("django-admindocs-models-detail", args=["admin_docs", "company"]) |
| 400 |
) |
| 401 |
self.assertContains( |
| 402 |
response, |
| 403 |
"number of related %s objects" |
| 404 |
% (link % ("admin_docs.person", "admin_docs.Person")), |
| 405 |
) |
| 406 |
self.assertContains( |
| 407 |
response, |
| 408 |
"all related %s objects" |
| 409 |
% (link % ("admin_docs.person", "admin_docs.Person")), |
| 410 |
) |
| 411 |
|
| 412 |
def test_model_with_no_backward_relations_render_only_relevant_fields(self): |
| 413 |
""" |
| 414 |
A model with ``related_name`` of `+` shouldn't show backward |
| 415 |
relationship links. |
| 416 |
""" |
| 417 |
response = self.client.get( |
| 418 |
reverse("django-admindocs-models-detail", args=["admin_docs", "family"]) |
| 419 |
) |
| 420 |
fields = response.context_data.get("fields") |
| 421 |
self.assertEqual(len(fields), 2) |
| 422 |
|
| 423 |
def test_model_docstring_renders_correctly(self): |
| 424 |
summary = ( |
| 425 |
'<h2 class="subhead">Stores information about a person, related to ' |
| 426 |
'<a class="reference external" href="/admindocs/models/myapp.company/">' |
| 427 |
"myapp.Company</a>.</h2>" |
| 428 |
) |
| 429 |
subheading = "<p><strong>Notes</strong></p>" |
| 430 |
body = ( |
| 431 |
'<p>Use <tt class="docutils literal">save_changes()</tt> when saving this ' |
| 432 |
"object.</p>" |
| 433 |
) |
| 434 |
model_body = ( |
| 435 |
'<dl class="docutils"><dt><tt class="' |
| 436 |
'docutils literal">company</tt></dt><dd>Field storing <a class="' |
| 437 |
'reference external" href="/admindocs/models/myapp.company/">' |
| 438 |
"myapp.Company</a> where the person works.</dd></dl>" |
| 439 |
) |
| 440 |
self.assertContains(self.response, "DESCRIPTION") |
| 441 |
self.assertContains(self.response, summary, html=True) |
| 442 |
self.assertContains(self.response, subheading, html=True) |
| 443 |
self.assertContains(self.response, body, html=True) |
| 444 |
self.assertContains(self.response, model_body, html=True) |
| 445 |
|
| 446 |
def test_model_docstring_built_in_tag_links(self): |
| 447 |
summary = "Links with different link text." |
| 448 |
body = ( |
| 449 |
'<p>This is a line with tag <a class="reference external" ' |
| 450 |
'href="/admindocs/tags/#built_in-extends">extends</a>\n' |
| 451 |
'This is a line with model <a class="reference external" ' |
| 452 |
'href="/admindocs/models/myapp.family/">Family</a>\n' |
| 453 |
'This is a line with view <a class="reference external" ' |
| 454 |
'href="/admindocs/views/myapp.views.Index/">Index</a>\n' |
| 455 |
'This is a line with template <a class="reference external" ' |
| 456 |
'href="/admindocs/templates/Index.html/">index template</a>\n' |
| 457 |
'This is a line with filter <a class="reference external" ' |
| 458 |
'href="/admindocs/filters/#filtername">example filter</a></p>' |
| 459 |
) |
| 460 |
url = reverse("django-admindocs-models-detail", args=["admin_docs", "family"]) |
| 461 |
response = self.client.get(url) |
| 462 |
self.assertContains(response, summary, html=True) |
| 463 |
self.assertContains(response, body, html=True) |
| 464 |
|
| 465 |
def test_model_detail_title(self): |
| 466 |
self.assertContains(self.response, "<h1>admin_docs.Person</h1>", html=True) |
| 467 |
|
| 468 |
def test_app_not_found(self): |
| 469 |
response = self.client.get( |
| 470 |
reverse("django-admindocs-models-detail", args=["doesnotexist", "Person"]) |
| 471 |
) |
| 472 |
self.assertEqual(response.context["exception"], "App 'doesnotexist' not found") |
| 473 |
self.assertEqual(response.status_code, 404) |
| 474 |
|
| 475 |
def test_model_not_found(self): |
| 476 |
response = self.client.get( |
| 477 |
reverse( |
| 478 |
"django-admindocs-models-detail", args=["admin_docs", "doesnotexist"] |
| 479 |
) |
| 480 |
) |
| 481 |
self.assertEqual( |
| 482 |
response.context["exception"], |
| 483 |
"Model 'doesnotexist' not found in app 'admin_docs'", |
| 484 |
) |
| 485 |
self.assertEqual(response.status_code, 404) |
| 486 |
|
| 487 |
def test_model_permission_denied(self): |
| 488 |
person_url = reverse( |
| 489 |
"django-admindocs-models-detail", args=["admin_docs", "person"] |
| 490 |
) |
| 491 |
company_url = reverse( |
| 492 |
"django-admindocs-models-detail", args=["admin_docs", "company"] |
| 493 |
) |
| 494 |
staff_user = User.objects.create_user( |
| 495 |
username="staff", password="secret", is_staff=True |
| 496 |
) |
| 497 |
self.client.force_login(staff_user) |
| 498 |
response_for_person = self.client.get(person_url) |
| 499 |
response_for_company = self.client.get(company_url) |
| 500 |
# No access without permissions. |
| 501 |
self.assertEqual(response_for_person.status_code, 403) |
| 502 |
self.assertEqual(response_for_company.status_code, 403) |
| 503 |
company_content_type = ContentType.objects.get_for_model(Company) |
| 504 |
person_content_type = ContentType.objects.get_for_model(Person) |
| 505 |
view_company = Permission.objects.get( |
| 506 |
codename="view_company", content_type=company_content_type |
| 507 |
) |
| 508 |
change_person = Permission.objects.get( |
| 509 |
codename="change_person", content_type=person_content_type |
| 510 |
) |
| 511 |
staff_user.user_permissions.add(view_company, change_person) |
| 512 |
with captured_stderr(): |
| 513 |
response_for_person = self.client.get(person_url) |
| 514 |
response_for_company = self.client.get(company_url) |
| 515 |
# View or change permission grants access. |
| 516 |
self.assertEqual(response_for_person.status_code, 200) |
| 517 |
self.assertEqual(response_for_company.status_code, 200) |
| 518 |
|
| 519 |
|
| 520 |
@unittest.skipUnless(utils.docutils_is_available, "no docutils installed.") |
| 521 |
class TestModelIndexView(TestDataMixin, AdminDocsTestCase): |
| 522 |
def test_model_index_superuser(self): |
| 523 |
self.client.force_login(self.superuser) |
| 524 |
index_url = reverse("django-admindocs-models-index") |
| 525 |
response = self.client.get(index_url) |
| 526 |
self.assertContains( |
| 527 |
response, |
| 528 |
'<a href="/admindocs/models/admin_docs.family/">Family</a>', |
| 529 |
html=True, |
| 530 |
) |
| 531 |
self.assertContains( |
| 532 |
response, |
| 533 |
'<a href="/admindocs/models/admin_docs.person/">Person</a>', |
| 534 |
html=True, |
| 535 |
) |
| 536 |
self.assertContains( |
| 537 |
response, |
| 538 |
'<a href="/admindocs/models/admin_docs.company/">Company</a>', |
| 539 |
html=True, |
| 540 |
) |
| 541 |
|
| 542 |
def test_model_index_with_model_permission(self): |
| 543 |
staff_user = User.objects.create_user( |
| 544 |
username="staff", password="secret", is_staff=True |
| 545 |
) |
| 546 |
self.client.force_login(staff_user) |
| 547 |
index_url = reverse("django-admindocs-models-index") |
| 548 |
response = self.client.get(index_url) |
| 549 |
# Models are not listed without permissions. |
| 550 |
self.assertNotContains( |
| 551 |
response, |
| 552 |
'<a href="/admindocs/models/admin_docs.family/">Family</a>', |
| 553 |
html=True, |
| 554 |
) |
| 555 |
self.assertNotContains( |
| 556 |
response, |
| 557 |
'<a href="/admindocs/models/admin_docs.person/">Person</a>', |
| 558 |
html=True, |
| 559 |
) |
| 560 |
self.assertNotContains( |
| 561 |
response, |
| 562 |
'<a href="/admindocs/models/admin_docs.company/">Company</a>', |
| 563 |
html=True, |
| 564 |
) |
| 565 |
company_content_type = ContentType.objects.get_for_model(Company) |
| 566 |
person_content_type = ContentType.objects.get_for_model(Person) |
| 567 |
view_company = Permission.objects.get( |
| 568 |
codename="view_company", content_type=company_content_type |
| 569 |
) |
| 570 |
change_person = Permission.objects.get( |
| 571 |
codename="change_person", content_type=person_content_type |
| 572 |
) |
| 573 |
staff_user.user_permissions.add(view_company, change_person) |
| 574 |
response = self.client.get(index_url) |
| 575 |
# View or change permission grants access. |
| 576 |
self.assertNotContains( |
| 577 |
response, |
| 578 |
'<a href="/admindocs/models/admin_docs.family/">Family</a>', |
| 579 |
html=True, |
| 580 |
) |
| 581 |
self.assertContains( |
| 582 |
response, |
| 583 |
'<a href="/admindocs/models/admin_docs.person/">Person</a>', |
| 584 |
html=True, |
| 585 |
) |
| 586 |
self.assertContains( |
| 587 |
response, |
| 588 |
'<a href="/admindocs/models/admin_docs.company/">Company</a>', |
| 589 |
html=True, |
| 590 |
) |
| 591 |
|
| 592 |
|
| 593 |
class CustomField(models.Field): |
| 594 |
description = "A custom field type" |
| 595 |
|
| 596 |
|
| 597 |
class DescriptionLackingField(models.Field): |
| 598 |
pass |
| 599 |
|
| 600 |
|
| 601 |
class TestFieldType(unittest.TestCase): |
| 602 |
def test_field_name(self): |
| 603 |
with self.assertRaises(AttributeError): |
| 604 |
views.get_readable_field_data_type("NotAField") |
| 605 |
|
| 606 |
def test_builtin_fields(self): |
| 607 |
self.assertEqual( |
| 608 |
views.get_readable_field_data_type(fields.BooleanField()), |
| 609 |
"Boolean (Either True or False)", |
| 610 |
) |
| 611 |
|
| 612 |
def test_char_fields(self): |
| 613 |
self.assertEqual( |
| 614 |
views.get_readable_field_data_type(fields.CharField(max_length=255)), |
| 615 |
"String (up to 255)", |
| 616 |
) |
| 617 |
self.assertEqual( |
| 618 |
views.get_readable_field_data_type(fields.CharField()), |
| 619 |
"String (unlimited)", |
| 620 |
) |
| 621 |
|
| 622 |
def test_custom_fields(self): |
| 623 |
self.assertEqual( |
| 624 |
views.get_readable_field_data_type(CustomField()), "A custom field type" |
| 625 |
) |
| 626 |
self.assertEqual( |
| 627 |
views.get_readable_field_data_type(DescriptionLackingField()), |
| 628 |
"Field of type: DescriptionLackingField", |
| 629 |
) |
| 630 |
|
| 631 |
|
| 632 |
class AdminDocViewFunctionsTests(SimpleTestCase): |
| 633 |
def test_simplify_regex(self): |
| 634 |
tests = ( |
| 635 |
# Named and unnamed groups. |
| 636 |
(r"^(?P<a>\w+)/b/(?P<c>\w+)/$", "/<a>/b/<c>/"), |
| 637 |
(r"^(?P<a>\w+)/b/(?P<c>\w+)$", "/<a>/b/<c>"), |
| 638 |
(r"^(?P<a>\w+)/b/(?P<c>\w+)", "/<a>/b/<c>"), |
| 639 |
(r"^(?P<a>\w+)/b/(\w+)$", "/<a>/b/<var>"), |
| 640 |
(r"^(?P<a>\w+)/b/(\w+)", "/<a>/b/<var>"), |
| 641 |
(r"^(?P<a>\w+)/b/((x|y)\w+)$", "/<a>/b/<var>"), |
| 642 |
(r"^(?P<a>\w+)/b/((x|y)\w+)", "/<a>/b/<var>"), |
| 643 |
(r"^(?P<a>(x|y))/b/(?P<c>\w+)$", "/<a>/b/<c>"), |
| 644 |
(r"^(?P<a>(x|y))/b/(?P<c>\w+)", "/<a>/b/<c>"), |
| 645 |
(r"^(?P<a>(x|y))/b/(?P<c>\w+)ab", "/<a>/b/<c>ab"), |
| 646 |
(r"^(?P<a>(x|y)(\(|\)))/b/(?P<c>\w+)ab", "/<a>/b/<c>ab"), |
| 647 |
# Non-capturing groups. |
| 648 |
(r"^a(?:\w+)b", "/ab"), |
| 649 |
(r"^a(?:(x|y))", "/a"), |
| 650 |
(r"^(?:\w+(?:\w+))a", "/a"), |
| 651 |
(r"^a(?:\w+)/b(?:\w+)", "/a/b"), |
| 652 |
(r"(?P<a>\w+)/b/(?:\w+)c(?:\w+)", "/<a>/b/c"), |
| 653 |
(r"(?P<a>\w+)/b/(\w+)/(?:\w+)c(?:\w+)", "/<a>/b/<var>/c"), |
| 654 |
# Single and repeated metacharacters. |
| 655 |
(r"^a", "/a"), |
| 656 |
(r"^^a", "/a"), |
| 657 |
(r"^^^a", "/a"), |
| 658 |
(r"a$", "/a"), |
| 659 |
(r"a$$", "/a"), |
| 660 |
(r"a$$$", "/a"), |
| 661 |
(r"a?", "/a"), |
| 662 |
(r"a??", "/a"), |
| 663 |
(r"a???", "/a"), |
| 664 |
(r"a*", "/a"), |
| 665 |
(r"a**", "/a"), |
| 666 |
(r"a***", "/a"), |
| 667 |
(r"a+", "/a"), |
| 668 |
(r"a++", "/a"), |
| 669 |
(r"a+++", "/a"), |
| 670 |
(r"\Aa", "/a"), |
| 671 |
(r"\A\Aa", "/a"), |
| 672 |
(r"\A\A\Aa", "/a"), |
| 673 |
(r"a\Z", "/a"), |
| 674 |
(r"a\Z\Z", "/a"), |
| 675 |
(r"a\Z\Z\Z", "/a"), |
| 676 |
(r"\ba", "/a"), |
| 677 |
(r"\b\ba", "/a"), |
| 678 |
(r"\b\b\ba", "/a"), |
| 679 |
(r"a\B", "/a"), |
| 680 |
(r"a\B\B", "/a"), |
| 681 |
(r"a\B\B\B", "/a"), |
| 682 |
# Multiple mixed metacharacters. |
| 683 |
(r"^a/?$", "/a/"), |
| 684 |
(r"\Aa\Z", "/a"), |
| 685 |
(r"\ba\B", "/a"), |
| 686 |
# Escaped single metacharacters. |
| 687 |
(r"\^a", r"/^a"), |
| 688 |
(r"\\^a", r"/\\a"), |
| 689 |
(r"\\\^a", r"/\\^a"), |
| 690 |
(r"\\\\^a", r"/\\\\a"), |
| 691 |
(r"\\\\\^a", r"/\\\\^a"), |
| 692 |
(r"a\$", r"/a$"), |
| 693 |
(r"a\\$", r"/a\\"), |
| 694 |
(r"a\\\$", r"/a\\$"), |
| 695 |
(r"a\\\\$", r"/a\\\\"), |
| 696 |
(r"a\\\\\$", r"/a\\\\$"), |
| 697 |
(r"a\?", r"/a?"), |
| 698 |
(r"a\\?", r"/a\\"), |
| 699 |
(r"a\\\?", r"/a\\?"), |
| 700 |
(r"a\\\\?", r"/a\\\\"), |
| 701 |
(r"a\\\\\?", r"/a\\\\?"), |
| 702 |
(r"a\*", r"/a*"), |
| 703 |
(r"a\\*", r"/a\\"), |
| 704 |
(r"a\\\*", r"/a\\*"), |
| 705 |
(r"a\\\\*", r"/a\\\\"), |
| 706 |
(r"a\\\\\*", r"/a\\\\*"), |
| 707 |
(r"a\+", r"/a+"), |
| 708 |
(r"a\\+", r"/a\\"), |
| 709 |
(r"a\\\+", r"/a\\+"), |
| 710 |
(r"a\\\\+", r"/a\\\\"), |
| 711 |
(r"a\\\\\+", r"/a\\\\+"), |
| 712 |
(r"\\Aa", r"/\Aa"), |
| 713 |
(r"\\\Aa", r"/\\a"), |
| 714 |
(r"\\\\Aa", r"/\\\Aa"), |
| 715 |
(r"\\\\\Aa", r"/\\\\a"), |
| 716 |
(r"\\\\\\Aa", r"/\\\\\Aa"), |
| 717 |
(r"a\\Z", r"/a\Z"), |
| 718 |
(r"a\\\Z", r"/a\\"), |
| 719 |
(r"a\\\\Z", r"/a\\\Z"), |
| 720 |
(r"a\\\\\Z", r"/a\\\\"), |
| 721 |
(r"a\\\\\\Z", r"/a\\\\\Z"), |
| 722 |
# Escaped mixed metacharacters. |
| 723 |
(r"^a\?$", r"/a?"), |
| 724 |
(r"^a\\?$", r"/a\\"), |
| 725 |
(r"^a\\\?$", r"/a\\?"), |
| 726 |
(r"^a\\\\?$", r"/a\\\\"), |
| 727 |
(r"^a\\\\\?$", r"/a\\\\?"), |
| 728 |
# Adjacent escaped metacharacters. |
| 729 |
(r"^a\?\$", r"/a?$"), |
| 730 |
(r"^a\\?\\$", r"/a\\\\"), |
| 731 |
(r"^a\\\?\\\$", r"/a\\?\\$"), |
| 732 |
(r"^a\\\\?\\\\$", r"/a\\\\\\\\"), |
| 733 |
(r"^a\\\\\?\\\\\$", r"/a\\\\?\\\\$"), |
| 734 |
# Complex examples with metacharacters and (un)named groups. |
| 735 |
(r"^\b(?P<slug>\w+)\B/(\w+)?", "/<slug>/<var>"), |
| 736 |
(r"^\A(?P<slug>\w+)\Z", "/<slug>"), |
| 737 |
) |
| 738 |
for pattern, output in tests: |
| 739 |
with self.subTest(pattern=pattern): |
| 740 |
self.assertEqual(simplify_regex(pattern), output) |