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

nautobot/core/testing/api.py

@@ -5,13 +5,11 @@ from typing import Optional, Sequence, Union
 from django.conf import settings
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
-from django.db import connections, DEFAULT_DB_ALIAS
 from django.db.models import ForeignKey, ManyToManyField, QuerySet
 from django.test import override_settings, tag
-from django.test.utils import CaptureQueriesContext
 from django.urls import reverse
 from django.utils.text import slugify
-from rest_framework import serializers, status
+from rest_framework import status
 from rest_framework.relations import ManyRelatedField
 from rest_framework.test import APITransactionTestCase as _APITransactionTestCase
 
@@ -96,15 +94,6 @@ class APITestCase(views.ModelTestCase):
         for verboten in self.VERBOTEN_STRINGS:
             self.assertNotIn(verboten, response_raw_content)
 
-    def get_m2m_fields(self):
-        """Get serializer field names that are many-to-many or one-to-many and thus affected by ?exclude_m2m=true."""
-        serializer_class = get_serializer_for_model(self.model)
-        m2m_fields = []
-        for field_name, field_instance in serializer_class().fields.items():
-            if isinstance(field_instance, (serializers.ManyRelatedField, serializers.ListSerializer)):
-                m2m_fields.append(field_name)
-        return m2m_fields
-
 
 @tag("unit")
 class APIViewTestCases:
@@ -242,7 +231,7 @@ class APIViewTestCases:
         def get_depth_fields(self):
             """Get a list of model fields that could be tested with the ?depth query parameter"""
             depth_fields = []
-            for field in self.model._meta.get_fields():
+            for field in self.model._meta.fields:
                 if not field.name.startswith("_"):
                     if isinstance(field, (ForeignKey, GenericForeignKey, ManyToManyField, core_fields.TagsField)) and (
                         # we represent content-types as "app_label.modelname" rather than as FKs
@@ -251,9 +240,6 @@ class APIViewTestCases:
                         and not (field.name == "user" and self.model == users_models.Token)
                     ):
                         depth_fields.append(field.name)
-            serializer_class = get_serializer_for_model(self.model)
-            serializer = serializer_class()
-            depth_fields = [field_name for field_name in depth_fields if field_name in serializer.fields]
             return depth_fields
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -283,12 +269,9 @@ class APIViewTestCases:
             GET a list of objects using the "?depth=0" parameter.
             """
             depth_fields = self.get_depth_fields()
-            m2m_fields = self.get_m2m_fields()
             self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
-            list_url = f"{self._get_list_url()}?depth=0"
-            with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
-            base_num_queries = len(cqc)
+            url = f"{self._get_list_url()}?depth=0"
+            response = self.client.get(url, **self.header)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
             self.assertIsInstance(response.data, dict)
@@ -297,23 +280,15 @@ class APIViewTestCases:
             self.assert_no_verboten_content(response)
 
             for response_data in response.data["results"]:
-                for field in m2m_fields:
-                    self.assertIn(field, response_data)
-                    self.assertIsInstance(response_data[field], list)
                 for field in depth_fields:
                     self.assertIn(field, response_data)
                     if isinstance(response_data[field], list):
                         for entry in response_data[field]:
                             self.assertIsInstance(entry, dict)
-                            if entry["object_type"] in ["auth.group"]:
-                                self.assertIsInstance(entry["id"], int)
-                            else:
-                                self.assertTrue(is_uuid(entry["id"]))
-                            self.assertEqual(len(entry.keys()), 3)  # just id/object_type/url
+                            self.assertTrue(is_uuid(entry["id"]))
                     else:
                         if response_data[field] is not None:
                             self.assertIsInstance(response_data[field], dict)
-                            self.assertEqual(len(response_data[field].keys()), 3)  # just id/object_type/url
                             url = response_data[field]["url"]
                             pk = response_data[field]["id"]
                             object_type = response_data[field]["object_type"]
@@ -321,67 +296,22 @@ class APIViewTestCases:
                             # URL ending in the UUID of the relevant object:
                             # http://nautobot.example.com/api/circuits/providers/<uuid>/
                             #                                                    ^^^^^^
-                            if object_type in ["auth.group"]:
-                                self.assertIsInstance(url.split("/")[-2], int)
-                                self.assertIsInstance(pk, int)
-                            else:
-                                self.assertTrue(is_uuid(url.split("/")[-2]))
-                                self.assertTrue(is_uuid(pk))
+                            self.assertTrue(is_uuid(url.split("/")[-2]))
+                            self.assertTrue(is_uuid(pk))
 
                             with self.subTest(f"Assert object_type {object_type} is valid"):
                                 app_label, model_name = object_type.split(".")
                                 ContentType.objects.get(app_label=app_label, model=model_name)
 
-            list_url += "&exclude_m2m=true"
-            with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
-
-            self.assertHttpStatus(response, status.HTTP_200_OK)
-            self.assertIsInstance(response.data, dict)
-            self.assertIn("results", response.data)
-            self.assert_no_verboten_content(response)
-
-            if m2m_fields:
-                if self.model._meta.app_label in [
-                    "circuits",
-                    "cloud",
-                    "dcim",
-                    "extras",
-                    "ipam",
-                    "tenancy",
-                    "users",
-                    "virtualization",
-                    "wireless",
-                ]:
-                    self.assertLess(
-                        len(cqc), base_num_queries, "Number of queries did not decrease with ?exclude_m2m=true"
-                    )
-                else:
-                    # Less strict check for non-core APIs
-                    self.assertLessEqual(
-                        len(cqc), base_num_queries, "Number of queries increased with ?exclude_m2m=true"
-                    )
-            else:
-                # No M2M fields to exclude
-                self.assertLessEqual(len(cqc), base_num_queries, "Number of queries increased with ?exclude_m2m=true")
-
-            for response_data in response.data["results"]:
-                for field in m2m_fields:
-                    self.assertNotIn(field, response_data)
-                # TODO: we should assert that all other fields are still present, but there's a few corner cases...
-
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_depth_1(self):
             """
             GET a list of objects using the "?depth=1" parameter.
             """
             depth_fields = self.get_depth_fields()
-            m2m_fields = self.get_m2m_fields()
             self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
-            list_url = f"{self._get_list_url()}?depth=1"
-            with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
-            base_num_queries = len(cqc)
+            url = f"{self._get_list_url()}?depth=1"
+            response = self.client.get(url, **self.header)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
             self.assertIsInstance(response.data, dict)
@@ -390,65 +320,16 @@ class APIViewTestCases:
             self.assert_no_verboten_content(response)
 
             for response_data in response.data["results"]:
-                for field in m2m_fields:
-                    self.assertIn(field, response_data)
-                    self.assertIsInstance(response_data[field], list)
                 for field in depth_fields:
                     self.assertIn(field, response_data)
                     if isinstance(response_data[field], list):
                         for entry in response_data[field]:
                             self.assertIsInstance(entry, dict)
-                            if entry["object_type"] in ["auth.group"]:
-                                self.assertIsInstance(entry["id"], int)
-                            else:
-                                self.assertTrue(is_uuid(entry["id"]))
-                            self.assertGreater(len(entry.keys()), 3, entry)  # not just id/object_type/url!
+                            self.assertTrue(is_uuid(entry["id"]))
                     else:
                         if response_data[field] is not None:
                             self.assertIsInstance(response_data[field], dict)
-                            if response_data[field]["object_type"] in ["auth.group"]:
-                                self.assertIsInstance(response_data[field]["id"], int)
-                            else:
-                                self.assertTrue(is_uuid(response_data[field]["id"]))
-                            self.assertGreater(len(response_data[field].keys()), 3, response_data[field])
-
-            list_url += "&exclude_m2m=true"
-            with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
-
-            self.assertHttpStatus(response, status.HTTP_200_OK)
-            self.assertIsInstance(response.data, dict)
-            self.assertIn("results", response.data)
-            self.assert_no_verboten_content(response)
-
-            if m2m_fields:
-                if self.model._meta.app_label in [
-                    "circuits",
-                    "cloud",
-                    "dcim",
-                    "extras",
-                    "ipam",
-                    "tenancy",
-                    "users",
-                    "virtualization",
-                    "wireless",
-                ]:
-                    self.assertLess(
-                        len(cqc), base_num_queries, "Number of queries did not decrease with ?exclude_m2m=true"
-                    )
-                else:
-                    # Less strict check for non-core APIs
-                    self.assertLessEqual(
-                        len(cqc), base_num_queries, "Number of queries increased with ?exclude_m2m=true"
-                    )
-            else:
-                # No M2M fields to exclude
-                self.assertLessEqual(len(cqc), base_num_queries, "Number of queries increased with ?exclude_m2m=true")
-
-            for response_data in response.data["results"]:
-                for field in m2m_fields:
-                    self.assertNotIn(field, response_data)
-                # TODO: we should assert that all other fields are still present, but there's a few corner cases...
+                            self.assertTrue(is_uuid(response_data[field]["id"]))
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_without_permission(self):
@@ -774,11 +655,7 @@ class APIViewTestCases:
             self.assertHttpStatus(response, status.HTTP_201_CREATED, csv_data)
             # Note that create via CSV is always treated as a bulk-create, and so the response is always a list of dicts
             new_instance = self._get_queryset().get(pk=response.data[0]["id"])
-            if isinstance(orig_pk, int):
-                self.assertNotEqual(new_instance.pk, orig_pk)
-            else:
-                # for our non-integer PKs, we're expecting the creation to respect the requested PK
-                self.assertEqual(new_instance.pk, orig_pk)
+            self.assertNotEqual(new_instance.pk, orig_pk)
 
             new_serializer = serializer_class(new_instance, context={"request": None})
             new_data = new_serializer.data
@@ -860,7 +737,7 @@ class APIViewTestCases:
 
             def strip_serialized_object(this_object):
                 """
-                Work around acceptable differences in PATCH response vs GET response which are known behaviors.
+                Only here to work around acceptable differences in PATCH response vs GET response which are known bugs.
                 """
                 # Work around for https://github.com/nautobot/nautobot/issues/3321
                 this_object.pop("last_updated", None)
@@ -869,12 +746,6 @@ class APIViewTestCases:
                 this_object.pop("config_context", None)
                 this_object.pop("relationships", None)
 
-                serializer = get_serializer_for_model(self.model)()
-                for field_name, field_instance in serializer.fields.items():
-                    if field_instance.read_only:
-                        # Likely a derived field, might change as a consequence of other data updates
-                        this_object.pop(field_name, None)
-
                 for value in this_object.values():
                     if isinstance(value, dict):
                         strip_serialized_object(value)
@@ -918,7 +789,7 @@ class APIViewTestCases:
             self.assertEqual(initial_serialized_object, serialized_object)
 
             # Verify ObjectChange creation -- yes, even though nothing actually changed
-            # TODO: This may change (hah) at some point -- see https://github.com/nautobot/nautobot/issues/3321
+            # This may change (hah) at some point -- see https://github.com/nautobot/nautobot/issues/3321
             if hasattr(self.model, "to_objectchange"):
                 objectchanges = lookup.get_changes_for_model(instance)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_UPDATE)
@@ -927,16 +798,10 @@ class APIViewTestCases:
             # Verify that a PATCH with some data updates that data correctly.
             response = self.client.patch(url, update_data, format="json", **self.header)
             self.assertHttpStatus(response, status.HTTP_200_OK)
-            serialized_object = response.json()
-            strip_serialized_object(serialized_object)
             # Check for unexpected side effects on fields we DIDN'T intend to update
             for field in initial_serialized_object:
                 if field not in update_data:
-                    self.assertEqual(
-                        initial_serialized_object[field],
-                        serialized_object[field],
-                        f"data changed unexpectedly for field '{field}'",
-                    )
+                    self.assertEqual(initial_serialized_object[field], serialized_object[field])
             instance.refresh_from_db()
             self.assertInstanceEqual(instance, update_data, exclude=self.validation_excluded_fields, api=True)
 
@@ -945,26 +810,6 @@ class APIViewTestCases:
                 objectchanges = lookup.get_changes_for_model(instance)
                 self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_UPDATE)
 
-            # Verify that a PATCH with ?exclude_m2m=true correctly excludes many-to-many fields from the response
-            # This also doubles as a test for idempotence of the PATCH request.
-            response = self.client.patch(url + "?exclude_m2m=true", update_data, format="json", **self.header)
-            self.assertHttpStatus(response, status.HTTP_200_OK)
-            m2m_fields = self.get_m2m_fields()
-            serialized_object = response.json()
-            strip_serialized_object(serialized_object)
-            for field in m2m_fields:
-                self.assertNotIn(field, serialized_object)
-            # Check for unexpected side effects on fields we DIDN'T intend to update
-            for field in initial_serialized_object:
-                if field not in update_data and field not in m2m_fields:
-                    self.assertEqual(
-                        initial_serialized_object[field],
-                        serialized_object[field],
-                        f"data changed unexpectedly for field '{field}'",
-                    )
-            instance.refresh_from_db()
-            self.assertInstanceEqual(instance, update_data, exclude=self.validation_excluded_fields, api=True)
-
         def test_get_put_round_trip(self):
             """GET and then PUT an object and verify that it's accepted and unchanged."""
             self.maxDiff = None

nautobot/core/testing/filters.py

@@ -30,8 +30,6 @@ 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.
 
@@ -73,7 +71,8 @@ class FilterTestCases:
     class FilterTestCase(BaseFilterTestCase):
         """Add common tests for all FilterSets."""
 
-        filterset: ClassVar[type[FilterSet]]
+        queryset: ClassVar[QuerySet]
+        filterset: ClassVar[FilterSet]
 
         # filter predicate fields that should be excluded from q test case
         exclude_q_filter_predicates = []
@@ -97,28 +96,6 @@ class FilterTestCases:
             """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"]}

nautobot/core/testing/forms.py

@@ -1,6 +1,5 @@
 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
 
@@ -19,7 +18,6 @@ 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/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

@@ -21,19 +21,17 @@ 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",
 )
 
@@ -1021,17 +1019,6 @@ 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 = {
@@ -1057,8 +1044,9 @@ class ViewTestCases:
             # Assign model-level permission
             self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
-            response = self.client.post(self._get_url("bulk_edit"), data)
-            self.validate_redirect_to_job_result(response)
+            # 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)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_edit_form_contains_all_pks(self):
@@ -1083,7 +1071,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" placeholder="None" id="id__all">',
+                '<input type="hidden" name="_all" value="True" class="form-control" required="required" placeholder="None" id="id__all">',
                 response_body,
             )
 
@@ -1119,7 +1107,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" placeholder="None" id="id__all">',
+                '<input type="hidden" name="_all" value="True" class="form-control" required="required" placeholder="None" id="id__all">',
                 response_body,
             )
 
@@ -1159,9 +1147,21 @@ class ViewTestCases:
 
             # Attempt to bulk edit permitted objects into a non-permitted state
             response = self.client.post(self._get_url("bulk_edit"), data)
-            # 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)
+            # 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)
 
     class BulkDeleteObjectsViewTestCase(ModelViewTestCase):
         """
@@ -1193,6 +1193,7 @@ 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,
@@ -1200,18 +1201,11 @@ class ViewTestCases:
             }
 
             # Assign unconstrained permission
-            self.add_permissions(
-                f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}", "extras.view_jobresult"
-            )
+            self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
 
-            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,
-            )
+            # 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))
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_bulk_delete_form_contains_all_objects(self):
@@ -1295,16 +1289,9 @@ class ViewTestCases:
             obj_perm.constraints = {"pk__isnull": False}  # Match a non-existent pk (i.e., allow all)
             obj_perm.save()
 
-            # 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,
-            )
+            # 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))
 
     class BulkRenameObjectsViewTestCase(ModelViewTestCase):
         """
@@ -1454,8 +1441,6 @@ 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):

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

@@ -31,7 +31,6 @@ class AuthenticationEnforcedTestCase(TestCase):
                     "/health/",
                     "/login/",
                     "/media-failure/",
-                    "/robots.txt",
                     "/template.css",
                 ]:
                     self.assertHttpStatus(response, 200, msg=url)

nautobot/core/tests/runner.py

@@ -142,7 +142,7 @@ class NautobotTestRunner(DiscoverRunner):
                             # branches/releases of Nautobot in separate files.
                             hexdigest = hashlib.shake_128(
                                 ",".join(
-                                    sorted(f"{m.app}.{m.name}" for m in MigrationRecorder.Migration.objects.all())  # pylint: disable=no-member
+                                    sorted(f"{m.app}.{m.name}" for m in MigrationRecorder.Migration.objects.all())
                                 ).encode("utf-8")
                             ).hexdigest(10)
                             command += ["--fixture-file", f"development/factory_dump.{hexdigest}.json"]