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

nautobot/core/testing/filters.py

@@ -1,12 +1,14 @@
 import random
 import string
+from typing import ClassVar, Iterable
 
 from django.contrib.contenttypes.models import ContentType
-from django.db.models import Count, Q
+from django.db.models import Count, Q, QuerySet
 from django.db.models.fields import CharField, TextField
 from django.db.models.fields.related import ManyToManyField
 from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel
 from django.test import tag
+from django_filters import FilterSet
 
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.filters import (
@@ -18,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
 
@@ -27,6 +30,8 @@ class FilterTestCases:
     class BaseFilterTestCase(views.TestCase):
         """Base class for testing of FilterSets."""
 
+        queryset: ClassVar[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.
 
@@ -68,8 +73,7 @@ class FilterTestCases:
     class FilterTestCase(BaseFilterTestCase):
         """Add common tests for all FilterSets."""
 
-        queryset = None
-        filterset = None
+        filterset: ClassVar[type[FilterSet]]
 
         # filter predicate fields that should be excluded from q test case
         exclude_q_filter_predicates = []
@@ -81,7 +85,13 @@ 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."""
@@ -137,15 +147,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:
@@ -173,9 +190,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
@@ -234,10 +248,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),
@@ -373,27 +383,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/forms.py

@@ -1,5 +1,6 @@
 from django.test import tag, TestCase
 
+from nautobot.core.api.constants import NON_FILTER_QUERY_PARAMS
 from nautobot.core.forms.fields import DynamicModelChoiceMixin
 from nautobot.core.utils.lookup import get_filterset_for_model
 
@@ -18,6 +19,7 @@ class FormTestCases:
                     continue
                 with self.subTest(f"Assert {self.form_class.__name__}.{field_name} query_params are valid."):
                     query_params_fields = set(field_class.query_params.keys())
+                    query_params_fields = query_params_fields - set(NON_FILTER_QUERY_PARAMS)
                     if not query_params_fields:
                         self.skipTest(f"{self.form_class.__name__}.{field_name} has no query_params")
                     field_model = field_class.queryset.model

nautobot/core/testing/views.py

@@ -21,17 +21,19 @@ 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
+from nautobot.extras.models.jobs import JobResult
 from nautobot.extras.models.mixins import NotesMixin
 from nautobot.ipam.models import Prefix
 from nautobot.users import models as users_models
 
 __all__ = (
-    "TestCase",
     "ModelTestCase",
     "ModelViewTestCase",
+    "TestCase",
     "ViewTestCases",
 )
 
@@ -171,10 +173,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())
@@ -323,10 +322,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)
@@ -433,32 +429,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.
@@ -491,10 +461,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)
@@ -615,10 +582,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)
@@ -654,10 +618,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)
@@ -862,10 +823,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"))
@@ -878,11 +836,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
 
@@ -989,13 +953,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)
@@ -1049,34 +1007,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.
@@ -1091,6 +1021,17 @@ class ViewTestCases:
             for instance in self._get_queryset().filter(pk__in=pk_list):
                 self.assertInstanceEqual(instance, self.bulk_edit_data)
 
+        def validate_redirect_to_job_result(self, response):
+            # Get the last Bulk Edit Objects JobResult created
+            job_result = JobResult.objects.filter(name="Bulk Edit Objects").first()
+            # Assert redirect to Job Results
+            self.assertRedirects(
+                response,
+                reverse("extras:jobresult", args=[job_result.pk]),
+                status_code=302,
+                target_status_code=200,
+            )
+
         def test_bulk_edit_objects_without_permission(self):
             pk_list = list(self._get_queryset().values_list("pk", flat=True)[:3])
             data = {
@@ -1114,14 +1055,10 @@ 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)
-            self.validate_object_data_after_bulk_edit(pk_list)
+            response = self.client.post(self._get_url("bulk_edit"), data)
+            self.validate_redirect_to_job_result(response)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_edit_form_contains_all_pks(self):
@@ -1132,10 +1069,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)
@@ -1149,7 +1083,7 @@ class ViewTestCases:
             for pk in pk_list:
                 self.assertNotIn(str(pk), response_body)
             self.assertInHTML(
-                '<input type="hidden" name="_all" value="True" class="form-control" required="required" placeholder="None" id="id__all">',
+                '<input type="hidden" name="_all" value="True" class="form-control" placeholder="None" id="id__all">',
                 response_body,
             )
 
@@ -1185,7 +1119,7 @@ class ViewTestCases:
             self.assertNotIn(str(third_pk), response_body)
             self.assertIn("Editing 2 ", response_body)
             self.assertInHTML(
-                '<input type="hidden" name="_all" value="True" class="form-control" required="required" placeholder="None" id="id__all">',
+                '<input type="hidden" name="_all" value="True" class="form-control" placeholder="None" id="id__all">',
                 response_body,
             )
 
@@ -1225,21 +1159,9 @@ class ViewTestCases:
 
             # Attempt to bulk edit permitted objects into a non-permitted state
             response = self.client.post(self._get_url("bulk_edit"), data)
-            # 200 because we're sent back to the edit form to try again; if the update were successful it'd be a 302
-            self.assertHttpStatus(response, 200)
-            # Assert that the objects are NOT updated
-            for instance in self._get_queryset().filter(pk__in=pk_list):
-                self.assertIn(field.value_from_object(instance), values)
-                self.assertNotEqual(field.value_from_object(instance), self.bulk_edit_data[attr_name])
-
-            # Update permission constraints to permit all objects
-            obj_perm.constraints = {"pk__gt": 0}
-            obj_perm.save()
-
-            # Bulk edit permitted objects and expect a redirect back to the list view
-            self.assertHttpStatus(self.client.post(self._get_url("bulk_edit"), data), 302)
-            # Assert that the objects were all updated correctly
-            self.validate_object_data_after_bulk_edit(pk_list)
+            # NOTE: There is no way of testing constrained failure as bulk edit is a system Job;
+            # and can only be tested by checking JobLogs.
+            self.validate_redirect_to_job_result(response)
 
     class BulkDeleteObjectsViewTestCase(ModelViewTestCase):
         """
@@ -1271,7 +1193,6 @@ class ViewTestCases:
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_bulk_delete_objects_with_permission(self):
             pk_list = self.get_deletable_object_pks()
-            initial_count = self._get_queryset().count()
             data = {
                 "pk": pk_list,
                 "confirm": True,
@@ -1279,14 +1200,18 @@ 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}", "extras.view_jobresult"
+            )
 
-            # Try POST with model-level permission
-            self.assertHttpStatus(self.client.post(self._get_url("bulk_delete"), data), 302)
-            self.assertEqual(self._get_queryset().count(), initial_count - len(pk_list))
+            response = self.client.post(self._get_url("bulk_delete"), data)
+            job_result = JobResult.objects.filter(name="Bulk Delete Objects").first()
+            self.assertRedirects(
+                response,
+                reverse("extras:jobresult", args=[job_result.pk]),
+                status_code=302,
+                target_status_code=200,
+            )
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_bulk_delete_form_contains_all_objects(self):
@@ -1298,10 +1223,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)
@@ -1373,9 +1295,16 @@ class ViewTestCases:
             obj_perm.constraints = {"pk__isnull": False}  # Match a non-existent pk (i.e., allow all)
             obj_perm.save()
 
-            # Bulk delete permitted objects
-            self.assertHttpStatus(self.client.post(self._get_url("bulk_delete"), data), 302)
-            self.assertEqual(self._get_queryset().count(), initial_count - len(pk_list))
+            # User would be redirected to Job Result therefore user needs to have permission to view Job Result
+            self.add_permissions("extras.view_jobresult")
+            response = self.client.post(self._get_url("bulk_delete"), data)
+            job_result = JobResult.objects.filter(name="Bulk Delete Objects").first()
+            self.assertRedirects(
+                response,
+                reverse("extras:jobresult", args=[job_result.pk]),
+                status_code=302,
+                target_status_code=200,
+            )
 
     class BulkRenameObjectsViewTestCase(ModelViewTestCase):
         """
@@ -1415,10 +1344,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)
@@ -1528,14 +1454,13 @@ 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()
 
@@ -1579,10 +1504,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,7 +9,6 @@ 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,7 +5,6 @@ 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,8 +11,6 @@ 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,7 +7,6 @@ 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,7 +4,6 @@ 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,6 +31,7 @@ class AuthenticationEnforcedTestCase(TestCase):
                     "/health/",
                     "/login/",
                     "/media-failure/",
+                    "/robots.txt",
                     "/template.css",
                 ]:
                     self.assertHttpStatus(response, 200, msg=url)