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

nautobot/dcim/tests/test_filters.py

@@ -1,3 +1,4 @@
+# pylint: disable=no-member  # it doesn't recognize the class attributes assigned in common_test_data()
 import uuid
 
 from django.contrib.auth import get_user_model
@@ -44,6 +45,7 @@ from nautobot.dcim.filters import (
     InterfaceRedundancyGroupAssociationFilterSet,
     InterfaceRedundancyGroupFilterSet,
     InterfaceTemplateFilterSet,
+    InterfaceVDCAssignmentFilterSet,
     InventoryItemFilterSet,
     LocationFilterSet,
     LocationTypeFilterSet,
@@ -67,6 +69,7 @@ from nautobot.dcim.filters import (
     SoftwareImageFileFilterSet,
     SoftwareVersionFilterSet,
     VirtualChassisFilterSet,
+    VirtualDeviceContextFilterSet,
 )
 from nautobot.dcim.models import (
     Cable,
@@ -89,6 +92,7 @@ from nautobot.dcim.models import (
     InterfaceRedundancyGroup,
     InterfaceRedundancyGroupAssociation,
     InterfaceTemplate,
+    InterfaceVDCAssignment,
     InventoryItem,
     Location,
     LocationType,
@@ -112,11 +116,13 @@ from nautobot.dcim.models import (
     SoftwareImageFile,
     SoftwareVersion,
     VirtualChassis,
+    VirtualDeviceContext,
 )
 from nautobot.extras.models import ExternalIntegration, Role, SecretsGroup, Status, Tag
 from nautobot.ipam.models import IPAddress, Namespace, Prefix, Service, VLAN, VLANGroup
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import Cluster, ClusterType, VirtualMachine
+from nautobot.wireless.models import RadioProfile, WirelessNetwork
 
 # Use the proper swappable User model
 User = get_user_model()
@@ -593,7 +599,6 @@ def common_test_data(cls):
     )
 
     device_statuses = Status.objects.get_for_model(Device)
-
     cls.devices = (
         Device.objects.create(
             name="Device 1",
@@ -994,11 +999,12 @@ class PathEndpointModelTestMixin:
             )
 
 
-class LocationTypeFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class LocationTypeFilterSetTestCase(FilterTestCases.FilterTestCase):
     queryset = LocationType.objects.all()
     filterset = LocationTypeFilterSet
     generic_filter_tests = [
         ("description",),
+        ("name",),
         ("parent", "parent__id"),
         ("parent", "parent__name"),
     ]
@@ -1030,7 +1036,7 @@ class LocationTypeFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
             )
 
 
-class LocationFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
+class LocationFilterSetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = Location.objects.all()
     filterset = LocationFilterSet
     tenancy_related_name = "locations"
@@ -1051,6 +1057,7 @@ class LocationFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase, FilterTe
         ("longitude",),
         ("location_type", "location_type__id"),
         ("location_type", "location_type__name"),
+        ("name",),
         ("parent", "parent__id"),
         ("parent", "parent__name"),
         ("physical_address",),
@@ -1101,17 +1108,13 @@ class LocationFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase, FilterTe
             Location.objects.filter(location_type__content_types=ct),
         )
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, self.queryset.filter(pk=value))
 
-
-class RackGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class RackGroupTestCase(FilterTestCases.FilterTestCase):
     queryset = RackGroup.objects.all()
     filterset = RackGroupFilterSet
     generic_filter_tests = [
         ("description",),
+        ("name",),
         ("parent", "parent__id"),
         ("parent", "parent__name"),
         ("power_panels", "power_panels__id"),
@@ -1230,11 +1233,6 @@ class RackTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilter
             params = {"outer_unit": [RackDimensionUnitChoices.UNIT_MILLIMETER]}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class RackReservationTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = RackReservation.objects.all()
@@ -1254,13 +1252,8 @@ class RackReservationTestCase(FilterTestCases.FilterTestCase, FilterTestCases.Te
     def setUpTestData(cls):
         common_test_data(cls)
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
-class ManufacturerTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class ManufacturerTestCase(FilterTestCases.FilterTestCase):
     queryset = Manufacturer.objects.all()
     filterset = ManufacturerFilterSet
     generic_filter_tests = [
@@ -1269,6 +1262,7 @@ class ManufacturerTestCase(FilterTestCases.NameOnlyFilterTestCase):
         ("device_types", "device_types__model"),
         ("inventory_items", "inventory_items__id"),
         ("inventory_items", "inventory_items__name"),
+        ("name",),
         ("platforms", "platforms__id"),
         ("platforms", "platforms__name"),
     ]
@@ -1284,13 +1278,14 @@ class ManufacturerTestCase(FilterTestCases.NameOnlyFilterTestCase):
         InventoryItem.objects.create(device=devices[2], name="Inventory Item 3", manufacturer=cls.manufacturers[2])
 
 
-class DeviceFamilyTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class DeviceFamilyTestCase(FilterTestCases.FilterTestCase):
     queryset = DeviceFamily.objects.all()
     filterset = DeviceFamilyFilterSet
     generic_filter_tests = [
         ("description",),
         ("device_types", "device_types__id"),
         ("device_types", "device_types__model"),
+        ("name",),
     ]
 
 
@@ -1480,11 +1475,6 @@ class DeviceTypeTestCase(FilterTestCases.FilterTestCase):
                 self.queryset.exclude(device_bay_templates__isnull=False),
             )
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class ConsolePortTemplateTestCase(ModularComponentTemplateTestMixin, FilterTestCases.FilterTestCase):
     queryset = ConsolePortTemplate.objects.all()
@@ -1632,7 +1622,7 @@ class DeviceBayTemplateTestCase(ComponentTemplateTestMixin, FilterTestCases.Filt
     filterset = DeviceBayTemplateFilterSet
 
 
-class PlatformTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class PlatformTestCase(FilterTestCases.FilterTestCase):
     queryset = Platform.objects.all()
     filterset = PlatformFilterSet
     generic_filter_tests = [
@@ -1640,6 +1630,7 @@ class PlatformTestCase(FilterTestCases.NameOnlyFilterTestCase):
         ("devices", "devices__id"),
         ("manufacturer", "manufacturer__id"),
         ("manufacturer", "manufacturer__name"),
+        ("name",),
         ("napalm_driver",),
         ("virtual_machines", "virtual_machines__id"),
     ]
@@ -1716,6 +1707,8 @@ class DeviceTestCase(
         ("rack", "rack__name"),
         ("rack_group", "rack__rack_group__id"),
         ("rack_group", "rack__rack_group__name"),
+        ("radio_profiles", "controller_managed_device_group__radio_profiles__id"),
+        ("radio_profiles", "controller_managed_device_group__radio_profiles__name"),
         ("rear_ports", "rear_ports__id"),
         ("role", "role__id"),
         ("role", "role__name"),
@@ -1731,6 +1724,8 @@ class DeviceTestCase(
         ("vc_priority",),
         ("virtual_chassis", "virtual_chassis__id"),
         ("virtual_chassis", "virtual_chassis__name"),
+        ("wireless_networks", "controller_managed_device_group__wireless_networks__id"),
+        ("wireless_networks", "controller_managed_device_group__wireless_networks__name"),
     ]
 
     @classmethod
@@ -1772,6 +1767,14 @@ class DeviceTestCase(
         Service.objects.create(device=devices[1], name="dns", protocol="udp", ports=[53])
 
         cls.controller_managed_device_groups = list(ControllerManagedDeviceGroup.objects.all()[:2])
+        cls.controller_managed_device_groups[0].radio_profiles.set(RadioProfile.objects.all()[:2])
+        cls.controller_managed_device_groups[0].wireless_networks.set(
+            WirelessNetwork.objects.filter(controller_managed_device_groups__isnull=True)[:2]
+        )
+        cls.controller_managed_device_groups[1].radio_profiles.set(RadioProfile.objects.all()[2:4])
+        cls.controller_managed_device_groups[1].wireless_networks.set(
+            WirelessNetwork.objects.filter(controller_managed_device_groups__isnull=True)[2:4]
+        )
         cls.device_redundancy_groups = list(DeviceRedundancyGroup.objects.all()[:2])
         Device.objects.filter(pk=devices[0].pk).update(
             controller_managed_device_group=cls.controller_managed_device_groups[0],
@@ -1928,45 +1931,6 @@ class DeviceTestCase(
                 Device.objects.filter(local_config_context_data__isnull=True),
             )
 
-    def test_search(self):
-        filter_fields = (
-            "name",
-            "serial",
-            "inventory_items__serial",
-            "asset_tag",
-            "device_type__manufacturer__name",
-            "comments",
-        )
-        for filter_field in filter_fields:
-            with self.subTest(f"test q filter by field {filter_field}"):
-                value = (
-                    self.queryset.values_list(filter_field, flat=True)
-                    .exclude(**{f"{filter_field}__in": ["", None]})
-                    .first()
-                )
-                params = {"q": value}
-                # TODO: Remove pylint disable after issue is resolved (see: https://github.com/PyCQA/pylint/issues/7381)
-                # pylint: disable=unsupported-binary-operation
-                qs_filter = (
-                    Q(name__icontains=value)
-                    | Q(serial__icontains=value.strip())
-                    | Q(inventory_items__serial__icontains=value.strip())
-                    | Q(asset_tag__icontains=value.strip())
-                    | Q(device_type__manufacturer__name__icontains=value.strip())
-                    | Q(comments__icontains=value)
-                )
-                self.assertQuerysetEqualAndNotEmpty(
-                    self.filterset(params, self.queryset).qs,
-                    self.queryset.filter(qs_filter),
-                )
-
-        with self.subTest("test q filter by field pk"):
-            value = self.queryset.values_list("pk", flat=True).first()
-            params = {"q": value}
-            self.assertQuerysetEqualAndNotEmpty(
-                self.filterset(params, self.queryset).qs, self.queryset.filter(id=value)
-            )
-
 
 class ConsolePortTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMixin, FilterTestCases.FilterTestCase):
     queryset = ConsolePort.objects.all()
@@ -2199,6 +2163,8 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         ("tagged_vlans", "tagged_vlans__vid"),
         ("untagged_vlan", "untagged_vlan__id"),
         ("untagged_vlan", "untagged_vlan__vid"),
+        ("virtual_device_contexts", "virtual_device_contexts__id"),
+        ("virtual_device_contexts", "virtual_device_contexts__name"),
     ]
 
     @classmethod
@@ -2437,6 +2403,17 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
 
         cabled_interfaces[0].add_ip_addresses([ipaddresses[0], ipaddresses[2]])
         cabled_interfaces[1].add_ip_addresses([ipaddresses[1], ipaddresses[3]])
+        # Virtual Device Context
+        vdc_status = Status.objects.get_for_model(VirtualDeviceContext).first()
+        vdcs = [
+            VirtualDeviceContext.objects.create(
+                device=devices[2], status=vdc_status, identifier=200 + idx, name=f"Test VDC {idx}"
+            )
+            for idx in range(3)
+        ]
+        vdcs[0].interfaces.set(lag_interfaces)
+        vdcs[1].interfaces.set(lag_interfaces)
+        vdcs[2].interfaces.set(lag_interfaces)
 
     def test_enabled(self):
         # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
@@ -3088,11 +3065,6 @@ class InventoryItemTestCase(DeviceComponentTestMixin, FilterTestCases.FilterTest
             params = {"serial": "abc"}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class VirtualChassisTestCase(FilterTestCases.FilterTestCase):
     queryset = VirtualChassis.objects.all()
@@ -3177,11 +3149,6 @@ class VirtualChassisTestCase(FilterTestCases.FilterTestCase):
         Device.objects.filter(pk=devices[3].pk).update(virtual_chassis=virtual_chassis[1])
         Device.objects.filter(pk=devices[5].pk).update(virtual_chassis=virtual_chassis[2])
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class CableTestCase(FilterTestCases.FilterTestCase):
     queryset = Cable.objects.all()
@@ -3975,6 +3942,8 @@ class ControllerFilterSetTestCase(FilterTestCases.FilterTestCase):
         ("controller_device", "controller_device__name"),
         ("controller_device_redundancy_group", "controller_device_redundancy_group__id"),
         ("controller_device_redundancy_group", "controller_device_redundancy_group__name"),
+        ("wireless_networks", "controller_managed_device_groups__wireless_networks__id"),
+        ("wireless_networks", "controller_managed_device_groups__wireless_networks__name"),
     )
 
     @classmethod
@@ -4117,3 +4086,130 @@ class ModuleBayTestCase(FilterTestCases.FilterTestCase):
         module_bays = ModuleBay.objects.all()[:2]
         module_bays[0].tags.set(Tag.objects.get_for_model(ModuleBay))
         module_bays[1].tags.set(Tag.objects.get_for_model(ModuleBay)[:3])
+
+
+class VirtualDeviceContextTestCase(FilterTestCases.FilterTestCase, FilterTestCases):
+    queryset = VirtualDeviceContext.objects.all()
+    filterset = VirtualDeviceContextFilterSet
+    generic_filter_tests = [
+        ("description",),
+        ("device", "device__name"),
+        ("device", "device__id"),
+        ("tenant", "tenant__name"),
+        ("tenant", "tenant__id"),
+        ("interfaces", "interfaces__id"),
+        ("interfaces", "interfaces__name"),
+        ("name",),
+        ("role", "role__name"),
+        ("status", "status__name"),
+        ("role", "role__id"),
+        ("status", "status__id"),
+    ]
+
+    @classmethod
+    def setUpTestData(cls):
+        device = Device.objects.first()
+        intf_status = Status.objects.get_for_model(Interface).first()
+        vdc_status = Status.objects.get_for_model(VirtualDeviceContext).first()
+        intf_role = Role.objects.get_for_model(Interface).first()
+        interface = Interface.objects.create(
+            name="Int1", device=device, status=intf_status, role=intf_role, type=InterfaceTypeChoices.TYPE_100GE_CFP
+        )
+        cls.ips_v4 = IPAddress.objects.filter(ip_version=4)[:3]
+        cls.ips_v6 = IPAddress.objects.filter(ip_version=6)[:3]
+        interface.add_ip_addresses([*cls.ips_v4, *cls.ips_v6])
+        vdcs = [
+            VirtualDeviceContext.objects.create(
+                device=device,
+                status=vdc_status,
+                identifier=200 + idx,
+                name=f"Test VDC {idx}",
+                primary_ip4=cls.ips_v4[idx],
+                primary_ip6=cls.ips_v6[idx],
+            )
+            for idx in range(3)
+        ]
+        vdcs[0].tags.set(Tag.objects.get_for_model(VirtualDeviceContext))
+        vdcs[1].tags.set(Tag.objects.get_for_model(VirtualDeviceContext)[:3])
+
+        interfaces = [
+            Interface.objects.create(
+                device=device,
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                name=f"Interface 00{idx}",
+                status=intf_status,
+            )
+            for idx in range(3)
+        ]
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[0], interface=interfaces[0])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[0])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[1])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[2], interface=interfaces[2])
+
+    def test_has_primary_ip(self):
+        # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
+        with self.subTest():
+            params = {"has_primary_ip": True}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                VirtualDeviceContext.objects.filter(Q(primary_ip4__isnull=False) | Q(primary_ip6__isnull=False)),
+            )
+        with self.subTest():
+            params = {"has_primary_ip": False}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                VirtualDeviceContext.objects.filter(primary_ip4__isnull=True, primary_ip6__isnull=True),
+            )
+
+    def test_primary_ip4(self):
+        params = {"primary_ip4": ["192.0.2.1/24", self.ips_v4[0].pk]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, VirtualDeviceContext.objects.filter(primary_ip4=self.ips_v4[0])
+        )
+
+    def test_primary_ip6(self):
+        params = {"primary_ip6": ["fe80::8ef:3eff:fe4c:3895/24", self.ips_v6[1].pk]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, VirtualDeviceContext.objects.filter(primary_ip6=self.ips_v6[1])
+        )
+
+
+class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = InterfaceVDCAssignment.objects.all()
+    filterset = InterfaceVDCAssignmentFilterSet
+    generic_filter_tests = [
+        ("virtual_device_context", "virtual_device_context__id"),
+        ("virtual_device_context", "virtual_device_context__name"),
+        ("interface", "interface__id"),
+        ("interface", "interface__name"),
+        ("device", "interface__device__id"),
+        ("device", "interface__device__name"),
+    ]
+
+    @classmethod
+    def setUpTestData(cls):
+        device = Device.objects.first()
+        vdc_status = Status.objects.get_for_model(VirtualDeviceContext)[0]
+        interface_status = Status.objects.get_for_model(Interface)[0]
+        interfaces = [
+            Interface.objects.create(
+                device=device,
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                name=f"Interface 00{idx}",
+                status=interface_status,
+            )
+            for idx in range(3)
+        ]
+        vdcs = [
+            VirtualDeviceContext.objects.create(
+                device=device,
+                status=vdc_status,
+                identifier=200 + idx,
+                name=f"Test VDC {idx}",
+            )
+            for idx in range(3)
+        ]
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[0], interface=interfaces[0])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[0])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[1])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[2], interface=interfaces[2])

nautobot/dcim/tests/test_graphql.py

@@ -83,3 +83,55 @@ class GraphQLTestCase(TestCase):
             self.assertEqual(
                 resp["data"]["devices"][0]["platform"]["network_driver_mappings"]["scrapli"], "cisco_iosxe"
             )
+
+        with self.subTest("device serial number query"):
+            non_empty_serial_device = Device.objects.first()
+            non_empty_serial_device.serial = "1234567890abceFGHIJKL"
+            non_empty_serial_device.save()
+
+            # Test device serial query default behavior: serial__ie
+            query = 'query { devices (serial: " ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertEqual(device["serial"], "")
+
+            # Test device serial default filter with non-empty serial number
+            query = 'query { devices (serial:"' + non_empty_serial_device.serial.lower() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            self.assertEqual(resp["data"]["devices"][0]["serial"], non_empty_serial_device.serial)
+
+            # Test device serial iexact filter with non-empty serial number
+            query = 'query { devices (serial__ie:"' + non_empty_serial_device.serial.upper() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            self.assertEqual(resp["data"]["devices"][0]["serial"], non_empty_serial_device.serial)
+
+            # Test device serial__nie filter with non-empty serial number
+            query = 'query { devices (serial__nie:"' + non_empty_serial_device.serial.lower() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], non_empty_serial_device.serial)
+
+            # Test device serial__ie filter with empty serial number
+            query = 'query { devices (serial__ie:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertEqual(device["serial"], "")
+
+            # Test device serial__nie filter with empty serial number
+            query = 'query { devices (serial__nie:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], "")
+
+            # Test device serial__n filter with empty serial number
+            query = 'query { devices (serial__n:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], "")

nautobot/dcim/tests/test_jobs.py

@@ -0,0 +1,118 @@
+from django.contrib.contenttypes.models import ContentType
+
+from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
+from nautobot.dcim.models import (
+    Device,
+    DeviceType,
+    DeviceTypeToSoftwareImageFile,
+    Location,
+    LocationType,
+    Manufacturer,
+    Platform,
+    SoftwareImageFile,
+    SoftwareVersion,
+)
+from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.models import JobLogEntry, Role, Status
+
+
+def create_common_data_for_software_related_test_cases():
+    manufacturer = Manufacturer.objects.create(name="Manufacturer 1")
+    Platform.objects.create(name="Platform 1")
+    platform = Platform.objects.create(name="Platform 2", manufacturer=manufacturer)
+
+    status = Status.objects.first()
+    software_version_ct = ContentType.objects.get_for_model(SoftwareVersion)
+    software_image_file_ct = ContentType.objects.get_for_model(SoftwareImageFile)
+    status.content_types.add(software_version_ct)
+    status.content_types.add(software_image_file_ct)
+
+    software_version = SoftwareVersion.objects.create(
+        platform=platform,
+        version="Test version 1.0.0",
+        status=status,
+    )
+    software_image_file = SoftwareImageFile.objects.create(
+        software_version=software_version,
+        image_file_name="software_image_file_qs_test_1.bin",
+        status=status,
+    )
+
+    device_type = DeviceType.objects.create(
+        manufacturer=manufacturer,
+        model="Cisco CSR1000v",
+        u_height=0,
+    )
+
+    device_ct = ContentType.objects.get_for_model(Device)
+
+    device_role = Role.objects.create(name="Device Status")
+    device_role.content_types.set([device_ct])
+
+    location_type = LocationType.objects.create(name="Test Location Type")
+    location_type.content_types.set([device_ct])
+    location = Location.objects.create(
+        name="Device Location",
+        location_type=location_type,
+        status=Status.objects.get_for_model(Location).first(),
+    )
+    device_status = Status.objects.get_for_model(Device).first()
+    Device.objects.create(
+        device_type=device_type,
+        role=device_role,
+        name="Device 1",
+        location=location,
+        status=device_status,
+        software_version=software_version,
+    )
+    DeviceTypeToSoftwareImageFile.objects.create(device_type=device_type, software_image_file=software_image_file)
+
+
+class TestSoftwareImageFileTestCase(TransactionTestCase):
+    def test_correct_handling_for_model_protected_error(self):
+        create_common_data_for_software_related_test_cases()
+        software_image_file = SoftwareImageFile.objects.first()
+
+        self.add_permissions("dcim.delete_softwareimagefile")
+        pk_list = [str(software_image_file.pk)]
+        initial_count = SoftwareImageFile.objects.all().count()
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=ContentType.objects.get_for_model(SoftwareImageFile).id,
+            delete_all=False,
+            filter_query_params={},
+            pk_list=pk_list,
+            username=self.user.username,
+        )
+        logs = JobLogEntry.objects.filter(job_result=job_result)
+        print([(log.message, log.log_level) for log in logs])
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn("Caught ProtectedError while attempting to delete objects", error_log.message)
+        self.assertEqual(initial_count, SoftwareImageFile.objects.all().count())
+
+
+class TestSoftwareVersionTestCase(TransactionTestCase):
+    def test_correct_handling_for_model_protected_error(self):
+        create_common_data_for_software_related_test_cases()
+        software_version = SoftwareVersion.objects.first()
+
+        initial_count = SoftwareVersion.objects.all().count()
+        self.add_permissions("dcim.delete_softwareversion")
+        pk_list = [str(software_version.pk)]
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=ContentType.objects.get_for_model(SoftwareVersion).id,
+            delete_all=False,
+            filter_query_params={},
+            pk_list=pk_list,
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn("Caught ProtectedError while attempting to delete objects", error_log.message)
+        self.assertEqual(initial_count, SoftwareVersion.objects.all().count())