nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/core/testing/context.py

@@ -0,0 +1,18 @@
+from django.test.utils import TestContextDecorator
+
+from nautobot.core.events import _EVENT_BROKERS, deregister_event_broker, load_event_brokers
+
+
+class load_event_broker_override_settings(TestContextDecorator):
+    def __init__(self, **kwargs) -> None:
+        self.options = kwargs
+        super().__init__()
+
+    def enable(self):
+        """Registered event brokers"""
+        load_event_brokers(self.options["EVENT_BROKERS"])
+
+    def disable(self):
+        """Clear all registered event brokers"""
+        for event_broker in _EVENT_BROKERS:
+            deregister_event_broker(event_broker)

nautobot/core/testing/filters.py

@@ -1,7 +1,6 @@
-from __future__ import annotations  # python 3.8
-
 import random
 import string
+from typing import ClassVar, Iterable
 
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Count, Q, QuerySet
@@ -21,6 +20,7 @@ from nautobot.core.filters import (
 )
 from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.testing import views
+from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
 from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Tag, Team
 from nautobot.tenancy import models
 
@@ -30,8 +30,6 @@ class FilterTestCases:
     class BaseFilterTestCase(views.TestCase):
         """Base class for testing of FilterSets."""
 
-        queryset: QuerySet
-
         def get_filterset_test_values(self, field_name, queryset=None):
             """Returns a list of distinct values from the requested queryset field to use in filterset tests.
 
@@ -73,7 +71,8 @@ class FilterTestCases:
     class FilterTestCase(BaseFilterTestCase):
         """Add common tests for all FilterSets."""
 
-        filterset: type[FilterSet]
+        queryset: ClassVar[QuerySet]
+        filterset: ClassVar[FilterSet]
 
         # filter predicate fields that should be excluded from q test case
         exclude_q_filter_predicates = []
@@ -85,34 +84,18 @@ class FilterTestCases:
         #       ["filter1"],
         #       ["filter2", "field2__name"],
         #   ]
-        generic_filter_tests = []
+        generic_filter_tests: ClassVar[Iterable]
+
+        def setUp(self):
+            for attr in ["queryset", "filterset", "generic_filter_tests"]:
+                if not hasattr(self, attr):
+                    raise NotImplementedError(f'{self} is missing a value for required attribute "{attr}"')
+            super().setUp()
 
         def get_q_filter(self):
             """Helper method to return q filter."""
             return self.filterset.declared_filters["q"].filter_predicates
 
-        def test_id(self):
-            """Verify that the filterset supports filtering by id with only lookup `__n`."""
-            with self.subTest("Assert `id`"):
-                params = {"id": list(self.queryset.values_list("pk", flat=True)[:2])}
-                expected_queryset = self.queryset.filter(id__in=params["id"])
-                filterset = self.filterset(params, self.queryset)
-                self.assertTrue(filterset.is_valid())
-                self.assertQuerysetEqualAndNotEmpty(filterset.qs.order_by("id"), expected_queryset.order_by("id"))
-
-            with self.subTest("Assert negate lookup"):
-                params = {"id__n": list(self.queryset.values_list("pk", flat=True)[:2])}
-                expected_queryset = self.queryset.exclude(id__in=params["id__n"])
-                filterset = self.filterset(params, self.queryset)
-                self.assertTrue(filterset.is_valid())
-                self.assertQuerysetEqualAndNotEmpty(filterset.qs.order_by("id"), expected_queryset.order_by("id"))
-
-            with self.subTest("Assert invalid lookup"):
-                params = {"id__in": list(self.queryset.values_list("pk", flat=True)[:2])}
-                filterset = self.filterset(params, self.queryset)
-                self.assertFalse(filterset.is_valid())
-                self.assertIn("Unknown filter field", filterset.errors.as_text())
-
         def test_invalid_filter(self):
             """Verify that the filterset reports as invalid when initialized with an unsupported filter parameter."""
             params = {"ice_cream_flavor": ["chocolate"]}
@@ -141,15 +124,22 @@ class FilterTestCases:
                     )
                 This expects a field named `devices` on the model and a filter named `devices` on the filterset.
             """
+            if not any(test[0] == "id" for test in self.generic_filter_tests):
+                self.generic_filter_tests = (["id"], *self.generic_filter_tests)
+
             if getattr(self.queryset.model, "is_contact_associable_model", False):
-                for generic_filter_test in (
-                    ["contacts", "associated_contacts__contact__name"],
-                    ["contacts", "associated_contacts__contact__id"],
-                    ["teams", "associated_contacts__team__name"],
-                    ["teams", "associated_contacts__team__id"],
-                ):
-                    if generic_filter_test not in self.generic_filter_tests:
-                        self.generic_filter_tests = (*self.generic_filter_tests, generic_filter_test)
+                if not any(test[0] == "contacts" for test in self.generic_filter_tests):
+                    self.generic_filter_tests = (
+                        *self.generic_filter_tests,
+                        ["contacts", "associated_contacts__contact__name"],
+                        ["contacts", "associated_contacts__contact__id"],
+                    )
+                if not any(test[0] == "teams" for test in self.generic_filter_tests):
+                    self.generic_filter_tests = (
+                        *self.generic_filter_tests,
+                        ["teams", "associated_contacts__team__name"],
+                        ["teams", "associated_contacts__team__id"],
+                    )
 
                 # Make sure we have at least 3 contacts and 3 teams in the database
                 if Contact.objects.count() < 3:
@@ -177,9 +167,6 @@ class FilterTestCases:
                         status=Status.objects.get_for_model(ContactAssociation).last(),
                     )
 
-            if not self.generic_filter_tests:
-                self.skipTest("No generic_filter_tests defined?")
-
             for test in self.generic_filter_tests:
                 filter_name = test[0]
                 field_name = test[-1]  # default to filter_name if a second list item was not supplied
@@ -238,10 +225,6 @@ class FilterTestCases:
             qs_result = self.queryset.filter(tags=tags[0]).filter(tags=tags[1]).distinct()
             self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
 
-        def test_q_filter_exists(self):
-            """Test the `q` filter exists on a filterset, does not validate the filter works as expected."""
-            self.assertIn("q", self.filterset.declared_filters)
-
         def _assert_valid_filter_predicates(self, obj, field_name):
             self.assertTrue(
                 hasattr(obj, field_name),
@@ -377,27 +360,27 @@ class FilterTestCases:
                         filter_field, (ContentTypeFilter, ContentTypeMultipleChoiceFilter, ContentTypeChoiceFilter)
                     )
 
+    # Test cases should just explicitly include `name` as a generic_filter_tests entry
+    @class_deprecated_in_favor_of(FilterTestCase)  # pylint: disable=undefined-variable
     class NameOnlyFilterTestCase(FilterTestCase):
         """Add simple tests for filtering by name."""
 
-        def test_name(self):
-            """Verify that the filterset supports filtering by name."""
-            params = {"name": list(self.queryset.values_list("name", flat=True)[:2])}
-            filterset = self.filterset(params, self.queryset)
-            self.assertTrue(filterset.is_valid())
-            self.assertQuerysetEqualAndNotEmpty(
-                filterset.qs.order_by("name"), self.queryset.filter(name__in=params["name"]).order_by("name")
-            )
+        def test_filters_generic(self):
+            if not any(test[0] == "name" for test in self.generic_filter_tests):
+                self.generic_filter_tests = (["name"], *self.generic_filter_tests)
+            super().test_filters_generic()
 
-    class NameSlugFilterTestCase(NameOnlyFilterTestCase):
+    # Test cases should just explicitly include `name` and `slug` as generic_filter_tests entries
+    @class_deprecated_in_favor_of(FilterTestCase)  # pylint: disable=undefined-variable
+    class NameSlugFilterTestCase(FilterTestCase):
         """Add simple tests for filtering by name and by slug."""
 
-        def test_slug(self):
-            """Verify that the filterset supports filtering by slug."""
-            params = {"slug": self.queryset.values_list("slug", flat=True)[:2]}
-            filterset = self.filterset(params, self.queryset)
-            self.assertTrue(filterset.is_valid())
-            self.assertEqual(filterset.qs.count(), 2)
+        def test_filters_generic(self):
+            if not any(test[0] == "slug" for test in self.generic_filter_tests):
+                self.generic_filter_tests = (["slug"], *self.generic_filter_tests)
+            if not any(test[0] == "name" for test in self.generic_filter_tests):
+                self.generic_filter_tests = (["name"], *self.generic_filter_tests)
+            super().test_filters_generic()
 
     class TenancyFilterTestCaseMixin(views.TestCase):
         """Add test cases for tenant and tenant-group filters."""

nautobot/core/testing/mixins.py

@@ -144,18 +144,13 @@ class NautobotTestCaseMixin:
     # Permissions management
     #
 
-    def add_permissions(self, *names, **kwargs):
+    def add_permissions(self, *names):
         """
         Assign a set of permissions to the test user. Accepts permission names in the form <app>.<action>_<model>.
-        Additional keyword arguments will be passed to the ObjectPermission constructor to allow creating more detailed permissions.
-
-        Examples:
-            >>> add_permissions("ipam.add_vlangroup", "ipam.view_vlangroup")
-            >>> add_permissions("ipam.add_vlangroup", "ipam.view_vlangroup", constraints={"pk": "uuid-1234"})
         """
         for name in names:
             ct, action = permissions.resolve_permission_ct(name)
-            obj_perm = users_models.ObjectPermission(name=name, actions=[action], **kwargs)
+            obj_perm = users_models.ObjectPermission(name=name, actions=[action])
             obj_perm.save()
             obj_perm.users.add(self.user)
             obj_perm.object_types.add(ct)

nautobot/core/testing/views.py

@@ -1,5 +1,3 @@
-from __future__ import annotations  # python 3.8
-
 import contextlib
 import re
 from typing import Optional, Sequence
@@ -23,7 +21,6 @@ from nautobot.core.models.tree_queries import TreeModel
 from nautobot.core.templatetags import helpers
 from nautobot.core.testing import mixins, utils
 from nautobot.core.utils import lookup
-from nautobot.dcim.models.device_components import ComponentModel
 from nautobot.extras import choices as extras_choices, models as extras_models, querysets as extras_querysets
 from nautobot.extras.forms import CustomFieldModelFormMixin, RelationshipModelFormMixin
 from nautobot.extras.models import CustomFieldModel, RelationshipModel
@@ -174,10 +171,7 @@ class ViewTestCases:
             instance = self._get_queryset().first()
 
             # Add model-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["view"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
 
             # Try GET with model-level permission
             response = self.client.get(instance.get_absolute_url())
@@ -326,10 +320,7 @@ class ViewTestCases:
             initial_count = self._get_queryset().count()
 
             # Assign unconstrained permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["add"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.add_{self.model._meta.model_name}")
 
             # Try GET with model-level permission
             self.assertHttpStatus(self.client.get(self._get_url("add")), 200)
@@ -436,32 +427,6 @@ class ViewTestCases:
             if isinstance(model_class, PrimaryModel):
                 self.assertIsNotNone(fields.get("tags"))
 
-        def test_slug_autocreation(self):
-            """Test that slug is autocreated through ORM."""
-            # This really should go on a models test page, but we don't have test structures for models.
-            if getattr(self.model, "slug_source", None) is not None:
-                obj = self.model.objects.get(**{self.slug_source: self.slug_test_object})
-                expected_slug = self.slugify_function(getattr(obj, self.slug_source))
-                self.assertEqual(obj.slug, expected_slug)
-
-        def test_slug_not_modified(self):
-            """Ensure save method does not modify slug that is passed in."""
-            # This really should go on a models test page, but we don't have test structures for models.
-            if getattr(self.model, "slug_source", None) is not None:
-                new_slug_source_value = "kwyjibo"
-
-                obj = self.model.objects.get(**{self.slug_source: self.slug_test_object})
-                expected_slug = self.slugify_function(getattr(obj, self.slug_source))
-                # Update slug source field str
-                filter_ = self.slug_source + "__exact"
-                self.model.objects.filter(**{filter_: self.slug_test_object}).update(
-                    **{self.slug_source: new_slug_source_value}
-                )
-
-                obj.refresh_from_db()
-                self.assertEqual(getattr(obj, self.slug_source), new_slug_source_value)
-                self.assertEqual(obj.slug, expected_slug)
-
     class EditObjectViewTestCase(ModelViewTestCase):
         """
         Edit a single existing instance.
@@ -494,10 +459,7 @@ class ViewTestCases:
             instance = self._get_queryset().first()
 
             # Assign model-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["change"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
             # Try GET with model-level permission
             self.assertHttpStatus(self.client.get(self._get_url("edit", instance)), 200)
@@ -618,10 +580,7 @@ class ViewTestCases:
                     instance_note_pk_list.append(note.pk)
 
             # Assign model-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["delete"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(assigned_object_type)
+            self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
 
             # Try GET with model-level permission
             self.assertHttpStatus(self.client.get(self._get_url("delete", instance)), 200)
@@ -657,10 +616,7 @@ class ViewTestCases:
             instance = self.get_deletable_object()
 
             # Assign model-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["delete"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
 
             # Try GET with model-level permission
             self.assertHttpStatus(self.client.get(self._get_url("delete", instance)), 200)
@@ -865,10 +821,7 @@ class ViewTestCases:
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_with_permission(self):
             # Add model-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["view"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
 
             # Try GET with model-level permission
             response = self.client.get(self._get_url("list"))
@@ -881,11 +834,17 @@ class ViewTestCases:
             # Check if breadcrumb is rendered correctly
             self.assertBodyContains(response, f'<a href="{list_url}">{title}</a>', html=True)
 
-            # Check if import button is absent due to user permissions
-            self.assertNotIn(
-                reverse("extras:job_run_by_class_path", kwargs={"class_path": "nautobot.core.jobs.ImportObjects"}),
-                response_body,
-            )
+            with self.subTest("Assert import-objects URL is absent due to user permissions"):
+                self.assertNotIn(
+                    reverse("extras:job_run_by_class_path", kwargs={"class_path": "nautobot.core.jobs.ImportObjects"}),
+                    response_body,
+                )
+
+            if "example_app" in settings.PLUGINS:
+                with self.subTest("Assert example-app banner is present"):
+                    self.assertIn(
+                        f"<div>You are viewing a table of {self.model._meta.verbose_name_plural}</div>", response_body
+                    )
 
             return response
 
@@ -992,13 +951,7 @@ class ViewTestCases:
             }
 
             # Assign non-constrained permission
-            obj_perm = users_models.ObjectPermission(
-                name="Test permission",
-                actions=["add"],
-            )
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.add_{self.model._meta.model_name}")
 
             # Bulk create objects
             response = self.client.post(**request)
@@ -1052,34 +1005,6 @@ class ViewTestCases:
                     pass
             self.assertEqual(matching_count, self.bulk_create_count)
 
-    class BulkImportObjectsViewTestCase(ModelViewTestCase):  # 3.0 TODO: remove this test mixin, no longer relevant.
-        """
-        Vestigial test case, to be removed in 3.0.
-
-        This is vestigial since the introduction of the ImportObjects system Job to handle bulk-import of all
-        content-types via REST API serializers. The parsing of CSV data by the serializer is exercised by
-        APIViewTestCases.CreateObjectViewTestCase.test_recreate_object_csv(), and the basic operation of the Job is
-        exercised by nautobot.core.tests.test_jobs.
-        """
-
-        csv_data = ()
-
-        def _get_csv_data(self):
-            return "\n".join(self.csv_data)
-
-        # Just in case Apps are extending any of these tests and calling super() in them.
-        def test_bulk_import_objects_without_permission(self):
-            pass
-
-        def test_bulk_import_objects_with_permission(self):
-            pass
-
-        def test_bulk_import_objects_with_permission_csv_file(self):
-            pass
-
-        def test_bulk_import_objects_with_constrained_permission(self):
-            pass
-
     class BulkEditObjectsViewTestCase(ModelViewTestCase):
         """
         Edit multiple instances.
@@ -1117,10 +1042,7 @@ class ViewTestCases:
             data.update(utils.post_data(self.bulk_edit_data))
 
             # Assign model-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["change"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
             # Try POST with model-level permission
             self.assertHttpStatus(self.client.post(self._get_url("bulk_edit"), data), 302)
@@ -1135,10 +1057,7 @@ class ViewTestCases:
                 "_all": "on",
             }
             # Assign model-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["change"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
             # Try POST with model-level permission
             response = self.client.post(self._get_url("bulk_edit"), selected_data)
@@ -1282,10 +1201,7 @@ class ViewTestCases:
             }
 
             # Assign unconstrained permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["delete"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
 
             # Try POST with model-level permission
             self.assertHttpStatus(self.client.post(self._get_url("bulk_delete"), data), 302)
@@ -1301,10 +1217,7 @@ class ViewTestCases:
             }
 
             # Assign unconstrained permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["delete"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
 
             # Try POST with the selected data first. Emulating selecting all -> pressing Delete Selected button.
             response = self.client.post(self._get_url("bulk_delete"), selected_data)
@@ -1418,10 +1331,7 @@ class ViewTestCases:
             data.update(self.rename_data)
 
             # Assign model-level permission
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["change"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
             # Try POST with model-level permission
             self.assertHttpStatus(self.client.post(self._get_url("bulk_rename"), data), 302)
@@ -1531,16 +1441,11 @@ class ViewTestCases:
         maxDiff = None
         bulk_add_data = None
         """Used for bulk-add (distinct from bulk-create) view testing; self.bulk_create_data will be used if unset."""
-        selected_objects: list[ComponentModel]
-        selected_objects_parent_name: str
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_add_component(self):
             """Test bulk-adding this component to devices/virtual-machines."""
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["add"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.add_{self.model._meta.model_name}")
 
             initial_count = self._get_queryset().count()
 
@@ -1584,10 +1489,7 @@ class ViewTestCases:
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_rename(self):
-            obj_perm = users_models.ObjectPermission(name="Test permission", actions=["change"])
-            obj_perm.save()
-            obj_perm.users.add(self.user)
-            obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+            self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
             objects = self.selected_objects
             pk_list = [obj.pk for obj in objects]

nautobot/core/tests/integration/test_app_home.py

@@ -9,6 +9,7 @@ from example_app.models import ExampleModel
 class AppHomeTestCase(SeleniumTestCase):
     """Integration test the Example App homepage extensions."""
 
+    fixtures = ["user-data.json"]  # bob/bob
     layout = {
         "Organization": {
             "Locations": {"model": Location, "permission": "dcim.view_location"},

nautobot/core/tests/integration/test_app_navbar.py

@@ -5,6 +5,7 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class AppNavBarTestCase(SeleniumTestCase):
     """Integration test the navigation menu."""
 
+    fixtures = ["user-data.json"]
     navbar = {
         "Circuits": {
             "Circuits": {

nautobot/core/tests/integration/test_filters.py

@@ -11,6 +11,8 @@ from nautobot.extras.models import CustomField, CustomFieldChoice, Status
 class ListViewFilterTestCase(SeleniumTestCase):
     """Integration test for the list view filter ui."""
 
+    fixtures = ["user-data.json"]
+
     def setUp(self):
         super().setUp()
         self.login(self.user.username, self.password)

nautobot/core/tests/integration/test_home.py

@@ -7,6 +7,7 @@ from nautobot.tenancy.models import Tenant
 class HomeTestCase(SeleniumTestCase):
     """Integration tests against the home page."""
 
+    fixtures = ["user-data.json"]  # bob/bob
     layout = {
         "Organization": {
             "Locations": {"model": Location, "permission": "dcim.view_location"},

nautobot/core/tests/integration/test_navbar.py

@@ -4,6 +4,7 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class NavBarTestCase(SeleniumTestCase):
     """Integration test the navigation menu."""
 
+    fixtures = ["user-data.json"]
     navbar = {
         "Organization": {
             "Locations": {

nautobot/core/tests/integration/test_view_authentication.py

@@ -14,7 +14,7 @@ class AuthenticationEnforcedTestCase(TestCase):
 
     def test_all_views_require_authentication(self):
         self.client.logout()
-        url_patterns = get_url_patterns()
+        url_patterns = get_url_patterns(ignore_redirects=True)
 
         for url_pattern in url_patterns:
             with self.subTest(url_pattern=url_pattern):
@@ -31,7 +31,6 @@ class AuthenticationEnforcedTestCase(TestCase):
                     "/health/",
                     "/login/",
                     "/media-failure/",
-                    "/robots.txt",
                     "/template.css",
                 ]:
                     self.assertHttpStatus(response, 200, msg=url)