nautobot 2.2.0b1__py3-none-any.whl → 2.2.2__py3-none-any.whl

nautobot/extras/tasks.py

@@ -14,7 +14,7 @@ logger = getLogger("nautobot.extras.tasks")
 
 
 @nautobot_task
-def update_custom_field_choice_data(field_id, old_value, new_value):
+def update_custom_field_choice_data(field_id, old_value, new_value, change_context=None):
     """
     Update the values for a custom field choice used in objects' _custom_field_data for the given field.
 
@@ -23,6 +23,8 @@ def update_custom_field_choice_data(field_id, old_value, new_value):
         old_value (str): The existing value of the choice
         new_value (str): The value which will be used as replacement
     """
+    # Circular Import
+    from nautobot.extras.context_managers import web_request_context
     from nautobot.extras.models import CustomField
 
     try:
@@ -35,19 +37,43 @@ def update_custom_field_choice_data(field_id, old_value, new_value):
         # Loop through all field content types and search for values to update
         for ct in field.content_types.all():
             model = ct.model_class()
-            for obj in model.objects.filter(**{f"_custom_field_data__{field.key}": old_value}):
-                obj._custom_field_data[field.key] = new_value
-                obj.save()
+            if change_context is not None:
+                with web_request_context(
+                    user=change_context.get("user"),
+                    change_id=change_context.get("change_id"),
+                    context_detail=change_context.get("context_detail"),
+                    context=change_context.get("context"),
+                ):
+                    for obj in model.objects.filter(**{f"_custom_field_data__{field.key}": old_value}):
+                        obj._custom_field_data[field.key] = new_value
+                        obj.save()
+            else:
+                for obj in model.objects.filter(**{f"_custom_field_data__{field.key}": old_value}):
+                    obj._custom_field_data[field.key] = new_value
+                    obj.save()
 
     elif field.type == CustomFieldTypeChoices.TYPE_MULTISELECT:
         # Loop through all field content types and search for values to update
         for ct in field.content_types.all():
             model = ct.model_class()
-            for obj in model.objects.filter(**{f"_custom_field_data__{field.key}__contains": old_value}):
-                old_list = obj._custom_field_data[field.key]
-                new_list = [new_value if e == old_value else e for e in old_list]
-                obj._custom_field_data[field.key] = new_list
-                obj.save()
+            if change_context is not None:
+                with web_request_context(
+                    user=change_context.get("user"),
+                    change_id=change_context.get("change_id"),
+                    context_detail=change_context.get("context_detail"),
+                    context=change_context.get("context"),
+                ):
+                    for obj in model.objects.filter(**{f"_custom_field_data__{field.key}__contains": old_value}):
+                        old_list = obj._custom_field_data[field.key]
+                        new_list = [new_value if e == old_value else e for e in old_list]
+                        obj._custom_field_data[field.key] = new_list
+                        obj.save()
+            else:
+                for obj in model.objects.filter(**{f"_custom_field_data__{field.key}__contains": old_value}):
+                    old_list = obj._custom_field_data[field.key]
+                    new_list = [new_value if e == old_value else e for e in old_list]
+                    obj._custom_field_data[field.key] = new_list
+                    obj.save()
 
     else:
         logger.error(f"Unknown field type, failing to act on choice data for this field {field.key}.")
@@ -57,7 +83,7 @@ def update_custom_field_choice_data(field_id, old_value, new_value):
 
 
 @nautobot_task
-def delete_custom_field_data(field_key, content_type_pk_set):
+def delete_custom_field_data(field_key, content_type_pk_set, change_context=None):
     """
     Delete the values for a custom field
 
@@ -65,16 +91,30 @@ def delete_custom_field_data(field_key, content_type_pk_set):
         field_key (str): The key of the custom field which is being deleted
         content_type_pk_set (list): List of PKs for content types to act upon
     """
+    # Circular Import
+    from nautobot.extras.context_managers import web_request_context
+
     with transaction.atomic():
         for ct in ContentType.objects.filter(pk__in=content_type_pk_set):
             model = ct.model_class()
-            for obj in model.objects.filter(**{f"_custom_field_data__{field_key}__isnull": False}):
-                del obj._custom_field_data[field_key]
-                obj.save()
+            if change_context is not None:
+                with web_request_context(
+                    user=change_context.get("user"),
+                    change_id=change_context.get("change_id"),
+                    context_detail=change_context.get("context_detail"),
+                    context=change_context.get("context"),
+                ):
+                    for obj in model.objects.filter(**{f"_custom_field_data__{field_key}__isnull": False}):
+                        del obj._custom_field_data[field_key]
+                        obj.save()
+            else:
+                for obj in model.objects.filter(**{f"_custom_field_data__{field_key}__isnull": False}):
+                    del obj._custom_field_data[field_key]
+                    obj.save()
 
 
 @nautobot_task
-def provision_field(field_id, content_type_pk_set):
+def provision_field(field_id, content_type_pk_set, change_context=None):
     """
     Provision a new custom field on all relevant content type object instances.
 
@@ -82,6 +122,8 @@ def provision_field(field_id, content_type_pk_set):
         field_id (uuid4): The PK of the custom field being provisioned
         content_type_pk_set (list): List of PKs for content types to act upon
     """
+    # Circular Import
+    from nautobot.extras.context_managers import web_request_context
     from nautobot.extras.models import CustomField
 
     try:
@@ -93,9 +135,20 @@ def provision_field(field_id, content_type_pk_set):
     with transaction.atomic():
         for ct in ContentType.objects.filter(pk__in=content_type_pk_set):
             model = ct.model_class()
-            for obj in model.objects.all():
-                obj._custom_field_data.setdefault(field.key, field.default)
-                obj.save()
+            if change_context is not None:
+                with web_request_context(
+                    user=change_context.get("user"),
+                    change_id=change_context.get("change_id"),
+                    context_detail=change_context.get("context_detail"),
+                    context=change_context.get("context"),
+                ):
+                    for obj in model.objects.all():
+                        obj._custom_field_data.setdefault(field.key, field.default)
+                        obj.save()
+            else:
+                for obj in model.objects.all():
+                    obj._custom_field_data.setdefault(field.key, field.default)
+                    obj.save()
 
     return True
 

nautobot/extras/tests/test_api.py

@@ -18,6 +18,7 @@ from nautobot.core.testing import APITestCase, APIViewTestCases
 from nautobot.core.testing.utils import disable_warnings
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.dcim.models import (
+    Controller,
     Device,
     DeviceType,
     Location,
@@ -408,11 +409,9 @@ class ContactTest(APIViewTestCases.APIViewTestCase):
             {
                 "name": "Contact 3",
                 "phone": "555-0123",
-                "email": "",
             },
             {
                 "name": "Contact 4",
-                "phone": "",
                 "email": "contact4@example.com",
             },
         ]
@@ -2851,6 +2850,7 @@ class RelationshipTest(APIViewTestCases.APIViewTestCase, RequiredRelationshipTes
         vlan_groups = VLANGroup.objects.all()[:2]
 
         # Try deleting all devices and then creating 2 VLANs (fails):
+        Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
         response = send_bulk_data(
             "post",
@@ -3611,11 +3611,9 @@ class TeamTest(APIViewTestCases.APIViewTestCase):
             {
                 "name": "Team 3",
                 "phone": "555-0123",
-                "email": "",
             },
             {
                 "name": "Team 4",
-                "phone": "",
                 "email": "team4@example.com",
                 "address": "Rainbow Bridge, Central NJ",
             },

nautobot/extras/tests/test_context_managers.py

@@ -7,7 +7,10 @@ from nautobot.core.testing import TransactionTestCase
 from nautobot.core.utils.lookup import get_changes_for_model
 from nautobot.dcim.models import Location, LocationType
 from nautobot.extras.choices import ObjectChangeActionChoices, ObjectChangeEventContextChoices
-from nautobot.extras.context_managers import web_request_context
+from nautobot.extras.context_managers import (
+    deferred_change_logging_for_bulk_operation,
+    web_request_context,
+)
 from nautobot.extras.models import Status, Webhook
 
 # Use the proper swappable User model
@@ -193,3 +196,97 @@ class WebRequestContextTransactionTestCase(TransactionTestCase):
             Status.objects.create(name="Test Status 2")
 
         self.assertEqual(get_changes_for_model(Status).count(), 2)
+
+
+class BulkEditDeleteChangeLogging(TestCase):
+    def setUp(self):
+        self.user = User.objects.create_user(
+            username="jacob",
+            email="jacob@example.com",
+            password="top_secret",  # noqa: S106  # hardcoded-password-func-arg -- ok as this is test code only
+        )
+
+    def test_change_log_created(self):
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+
+        location = Location.objects.get(name="Test Location 1")
+        oc_list = get_changes_for_model(location).order_by("pk")
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].changed_object, location)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+
+    def test_delete(self):
+        """Test that deletes raise an exception"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with self.assertRaises(ValueError):
+            with web_request_context(self.user):
+                with deferred_change_logging_for_bulk_operation():
+                    location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                    location.save()
+                    location.delete()
+
+    def test_create_then_update(self):
+        """Test that a create followed by an update is logged as a single create"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+                location.description = "changed"
+                location.save()
+
+        oc_list = get_changes_for_model(location)
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+        snapshots = oc_list[0].get_snapshots()
+        self.assertIsNone(snapshots["prechange"])
+        self.assertIsNotNone(snapshots["postchange"])
+        self.assertIsNone(snapshots["differences"]["removed"])
+        self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
+
+    def test_bulk_edit(self):
+        """Test that edits to multiple objects are correctly logged"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        locations = [
+            Location(name=f"Test Location {i}", location_type=location_type, status=location_status)
+            for i in range(1, 4)
+        ]
+        Location.objects.bulk_create(locations)
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                for location in locations:
+                    location.description = "changed"
+                    location.save()
+
+        oc_list = get_changes_for_model(Location)
+        self.assertEqual(len(oc_list), 3)
+        for oc in oc_list:
+            self.assertEqual(oc.action, ObjectChangeActionChoices.ACTION_UPDATE)
+            snapshots = oc.get_snapshots()
+            self.assertIsNone(snapshots["prechange"])
+            self.assertIsNotNone(snapshots["postchange"])
+            self.assertIsNone(snapshots["differences"]["removed"])
+            self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
+
+    def test_change_log_context(self):
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user, context_detail="test_change_log_context"):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+
+        location = Location.objects.get(name="Test Location 1")
+        oc_list = get_changes_for_model(location)
+        with self.subTest():
+            self.assertEqual(oc_list[0].change_context, ObjectChangeEventContextChoices.CONTEXT_ORM)
+        with self.subTest():
+            self.assertEqual(oc_list[0].change_context_detail, "test_change_log_context")

nautobot/extras/tests/test_customfields.py

@@ -16,11 +16,13 @@ from nautobot.core.tables import CustomFieldColumn
 from nautobot.core.testing import APITestCase, TestCase, TransactionTestCase
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.core.testing.utils import post_data
+from nautobot.core.utils.lookup import get_changes_for_model
 from nautobot.dcim.filters import LocationFilterSet
 from nautobot.dcim.forms import RackFilterForm
 from nautobot.dcim.models import Device, Location, LocationType, Rack
 from nautobot.dcim.tables import LocationTable
 from nautobot.extras.choices import CustomFieldFilterLogicChoices, CustomFieldTypeChoices
+from nautobot.extras.context_managers import web_request_context
 from nautobot.extras.models import ComputedField, CustomField, CustomFieldChoice, Status
 from nautobot.users.models import ObjectPermission
 from nautobot.virtualization.models import VirtualMachine
@@ -1537,8 +1539,10 @@ class CustomFieldFilterTest(TestCase):
         cf.save()
         cf.content_types.set([obj_type])
 
-        CustomFieldChoice.objects.create(custom_field=cf, value="Foo")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Bar")
+        cls.select_choices = (
+            CustomFieldChoice.objects.create(custom_field=cf, value="Foo"),
+            CustomFieldChoice.objects.create(custom_field=cf, value="Bar"),
+        )
 
         # Multi-select filtering
         cf = CustomField(
@@ -1548,8 +1552,11 @@ class CustomFieldFilterTest(TestCase):
         cf.save()
         cf.content_types.set([obj_type])
 
-        CustomFieldChoice.objects.create(custom_field=cf, value="Foo")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Bar")
+        cls.multiselect_choices = (
+            CustomFieldChoice.objects.create(custom_field=cf, value="Foo"),
+            CustomFieldChoice.objects.create(custom_field=cf, value="Bar"),
+        )
+
         cls.location_type = LocationType.objects.get(name="Campus")
         location_status = Status.objects.get_for_model(Location).first()
         Location.objects.create(
@@ -1844,6 +1851,10 @@ class CustomFieldFilterTest(TestCase):
             self.filterset({"cf_cf8": ["Foo", "AR"]}, self.queryset).qs,
             self.queryset.filter(_custom_field_data__cf8__in=["Foo", "AR"]),
         )
+        self.assertQuerysetEqualAndNotEmpty(  # https://github.com/nautobot/nautobot/issues/5009
+            self.filterset({"cf_cf8": [str(choice.pk) for choice in self.select_choices]}, self.queryset).qs,
+            self.queryset.filter(_custom_field_data__cf8__in=[choice.value for choice in self.select_choices]),
+        )
         self.assertQuerysetEqual(
             self.filterset({"cf_cf8__n": ["Foo"]}, self.queryset).qs,
             self.queryset.exclude(_custom_field_data__cf8="Foo")
@@ -1913,6 +1924,10 @@ class CustomFieldFilterTest(TestCase):
             self.filterset({"cf_cf9": "Bar"}, self.queryset).qs,
             self.queryset.filter(_custom_field_data__cf9__contains="Bar"),
         )
+        self.assertQuerysetEqualAndNotEmpty(  # https://github.com/nautobot/nautobot/issues/5009
+            self.filterset({"cf_cf9": str(self.multiselect_choices[0].pk)}, self.queryset).qs,
+            self.queryset.filter(_custom_field_data__cf9__contains=self.multiselect_choices[0].value),
+        )
 
 
 class CustomFieldChoiceTest(ModelTestCases.BaseModelTestCase):
@@ -2016,30 +2031,64 @@ class CustomFieldBackgroundTasks(TransactionTestCase):
 
         self.assertEqual(location.cf["cf1"], "Foo")
 
+        with web_request_context(self.user):
+            cf = CustomField(label="CF2", type=CustomFieldTypeChoices.TYPE_TEXT, default="Bar")
+            cf.save()
+            cf.content_types.set([obj_type])
+
+            location.refresh_from_db()
+
+            self.assertEqual(location.cf["cf2"], "Bar")
+
+        oc_list = get_changes_for_model(location).order_by("pk")
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].changed_object, location)
+        self.assertEqual(oc_list[0].change_context_detail, "provision custom field data for new content types")
+        self.assertEqual(oc_list[0].user, self.user)
+
     def test_delete_custom_field_data_task(self):
         obj_type = ContentType.objects.get_for_model(Location)
-        cf = CustomField(
+        cf_1 = CustomField(
             label="CF1",
             type=CustomFieldTypeChoices.TYPE_TEXT,
         )
-        cf.save()
-        cf.content_types.set([obj_type])
+        cf_1.save()
+        cf_1.content_types.set([obj_type])
+        cf_2 = CustomField(
+            label="CF2",
+            type=CustomFieldTypeChoices.TYPE_TEXT,
+        )
+        cf_2.save()
+        cf_2.content_types.set([obj_type])
         location_type = LocationType.objects.create(name="Root Type 2")
         location_status = Status.objects.get_for_model(Location).first()
         location = Location(
             name="Location 1",
             location_type=location_type,
             status=location_status,
-            _custom_field_data={"cf1": "foo"},
+            _custom_field_data={"cf1": "foo", "cf2": "bar"},
         )
         location.save()
 
-        cf.delete()
+        cf_1.delete()
 
         location.refresh_from_db()
 
         self.assertTrue("cf1" not in location.cf)
 
+        with web_request_context(self.user):
+            cf_2.delete()
+
+            location.refresh_from_db()
+
+            self.assertTrue("cf2" not in location.cf)
+
+        oc_list = get_changes_for_model(location).order_by("pk")
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].changed_object, location)
+        self.assertEqual(oc_list[0].change_context_detail, "delete custom field data")
+        self.assertEqual(oc_list[0].user, self.user)
+
     def test_update_custom_field_choice_data_task(self):
         obj_type = ContentType.objects.get_for_model(Location)
         cf = CustomField(
@@ -2068,6 +2117,20 @@ class CustomFieldBackgroundTasks(TransactionTestCase):
 
         self.assertEqual(location.cf["cf1"], "Bar")
 
+        with web_request_context(self.user):
+            choice.value = "FizzBuzz"
+            choice.save()
+
+            location.refresh_from_db()
+
+            self.assertEqual(location.cf["cf1"], "FizzBuzz")
+
+        oc_list = get_changes_for_model(location).order_by("pk")
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].changed_object, location)
+        self.assertEqual(oc_list[0].change_context_detail, "update custom field choice data")
+        self.assertEqual(oc_list[0].user, self.user)
+
 
 class CustomFieldTableTest(TestCase):
     """

nautobot/extras/tests/test_dynamicgroups.py

@@ -16,6 +16,7 @@ from nautobot.dcim.choices import PortTypeChoices
 from nautobot.dcim.filters import DeviceFilterSet
 from nautobot.dcim.forms import DeviceFilterForm, DeviceForm
 from nautobot.dcim.models import (
+    Controller,
     Device,
     DeviceType,
     FrontPort,
@@ -48,6 +49,7 @@ from nautobot.tenancy.models import Tenant
 class DynamicGroupTestBase(TestCase):
     @classmethod
     def setUpTestData(cls):
+        Controller.objects.filter(controller_device__isnull=False).delete()
         Device.objects.all().delete()
         cls.device_ct = ContentType.objects.get_for_model(Device)
         cls.dynamicgroup_ct = ContentType.objects.get_for_model(DynamicGroup)

nautobot/extras/tests/test_filters.py

@@ -61,6 +61,7 @@ from nautobot.extras.models import (
     ComputedField,
     ConfigContext,
     Contact,
+    ContactAssociation,
     CustomField,
     CustomFieldChoice,
     CustomLink,
@@ -457,7 +458,91 @@ class ContentTypeFilterSetTestCase(FilterTestCases.FilterTestCase):
         )
 
 
-class ContactFilterSetTestCase(FilterTestCases.FilterTestCase):
+class ContactAndTeamFilterSetTestCaseMixin:
+    """Mixin class to test common filters to both Contact and Team filter sets."""
+
+    def test_similar_to_location_data(self):
+        """Complex test to test the complex `similar_to_location_data` method filter."""
+        ContactAssociation.objects.all().delete()
+        self.queryset.delete()
+        location_type = LocationType.objects.filter(parent__isnull=True).first()
+        location_status = Status.objects.get_for_model(Location).first()
+        test_locations = (
+            Location.objects.create(
+                location_type=location_type,
+                name="Filter Test Location 0",
+                status=location_status,
+                contact_name="match 0",
+            ),
+            Location.objects.create(
+                location_type=location_type,
+                name="Filter Test Location 1",
+                status=location_status,
+                contact_email="Test email for location 1 and 2",
+            ),
+            Location.objects.create(
+                location_type=location_type,
+                name="Filter Test Location 2",
+                status=location_status,
+                contact_email="TEST EMAIL FOR LOCATION 1 AND 2",
+                contact_phone="Test phone for location 2 and 3",
+            ),
+            Location.objects.create(
+                location_type=location_type,
+                name="Filter Test Location 3",
+                status=location_status,
+                contact_phone="Test phone for location 2 and 3",
+            ),
+            Location.objects.create(
+                location_type=location_type,
+                name="Filter Test Location 4",
+                status=location_status,
+                contact_name="Hopefully this doesn't match any random factory data",
+                contact_email="Hopefully this doesn't match any random factory data",
+                contact_phone="Hopefully this doesn't match any random factory data",
+                physical_address="Hopefully this doesn't match any random factory data",
+                shipping_address="Hopefully this doesn't match any random factory data",
+            ),
+        )
+
+        self.queryset.create(name="match 0")
+        self.queryset.create(name="match 1 and 2", email="Test email for location 1 and 2")
+        self.queryset.create(name="match 2 and 3", phone="Test phone for location 2 and 3")
+
+        # These subtests are confusing because we're trying to test the NaturalKeyOrPKMultipleChoiceFilter
+        # behavior while also testing the `similar_to_location_data` method filter behavior.
+        with self.subTest("Test name match"):
+            params = {"similar_to_location_data": [test_locations[0].pk]}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                self.queryset.filter(name__in=["match 0"]),
+            )
+        with self.subTest("Test email match"):
+            params = {"similar_to_location_data": [test_locations[1].pk]}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                self.queryset.filter(name__in=["match 1 and 2"]),
+            )
+        with self.subTest("Test phone match"):
+            params = {"similar_to_location_data": [test_locations[2].pk]}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                self.queryset.filter(name__in=["match 1 and 2", "match 2 and 3"]),
+            )
+        with self.subTest("Test email and phone match"):
+            params = {"similar_to_location_data": [test_locations[1].pk, test_locations[3].name]}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                self.queryset.filter(name__in=["match 1 and 2", "match 2 and 3"]),
+            )
+        with self.subTest("Test no match"):
+            params = {"similar_to_location_data": [test_locations[4].pk]}
+            self.assertFalse(self.filterset(params, self.queryset).qs.exists())
+            params = {"similar_to_location_data": [test_locations[4].name]}
+            self.assertFalse(self.filterset(params, self.queryset).qs.exists())
+
+
+class ContactFilterSetTestCase(ContactAndTeamFilterSetTestCaseMixin, FilterTestCases.FilterTestCase):
     queryset = Contact.objects.all()
     filterset = ContactFilterSet
 
@@ -1756,7 +1841,7 @@ class TagTestCase(FilterTestCases.NameOnlyFilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
 
 
-class TeamFilterSetTestCase(FilterTestCases.FilterTestCase):
+class TeamFilterSetTestCase(ContactAndTeamFilterSetTestCaseMixin, FilterTestCases.FilterTestCase):
     queryset = Team.objects.all()
     filterset = TeamFilterSet
 
@@ -1838,8 +1923,8 @@ class RoleTestCase(FilterTestCases.NameOnlyFilterTestCase):
     def test_content_types(self):
         device_ct = ContentType.objects.get_for_model(Device)
         rack_ct = ContentType.objects.get_for_model(Rack)
-        device_roles = self.queryset.filter(content_types=device_ct)
-        params = {"content_types": ["dcim.device"]}
+        device_roles = self.queryset.filter(content_types__in=[device_ct, rack_ct]).distinct()
+        params = {"content_types": ["dcim.device", "dcim.rack"]}
         self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, device_roles)
 
         rack_roles = self.queryset.filter(content_types=rack_ct)

nautobot/extras/tests/test_models.py

@@ -1810,6 +1810,15 @@ class JobResultTestCase(TestCase):
                 JobResult.objects.create(name="ExampleJob2", user=None, result=lambda: 1)
             self.assertEqual(str(err.exception), "Object of type function is not JSON serializable")
 
+    def test_get_task(self):
+        """Assert bug fix for `Cannot resolve keyword 'task_id' into field` #5440"""
+        data = {
+            "output": "valid data",
+        }
+        job_result = JobResult.objects.create(name="ExampleJob1", user=None, result=data)
+
+        self.assertEqual(JobResult.objects.get_task(job_result.pk), job_result)
+
 
 class WebhookTest(ModelTestCases.BaseModelTestCase):
     model = Webhook

nautobot/extras/tests/test_relationships.py

@@ -15,7 +15,15 @@ from nautobot.core.tables import RelationshipColumn
 from nautobot.core.testing import TestCase
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.core.utils.lookup import get_route_for_model
-from nautobot.dcim.models import Device, DeviceTypeToSoftwareImageFile, Location, LocationType, Platform, Rack
+from nautobot.dcim.models import (
+    Controller,
+    Device,
+    DeviceTypeToSoftwareImageFile,
+    Location,
+    LocationType,
+    Platform,
+    Rack,
+)
 from nautobot.dcim.tables import LocationTable
 from nautobot.dcim.tests.test_views import create_test_device
 from nautobot.extras.choices import RelationshipRequiredSideChoices, RelationshipSideChoices, RelationshipTypeChoices
@@ -1165,6 +1173,7 @@ class RequiredRelationshipTestMixin:
         # Protected FK to SoftwareImageFile prevents deletion
         DeviceTypeToSoftwareImageFile.objects.all().delete()
         # Protected FK to SoftwareVersion prevents deletion
+        Controller.objects.all().delete()
         Device.objects.all().update(software_version=None)
 
         # Create required relationships: