nautobot 2.2.4__py3-none-any.whl → 2.2.6__py3-none-any.whl

nautobot/core/testing/views.py

@@ -213,6 +213,8 @@ class ViewTestCases:
                             escape(str(instance.cf.get(custom_field.key) or "")), response_body, msg=response_body
                         )
 
+            return response  # for consumption by child test cases if desired
+
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_get_object_with_constrained_permission(self):
             instance1, instance2 = self._get_queryset().all()[:2]
@@ -230,11 +232,14 @@ class ViewTestCases:
             obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
 
             # Try GET to permitted object
-            self.assertHttpStatus(self.client.get(instance1.get_absolute_url()), 200)
+            response = self.client.get(instance1.get_absolute_url())
+            self.assertHttpStatus(response, 200)
 
             # Try GET to non-permitted object
             self.assertHttpStatus(self.client.get(instance2.get_absolute_url()), 404)
 
+            return response  # for consumption by child test cases if desired
+
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_has_advanced_tab(self):
             instance = self._get_queryset().first()
@@ -740,6 +745,13 @@ class ViewTestCases:
         def get_list_view(self):
             return lookup.get_view_for_model(self.model, view_type="List")
 
+        def test_list_view_has_filter_form(self):
+            view = self.get_list_view()
+            if hasattr(view, "filterset_form"):  # ObjectListView
+                self.assertIsNotNone(view.filterset_form, "List view lacks a FilterForm")
+            if hasattr(view, "filterset_form_class"):  # ObjectListViewMixin
+                self.assertIsNotNone(view.filterset_form_class, "List viewset lacks a FilterForm")
+
         def test_table_with_indentation_is_removed_on_filter_or_sort(self):
             self.user.is_superuser = True
             self.user.save()

nautobot/core/tests/test_utils.py

@@ -4,6 +4,7 @@ from django import forms as django_forms
 from django.apps import apps
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
 from django.db.models import Q
 from django.http import QueryDict
 from django.test import TestCase
@@ -11,7 +12,7 @@ from django.test import TestCase
 from nautobot.circuits import models as circuits_models
 from nautobot.core import exceptions, forms, settings_funcs
 from nautobot.core.api import utils as api_utils
-from nautobot.core.models import fields as core_fields, utils as models_utils
+from nautobot.core.models import fields as core_fields, utils as models_utils, validators
 from nautobot.core.utils import data as data_utils, filtering, lookup, requests
 from nautobot.core.utils.migrations import update_object_change_ct_for_replaced_models
 from nautobot.dcim import filters as dcim_filters, forms as dcim_forms, models as dcim_models, tables
@@ -372,6 +373,52 @@ class SlugifyFunctionsTest(TestCase):
             self.assertEqual(core_fields.slugify_dashes_to_underscores(content), expected)
 
 
+class LaxURLFieldTest(TestCase):
+    """Test LaxURLField and related functionality."""
+
+    VALID_URLS = [
+        "http://example.com",
+        "https://local-dns/foo/bar.git",  # not supported out-of-the-box by Django, hence our custom classes
+        "https://1.1.1.1:8080/",
+        "https://[2001:db8::]/",
+    ]
+    INVALID_URLS = [
+        "unknown://example.com/",
+        "foo:/",
+        "http://file://",
+    ]
+
+    def test_enhanced_url_validator(self):
+        for valid in self.VALID_URLS:
+            with self.subTest(valid=valid):
+                validators.EnhancedURLValidator()(valid)
+
+        for invalid in self.INVALID_URLS:
+            with self.subTest(invalid=invalid):
+                with self.assertRaises(django_forms.ValidationError):
+                    validators.EnhancedURLValidator()(invalid)
+
+    def test_forms_lax_url_field(self):
+        for valid in self.VALID_URLS:
+            with self.subTest(valid=valid):
+                forms.LaxURLField().clean(valid)
+
+        for invalid in self.INVALID_URLS:
+            with self.subTest(invalid=invalid):
+                with self.assertRaises(django_forms.ValidationError):
+                    forms.LaxURLField().clean(invalid)
+
+    def test_models_lax_url_field(self):
+        for valid in self.VALID_URLS:
+            with self.subTest(valid=valid):
+                core_fields.LaxURLField().run_validators(valid)
+
+        for invalid in self.INVALID_URLS:
+            with self.subTest(invalid=invalid):
+                with self.assertRaises(ValidationError):
+                    core_fields.LaxURLField().run_validators(invalid)
+
+
 class LookupRelatedFunctionTest(TestCase):
     def test_is_single_choice_field(self):
         """

nautobot/core/utils/git.py

@@ -3,6 +3,7 @@
 from collections import namedtuple
 import logging
 import os
+import string
 
 from git import Repo
 
@@ -34,8 +35,8 @@ GIT_ENVIRONMENT = {
 
 def swap_status_initials(data):
     """Swap Git status initials with its equivalent."""
-    initial, text = data.split("\t")
-    return GitDiffLog(status=GIT_STATUS_MAP.get(initial), text=text)
+    initial, text = data.split("\t", 1)
+    return GitDiffLog(status=GIT_STATUS_MAP.get(initial[0]), text=text)
 
 
 def convert_git_diff_log_to_list(logs):
@@ -93,69 +94,140 @@ class GitRepo:
         """
         Check out the given branch, and optionally the specified commit within that branch.
 
+        Args:
+            branch (str): A branch name, a tag name, or a (possibly abbreviated) commit identifier.
+            commit_hexsha (str): A specific (possibly abbreviated) commit identifier.
+
+        If `commit_hexsha` is specified and `branch` is either a tag or a commit identifier, they must match.
+        If `commit_hexsha` is specified and `branch` is a branch name, it must contain the specified commit.
+
         Returns:
-            (str, bool): commit_hexsha the repo contains now, whether any change occurred
+            (str, bool): commit_hexsha the repo contains now, and whether any change occurred
         """
         # Short-circuit logic - do we already have this commit checked out?
-        if commit_hexsha and commit_hexsha == self.head:
+        if commit_hexsha and self.head.startswith(commit_hexsha):
             logger.debug(f"Commit {commit_hexsha} is already checked out.")
-            return (commit_hexsha, False)
+            return (self.head, False)
+        # User might specify the commit as a "branch" name...
+        if not commit_hexsha and set(branch).issubset(string.hexdigits) and self.head.startswith(branch):
+            logger.debug("Commit %s is already checked out.", branch)
+            return (self.head, False)
 
         self.fetch()
-        if commit_hexsha:
-            # Sanity check - GitPython doesn't provide a handy API for this so we just call a raw Git command:
-            # $ git branch origin/<branch> --remotes --contains <commit>
-            # prints the branch name if it DOES contain the commit, and nothing if it DOES NOT contain the commit.
-            # Since we did a `fetch` and not a `pull` above, we need to check for the commit in the remote origin
-            # branch, not the local (not-yet-updated) branch.
-            if branch not in self.repo.git.branch(f"origin/{branch}", "--remotes", "--contains", commit_hexsha):
-                raise RuntimeError(f"Requested to check out commit `{commit_hexsha}`, but it's not in branch {branch}!")
-            logger.info(f"Checking out commit `{commit_hexsha}` on branch `{branch}`...")
-            self.repo.git.checkout(commit_hexsha)
-            return (commit_hexsha, True)
-
-        if branch in self.repo.heads:
-            branch_head = self.repo.heads[branch]
-        else:
-            try:
-                branch_head = self.repo.create_head(branch, self.repo.remotes.origin.refs[branch])
-                branch_head.set_tracking_branch(self.repo.remotes.origin.refs[branch])
-            except IndexError as git_error:
-                logger.error(
-                    "Branch %s does not exist at %s. %s", branch, next(iter(self.repo.remotes.origin.urls)), git_error
-                )
-                raise BranchDoesNotExist(
-                    f"Please create branch '{branch}' in upstream and try again."
-                    f" If this is a new repo, please add a commit before syncing. {git_error}"
+        # Is `branch` actually a branch, a tag, or a commit? Heuristics:
+        is_branch = branch in self.repo.remotes.origin.refs
+        is_tag = branch in self.repo.tags
+        maybe_commit = set(branch).issubset(string.hexdigits)
+        logger.debug(
+            "Branch %s --> is_branch: %s, is_tag: %s, maybe_commit: %s",
+            branch,
+            is_branch,
+            is_tag,
+            maybe_commit,
+        )
+
+        if is_branch:
+            if commit_hexsha:
+                # Sanity check - GitPython doesn't provide a handy API for this so we just call a raw Git command:
+                # $ git branch origin/<branch> --remotes --contains <commit>
+                # prints the branch name if it DOES contain the commit, and nothing if it DOES NOT contain the commit.
+                # Since we did a `fetch` and not a `pull` above, we need to check for the commit in the remote origin
+                # branch, not the local (not-yet-updated) branch.
+                if branch not in self.repo.git.branch(f"origin/{branch}", "--remotes", "--contains", commit_hexsha):
+                    raise RuntimeError(
+                        f"Requested to check out commit {commit_hexsha}, but it's not part of branch {branch}!"
+                    )
+                logger.info("Checking out commit %s on branch %s...", commit_hexsha, branch)
+                self.repo.git.checkout(commit_hexsha)
+                return (self.head, True)
+
+            if branch in self.repo.heads:
+                branch_head = self.repo.heads[branch]
+            else:
+                try:
+                    branch_head = self.repo.create_head(branch, self.repo.remotes.origin.refs[branch])
+                    branch_head.set_tracking_branch(self.repo.remotes.origin.refs[branch])
+                except IndexError as git_error:
+                    logger.error(
+                        "Branch %s does not exist at %s. %s",
+                        branch,
+                        next(iter(self.repo.remotes.origin.urls)),
+                        git_error,
+                    )
+                    raise BranchDoesNotExist(
+                        f"Please create branch '{branch}' in upstream and try again."
+                        f" If this is a new repo, please add a commit before syncing. {git_error}"
+                    )
+
+            logger.info("Checking out latest commit on branch %s...", branch)
+            branch_head.checkout()
+            # No specific commit hash was given, so make sure we get the latest from origin
+            # We would use repo.remotes.origin.pull() here, but that will fail in the case where someone has
+            # force-pushed to the upstream repo since the last time we did a pull. To be safe, we reset instead.
+            self.repo.head.reset(f"origin/{branch}", index=True, working_tree=True)
+            logger.info("Latest commit on branch `%s` is `%s`", branch, self.head)
+            return (self.head, True)
+
+        if is_tag:
+            tag = self.repo.tags[branch]
+            if commit_hexsha:
+                # Sanity check
+                if not tag.commit.hexsha.startswith(commit_hexsha):
+                    raise RuntimeError(
+                        f"Requested to check out tag {branch} and commit {commit_hexsha} together, "
+                        f"but tag {branch} is actually commit {tag.commit.hexsha}!"
+                    )
+            logger.info("Checking out tag %s...", branch)
+            self.repo.git.checkout(branch)
+            return (self.head, True)
+
+        if maybe_commit:
+            # Sanity check
+            if commit_hexsha and not (commit_hexsha.startswith(branch) or branch.startswith(commit_hexsha)):
+                raise RuntimeError(
+                    f"Requested to check out both {branch} and {commit_hexsha} together, "
+                    f"but {branch} is neither a branch, a tag, nor the same commit hash!"
                 )
 
-        logger.info(f"Checking out latest commit on branch `{branch}`...")
-        branch_head.checkout()
-        # No specific commit hash was given, so make sure we get the latest from origin
-        # We would use repo.remotes.origin.pull() here, but that will fail in the case where someone has
-        # force-pushed to the upstream repo since the last time we did a pull. To be safe, we reset instead.
-        self.repo.head.reset(f"origin/{branch}", index=True, working_tree=True)
-        commit_hexsha = self.repo.head.reference.commit.hexsha
-        logger.info(f"Latest commit on branch `{branch}` is `{commit_hexsha}`")
-        return (commit_hexsha, True)
+            logger.info("Checking out commit %s...", branch)
+            self.repo.git.checkout(branch)
+            return (self.head, True)
+
+        # Fallthru
+        raise BranchDoesNotExist(
+            f"{branch} does not appear to be an existing branch, tag, or possible commit hash. "
+            "Please check your upstream repository and the data you are using."
+        )
 
     def diff_remote(self, branch):
         logger.debug("Fetching from remote.")
         self.fetch()
-
-        try:
-            self.repo.remotes.origin.refs[branch]
-        except IndexError as git_error:
-            logger.error(
-                "Branch %s does not exist at %s. %s", branch, next(iter(self.repo.remotes.origin.urls)), git_error
-            )
+        # Is `branch` actually a branch, a tag, or a commit? Heuristics:
+        is_branch = branch in self.repo.remotes.origin.refs
+        is_tag = branch in self.repo.tags
+        maybe_commit = set(branch).issubset(string.hexdigits)
+        logger.debug(
+            "Branch %s --> is_branch: %s, is_tag: %s, maybe_commit: %s",
+            branch,
+            is_branch,
+            is_tag,
+            maybe_commit,
+        )
+
+        if not is_branch and not is_tag and not maybe_commit:
+            logger.error("Branch %s does not exist at %s", branch, next(iter(self.repo.remotes.origin.urls)))
             raise BranchDoesNotExist(
                 f"Please create branch '{branch}' in upstream and try again."
-                f" If this is a new repo, please add a commit before syncing. {git_error}"
+                f" If this is a new repo, please add a commit before syncing."
             )
 
-        logger.debug("Getting diff between local branch and remote branch")
-        diff = self.repo.git.diff("--name-status", f"origin/{branch}")
+        if is_branch:
+            logger.debug("Getting diff between local branch and remote branch")
+            diff = self.repo.git.diff("--name-status", f"origin/{branch}")
+        else:
+            logger.debug("Getting diff between local state and specified tag or commit")
+            diff = self.repo.git.diff("--name-status", branch)
+
         if diff:  # if diff is not empty
             return convert_git_diff_log_to_list(diff)
         logger.debug("No Difference")

nautobot/core/utils/module_loading.py

@@ -24,6 +24,15 @@ def _temporarily_add_to_sys_path(path):
         sys.path = old_sys_path
 
 
+def clear_module_from_sys_modules(module_name):
+    """
+    Remove the module and all its submodules from sys.modules.
+    """
+    for name in list(sys.modules.keys()):
+        if name == module_name or name.startswith(f"{module_name}."):
+            del sys.modules[name]
+
+
 def import_modules_privately(path, module_path=None, ignore_import_errors=True):
     """
     Import modules from the filesystem without adding the path permanently to `sys.path`.
@@ -69,7 +78,7 @@ def import_modules_privately(path, module_path=None, ignore_import_errors=True):
                     continue
 
             if discovered_module_name in sys.modules:
-                del sys.modules[discovered_module_name]
+                clear_module_from_sys_modules(discovered_module_name)
 
             try:
                 if not is_package:
@@ -81,7 +90,6 @@ def import_modules_privately(path, module_path=None, ignore_import_errors=True):
                     spec.loader.exec_module(module)
                 else:
                     module = importlib.import_module(discovered_module_name)
-
                 importlib.reload(module)
             except Exception as exc:
                 logger.error("Unable to load module %s from %s: %s", discovered_module_name, path, exc)

nautobot/core/views/utils.py

@@ -215,11 +215,28 @@ def handle_protectederror(obj_list, request, e):
         protected_count,
     )
 
+    # Format objects based on whether they have a detail view/absolute url
+    objects_with_absolute_url = []
+    objects_without_absolute_url = []
     # Append dependent objects to error message
+    for dependent in protected_objects[:50]:
+        try:
+            dependent.get_absolute_url()
+            objects_with_absolute_url.append(dependent)
+        except AttributeError:
+            objects_without_absolute_url.append(dependent)
+
     err_message += format_html_join(
         ", ",
         '<a href="{}">{}</a>',
-        ((dependent.get_absolute_url(), dependent) for dependent in protected_objects[:50]),
+        ((dependent.get_absolute_url(), dependent) for dependent in objects_with_absolute_url),
+    )
+    if objects_with_absolute_url and objects_without_absolute_url:
+        err_message += format_html(", ")
+    err_message += format_html_join(
+        ", ",
+        "<span>{}</span>",
+        ((dependent,) for dependent in objects_without_absolute_url),
     )
 
     messages.error(request, err_message)

nautobot/dcim/factory.py

@@ -708,6 +708,6 @@ class ControllerManagedDeviceGroupFactory(PrimaryModelFactory):
     name = UniqueFaker("word")
     parent = factory.Maybe("has_parent", random_instance(ControllerManagedDeviceGroup), None)
     controller = factory.LazyAttribute(
-        lambda o: o.parent.controller if o.parent else Controller.objects.order_by("?").first()
+        lambda o: o.parent.controller if o.parent else factory.random.randgen.choice(Controller.objects.all())
     )
     weight = factory.Faker("pyint", min_value=1, max_value=1000)

nautobot/dcim/filters/__init__.py

@@ -102,13 +102,13 @@ __all__ = (
     "ControllerManagedDeviceGroupFilterSet",
     "DeviceBayFilterSet",
     "DeviceBayTemplateFilterSet",
+    "DeviceFamilyFilterSet",
     "DeviceFilterSet",
     "DeviceRedundancyGroupFilterSet",
     "DeviceTypeFilterSet",
     "DeviceTypeToSoftwareImageFileFilterSet",
     "FrontPortFilterSet",
     "FrontPortTemplateFilterSet",
-    "DeviceFamilyFilterSet",
     "InterfaceConnectionFilterSet",
     "InterfaceFilterSet",
     "InterfaceRedundancyGroupFilterSet",

nautobot/dcim/forms.py

@@ -728,6 +728,15 @@ class ManufacturerForm(NautobotModelForm):
         ]
 
 
+class ManufacturerFilterForm(NautobotFilterForm):
+    model = Manufacturer
+    q = forms.CharField(required=False, label="Search")
+    device_types = DynamicModelMultipleChoiceField(
+        queryset=DeviceType.objects.all(), to_field_name="model", required=False
+    )
+    platforms = DynamicModelMultipleChoiceField(queryset=Platform.objects.all(), to_field_name="name", required=False)
+
+
 #
 # Device Family
 #
@@ -745,6 +754,9 @@ class DeviceFamilyForm(NautobotModelForm):
 class DeviceFamilyFilterForm(NautobotFilterForm):
     model = DeviceFamily
     q = forms.CharField(required=False, label="Search")
+    device_types = DynamicModelMultipleChoiceField(
+        queryset=DeviceType.objects.all(), to_field_name="model", required=False
+    )
     tags = TagFilterField(model)
 
 
@@ -1582,6 +1594,13 @@ class PlatformForm(NautobotModelForm):
         }
 
 
+class PlatformFilterForm(NautobotFilterForm):
+    model = Platform
+    q = forms.CharField(required=False, label="Search")
+    name = forms.CharField(required=False)
+    network_driver = forms.CharField(required=False)
+
+
 #
 # Devices
 #
@@ -2567,14 +2586,14 @@ class InterfaceBulkEditForm(
         queryset=VLAN.objects.all(),
         required=False,
         query_params={
-            "location": "null",
+            "locations": "null",
         },
     )
     tagged_vlans = DynamicModelMultipleChoiceField(
         queryset=VLAN.objects.all(),
         required=False,
         query_params={
-            "location": "null",
+            "locations": "null",
         },
     )
     vrf = DynamicModelChoiceField(
@@ -2618,8 +2637,8 @@ class InterfaceBulkEditForm(
             # Limit VLAN choices by Location
             if locations.count() == 1:
                 location = locations.first()
-                self.fields["untagged_vlan"].widget.add_query_param("location", location.pk)
-                self.fields["tagged_vlans"].widget.add_query_param("location", location.pk)
+                self.fields["untagged_vlan"].widget.add_query_param("locations", location.pk)
+                self.fields["tagged_vlans"].widget.add_query_param("locations", location.pk)
 
         # Restrict parent/bridge/LAG interface assignment by device (or VC master)
         if device_count == 1:

nautobot/dcim/tables/devicetypes.py

@@ -45,9 +45,15 @@ __all__ = (
 class ManufacturerTable(BaseTable):
     pk = ToggleColumn()
     name = tables.LinkColumn()
-    device_type_count = tables.Column(verbose_name="Device Types")
-    inventory_item_count = tables.Column(verbose_name="Inventory Items")
-    platform_count = tables.Column(verbose_name="Platforms")
+    device_type_count = LinkedCountColumn(
+        viewname="dcim:devicetype_list", url_params={"manufacturer": "name"}, verbose_name="Device Types"
+    )
+    inventory_item_count = LinkedCountColumn(
+        viewname="dcim:inventoryitem_list", url_params={"manufacturer": "name"}, verbose_name="Inventory Items"
+    )
+    platform_count = LinkedCountColumn(
+        viewname="dcim:platform_list", url_params={"manufacturer": "name"}, verbose_name="Platforms"
+    )
     actions = ButtonsColumn(Manufacturer)
 
     class Meta(BaseTable.Meta):
@@ -71,7 +77,9 @@ class ManufacturerTable(BaseTable):
 class DeviceFamilyTable(BaseTable):
     pk = ToggleColumn()
     name = tables.Column(linkify=True)
-    device_type_count = tables.Column(verbose_name="Device Types")
+    device_type_count = LinkedCountColumn(
+        viewname="dcim:devicetype_list", url_params={"device_family": "name"}, verbose_name="Device Types"
+    )
     actions = ButtonsColumn(DeviceFamily)
     tags = TagColumn(url_name="dcim:devicefamily_list")
 
@@ -95,6 +103,8 @@ class DeviceFamilyTable(BaseTable):
 class DeviceTypeTable(BaseTable):
     pk = ToggleColumn()
     model = tables.Column(linkify=True, verbose_name="Device Type")
+    manufacturer = tables.Column(linkify=True)
+    device_family = tables.Column(linkify=True)
     is_full_depth = BooleanColumn(verbose_name="Full Depth")
     device_count = LinkedCountColumn(
         viewname="dcim:device_list",
@@ -109,6 +119,7 @@ class DeviceTypeTable(BaseTable):
             "pk",
             "model",
             "manufacturer",
+            "device_family",
             "part_number",
             "u_height",
             "is_full_depth",

nautobot/dcim/tests/test_models.py

@@ -1854,12 +1854,14 @@ class SoftwareVersionTestCase(ModelTestCases.BaseModelTestCase):
 
         # Only return the device types with a direct m2m relationship to the version's software image files
         device_type = DeviceType.objects.filter(software_image_files__isnull=False).first()
+        self.assertIsNotNone(device_type)
         self.assertQuerysetEqualAndNotEmpty(
             qs.get_for_object(device_type), qs.filter(software_image_files__device_types=device_type)
         )
 
         # Only return the software version set on the device's software_version foreign key
         device = Device.objects.filter(software_version__isnull=False).first()
+        self.assertIsNotNone(device)
         self.assertQuerysetEqualAndNotEmpty(qs.get_for_object(device), [device.software_version])
 
         # Only return the software version set on the inventory item's software_version foreign key

nautobot/dcim/tests/test_views.py

@@ -3398,6 +3398,48 @@ class SoftwareImageFileTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "download_url": "https://example.com/software_image_file_test_case.bin",
         }
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_correct_handling_for_model_protected_error(self):
+        platform = Platform.objects.first()
+        software_version_status = Status.objects.get_for_model(SoftwareVersion).first()
+        software_image_file_status = Status.objects.get_for_model(SoftwareImageFile).first()
+        software_version = SoftwareVersion.objects.create(
+            platform=platform, version="Test version 1.0.0", status=software_version_status
+        )
+        software_image_file = SoftwareImageFile.objects.create(
+            software_version=software_version,
+            image_file_name="software_image_file_qs_test_1.bin",
+            status=software_image_file_status,
+        )
+        device_type = DeviceType.objects.first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        location = Location.objects.filter(location_type__name="Campus").first()
+        Device.objects.create(
+            device_type=device_type,
+            role=device_role,
+            name="Device 1",
+            location=location,
+            status=device_status,
+            software_version=software_version,
+        )
+        device_type_to_software_image_file = DeviceTypeToSoftwareImageFile.objects.create(
+            device_type=device_type, software_image_file=software_image_file
+        )
+
+        self.add_permissions("dcim.delete_softwareimagefile")
+        pk_list = [software_image_file.pk]
+        data = {
+            "pk": pk_list,
+            "confirm": True,
+            "_confirm": True,  # Form button
+        }
+        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
+        self.assertHttpStatus(response, 200)
+        response_body = response.content.decode(response.charset)
+        # Assert protected error message included in the response body
+        self.assertInHTML(f"<span>{device_type_to_software_image_file}</span>", response_body)
+
 
 class SoftwareVersionTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = SoftwareVersion
@@ -3436,6 +3478,48 @@ class SoftwareVersionTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "pre_release": True,
         }
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_correct_handling_for_model_protected_error(self):
+        platform = Platform.objects.first()
+        software_version_status = Status.objects.get_for_model(SoftwareVersion).first()
+        software_image_file_status = Status.objects.get_for_model(SoftwareImageFile).first()
+        software_version = SoftwareVersion.objects.create(
+            platform=platform, version="Test version 1.0.0", status=software_version_status
+        )
+        software_image_file = SoftwareImageFile.objects.create(
+            software_version=software_version,
+            image_file_name="software_image_file_qs_test_1.bin",
+            status=software_image_file_status,
+        )
+        device_type = DeviceType.objects.first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        location = Location.objects.filter(location_type__name="Campus").first()
+        Device.objects.create(
+            device_type=device_type,
+            role=device_role,
+            name="Device 1",
+            location=location,
+            status=device_status,
+            software_version=software_version,
+        )
+        device_type_to_software_image_file = DeviceTypeToSoftwareImageFile.objects.create(
+            device_type=device_type, software_image_file=software_image_file
+        )
+
+        self.add_permissions("dcim.delete_softwareversion")
+        pk_list = [software_version.pk]
+        data = {
+            "pk": pk_list,
+            "confirm": True,
+            "_confirm": True,  # Form button
+        }
+        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
+        self.assertHttpStatus(response, 200)
+        response_body = response.content.decode(response.charset)
+        # Assert protected error message included in the response body
+        self.assertInHTML(f"<span>{device_type_to_software_image_file}</span>", response_body)
+
 
 class ControllerTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = Controller

nautobot/dcim/views.py

@@ -710,6 +710,7 @@ class ManufacturerListView(generic.ObjectListView):
         platform_count=count_related(Platform, "manufacturer"),
     )
     filterset = filters.ManufacturerFilterSet
+    filterset_form = forms.ManufacturerFilterForm
     table = tables.ManufacturerTable
 
 
@@ -1212,6 +1213,7 @@ class PlatformListView(generic.ObjectListView):
         virtual_machine_count=count_related(VirtualMachine, "platform"),
     )
     filterset = filters.PlatformFilterSet
+    filterset_form = forms.PlatformFilterForm
     table = tables.PlatformTable
 
 
@@ -3103,6 +3105,7 @@ class InterfaceRedundancyGroupAssociationUIViewSet(ObjectEditViewMixin, ObjectDe
 
 class DeviceFamilyUIViewSet(NautobotUIViewSet):
     filterset_class = filters.DeviceFamilyFilterSet
+    filterset_form_class = forms.DeviceFamilyFilterForm
     form_class = forms.DeviceFamilyForm
     bulk_update_form_class = forms.DeviceFamilyBulkEditForm
     queryset = DeviceFamily.objects.annotate(device_type_count=count_related(DeviceType, "device_family"))