Debian Codegraph @

tests/admin_docs/test_views.py

raw
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=&#x27;ltd&#x27;</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>&quot;raw&quot; 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>&quot;include&quot; 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)