nautobot 2.3.13__py3-none-any.whl → 2.3.15__py3-none-any.whl

nautobot/circuits/tables.py

@@ -110,6 +110,7 @@ class CircuitTable(StatusTableMixin, BaseTable):
     pk = ToggleColumn()
     cid = tables.LinkColumn(verbose_name="ID")
     provider = tables.Column(linkify=True)
+    circuit_type = tables.Column(linkify=True)
     tenant = TenantColumn()
     tags = TagColumn(url_name="circuits:circuit_list")
 
@@ -146,7 +147,7 @@ class CircuitTable(StatusTableMixin, BaseTable):
             "pk",
             "cid",
             "provider",
-            "type",
+            "circuit_type",
             "status",
             "tenant",
             "circuit_termination_a",

nautobot/core/filters.py

@@ -618,6 +618,7 @@ class BaseFilterSet(django_filters.FilterSet):
     @staticmethod
     def _get_filter_lookup_dict(existing_filter):
         # Choose the lookup expression map based on the filter type
+
         if isinstance(
             existing_filter,
             (
@@ -637,6 +638,7 @@ class BaseFilterSet(django_filters.FilterSet):
             (
                 django_filters.ModelChoiceFilter,
                 django_filters.ModelMultipleChoiceFilter,
+                MultiValueUUIDFilter,
                 TagFilter,
                 TreeNodeMultipleChoiceFilter,
             ),

nautobot/core/jobs/cleanup.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
 
 from django.core.exceptions import PermissionDenied
+from django.db.models import CASCADE
 from django.db.models.signals import pre_delete
 from django.utils import timezone
 
@@ -48,6 +49,27 @@ class LogsCleanup(Job):
         description = "Delete ObjectChange and/or JobResult/JobLogEntry records older than a specified cutoff."
         has_sensitive_variables = False
 
+    def recursive_delete_with_cascade(self, queryset, deletion_summary):
+        """
+        Recursively deletes all related objects with CASCADE for a given queryset.
+
+        Args:
+            queryset (QuerySet): The queryset of objects to delete.
+            deletion_summary (dict): A dictionary to store the count of deleted objects for each model.
+        """
+        related_objects = queryset.model._meta.related_objects
+        queryset = queryset.only("id")
+
+        for related_object in related_objects:
+            if related_object.on_delete is CASCADE:
+                related_model = related_object.related_model
+                related_field_name = related_object.field.name
+                cascade_queryset = related_model.objects.filter(**{f"{related_field_name}__id__in": queryset})
+                self.recursive_delete_with_cascade(cascade_queryset, deletion_summary)
+        _, deleted_dict = queryset.delete()
+        deletion_summary.update(deleted_dict)
+        return deletion_summary
+
     def run(self, *, cleanup_types, max_age=None):
         if max_age in (None, ""):
             max_age = get_settings_or_config("CHANGELOG_RETENTION")
@@ -77,22 +99,36 @@ class LogsCleanup(Job):
 
             if CleanupTypes.JOB_RESULT in cleanup_types:
                 self.logger.info("Deleting JobResult records prior to %s", cutoff)
-                _, deleted_dict = JobResult.objects.restrict(self.user, "delete").filter(date_done__lt=cutoff).delete()
+                queryset = JobResult.objects.restrict(self.user, "delete").filter(date_done__lt=cutoff)
+                deletion_summary = {}
+                self.recursive_delete_with_cascade(queryset, deletion_summary)
                 result.setdefault("extras.JobResult", 0)
                 result.setdefault("extras.JobLogEntry", 0)
-                result.update(**deleted_dict)
-                self.logger.info(
-                    "Deleted %d JobResult records and their associated %d JobLogEntry records",
-                    result["extras.JobResult"],
-                    result["extras.JobLogEntry"],
-                )
+                result.update(deletion_summary)
+
+                for modelname, count in deletion_summary.items():
+                    self.logger.info(
+                        "As part of deleting %d JobResult records, also deleted %d related %s records",
+                        result["extras.JobResult"],
+                        count,
+                        modelname,
+                    )
 
             if CleanupTypes.OBJECT_CHANGE in cleanup_types:
                 self.logger.info("Deleting ObjectChange records prior to %s", cutoff)
-                deleted_count, _ = ObjectChange.objects.restrict(self.user, "delete").filter(time__lt=cutoff).delete()
-                self.logger.info("Deleted %d ObjectChange records", deleted_count)
-                result["extras.ObjectChange"] = deleted_count
-
+                queryset = ObjectChange.objects.restrict(self.user, "delete").filter(time__lt=cutoff)
+                deletion_summary = {}
+                self.recursive_delete_with_cascade(queryset, deletion_summary)
+                result.setdefault("extras.ObjectChange", 0)
+                result.update(deletion_summary)
+
+                for modelname, count in deletion_summary.items():
+                    self.logger.info(
+                        "As part of deleting %d ObjectChange records, also deleted %d related %s records",
+                        result["extras.ObjectChange"],
+                        count,
+                        modelname,
+                    )
             return result
         finally:
             # Be sure to clean up after ourselves!

nautobot/core/settings.py

@@ -173,6 +173,9 @@ PLUGINS_CONFIG = {}
 if "NAUTOBOT_PREFER_IPV4" in os.environ and os.environ["NAUTOBOT_PREFER_IPV4"] != "":
     PREFER_IPV4 = is_truthy(os.environ["NAUTOBOT_PREFER_IPV4"])
 
+# Publish a simple "no-index" robots.txt for Nautobot?
+PUBLISH_ROBOTS_TXT = is_truthy(os.getenv("NAUTOBOT_PUBLISH_ROBOTS_TXT", "True"))
+
 # Default height and width in pixels of a single rack unit in rendered rack elevations. Defaults are 22 and 220
 if (
     "NAUTOBOT_RACK_ELEVATION_DEFAULT_UNIT_HEIGHT" in os.environ

nautobot/core/settings.yaml

@@ -1473,6 +1473,14 @@ properties:
     environment_variable: "NAUTOBOT_PREFER_IPV4"
     is_constance_config: true
     type: "boolean"
+  PUBLISH_ROBOTS_TXT:
+    default: true
+    description: >-
+        Setting this to true causes Nautobot to publish a `robots.txt` that discourages indexing by web crawlers.
+        Irrelevant if deployed behind a firewall.
+    environment_variable: "NAUTOBOT_PUBLISH_ROBOTS_TXT"
+    type: "boolean"
+    version_added: "2.3.15"
   RACK_ELEVATION_DEFAULT_UNIT_HEIGHT:
     default: 22
     description: >-

nautobot/core/templates/inc/media.html

@@ -47,3 +47,6 @@
     <meta name="theme-color" content="#ffffff">
     <meta charset="UTF-8">
     <meta name="viewport" content="initial-scale=1, maximum-scale=1, user-scalable=no, width=device-width">
+    {% if settings.PUBLISH_ROBOTS_TXT %}
+    <meta name="robots" content="noindex, nofollow">
+    {% endif %}

nautobot/core/templates/nautobot_config.py.j2

@@ -490,6 +490,9 @@ INSTALLATION_METRICS_ENABLED = is_truthy(os.getenv("NAUTOBOT_INSTALLATION_METRIC
 # if "NAUTOBOT_PREFER_IPV4" in os.environ and os.environ["NAUTOBOT_PREFER_IPV4"] != "":
 #     PREFER_IPV4 = is_truthy(os.environ["NAUTOBOT_PREFER_IPV4"])
 
+# Publish a simple "no-index" robots.txt for Nautobot?
+# PUBLISH_ROBOTS_TXT = is_truthy(os.getenv("NAUTOBOT_PUBLISH_ROBOTS_TXT", "True"))
+
 # Default height and width in pixels of a single rack unit in rendered rack elevations. Defaults are 22 and 230
 #
 # if (

nautobot/core/templates/search.html

@@ -65,3 +65,10 @@
         </div>
     {% endif %}
 {% endblock %}
+
+{% block javascript %}
+    {{ block.super }}
+    <script>
+        var clipboard = new ClipboardJS('.btn');
+    </script>
+{% endblock %}

nautobot/core/testing/filters.py

@@ -88,11 +88,26 @@ class FilterTestCases:
             return self.filterset.declared_filters["q"].filter_predicates
 
         def test_id(self):
-            """Verify that the filterset supports filtering by id."""
-            params = {"id": self.queryset.values_list("pk", flat=True)[:2]}
-            filterset = self.filterset(params, self.queryset)
-            self.assertTrue(filterset.is_valid())
-            self.assertEqual(filterset.qs.count(), 2)
+            """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."""

nautobot/core/testing/mixins.py

@@ -144,13 +144,18 @@ class NautobotTestCaseMixin:
     # Permissions management
     #
 
-    def add_permissions(self, *names):
+    def add_permissions(self, *names, **kwargs):
         """
         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])
+            obj_perm = users_models.ObjectPermission(name=name, actions=[action], **kwargs)
             obj_perm.save()
             obj_perm.users.add(self.user)
             obj_perm.object_types.add(ct)

nautobot/core/tests/integration/test_app_home.py

@@ -9,7 +9,6 @@ from example_app.models import ExampleModel
 class AppHomeTestCase(SeleniumTestCase):
     """Integration test the Example App homepage extensions."""
 
-    fixtures = ["user-data.json"]  # bob/bob
     layout = {
         "Organization": {
             "Locations": {"model": Location, "permission": "dcim.view_location"},

nautobot/core/tests/integration/test_app_navbar.py

@@ -5,7 +5,6 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class AppNavBarTestCase(SeleniumTestCase):
     """Integration test the navigation menu."""
 
-    fixtures = ["user-data.json"]
     navbar = {
         "Circuits": {
             "Circuits": {

nautobot/core/tests/integration/test_filters.py

@@ -11,8 +11,6 @@ from nautobot.extras.models import CustomField, CustomFieldChoice, Status
 class ListViewFilterTestCase(SeleniumTestCase):
     """Integration test for the list view filter ui."""
 
-    fixtures = ["user-data.json"]
-
     def setUp(self):
         super().setUp()
         self.login(self.user.username, self.password)

nautobot/core/tests/integration/test_home.py

@@ -7,7 +7,6 @@ from nautobot.tenancy.models import Tenant
 class HomeTestCase(SeleniumTestCase):
     """Integration tests against the home page."""
 
-    fixtures = ["user-data.json"]  # bob/bob
     layout = {
         "Organization": {
             "Locations": {"model": Location, "permission": "dcim.view_location"},

nautobot/core/tests/integration/test_navbar.py

@@ -4,7 +4,6 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class NavBarTestCase(SeleniumTestCase):
     """Integration test the navigation menu."""
 
-    fixtures = ["user-data.json"]
     navbar = {
         "Organization": {
             "Locations": {

nautobot/core/tests/integration/test_view_authentication.py

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

nautobot/core/tests/test_views.py

@@ -594,3 +594,32 @@ class ExampleViewWithCustomPermissionsTest(TestCase):
         self.user.save()
         response = self.client.get(url)
         self.assertBodyContains(response, "You are viewing a table of example models")
+
+
+class SearchRobotsTestCase(TestCase):
+    def test_robots_disallowed(self):
+        """
+        Test that the robots.txt file is accessible to all users and defaults to disallowing all bots.
+        """
+        url = reverse("robots_txt")
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        self.assertBodyContains(response, "User-Agent: *")
+        self.assertBodyContains(response, "Disallow: /")
+
+        url = reverse("home")
+        response = self.client.get(url)
+        self.assertContains(response, '<meta name="robots" content="noindex, nofollow">', html=True)
+
+    @override_settings(PUBLISH_ROBOTS_TXT=False)
+    def test_robots_allowed(self):
+        """
+        Test that the robots.txt file is not published if PUBLISH_ROBOTS_TXT is set to False.
+        """
+        url = reverse("robots_txt")
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 404)
+
+        url = reverse("home")
+        response = self.client.get(url)
+        self.assertNotContains(response, '<meta name="robots" content="noindex, nofollow">', html=True)

nautobot/core/urls.py

@@ -1,4 +1,5 @@
 from django.conf import settings
+from django.http import HttpResponse, HttpResponseNotFound
 from django.urls import include, path
 from django.views.generic import TemplateView
 from django.views.static import serve
@@ -72,6 +73,14 @@ urlpatterns = [
     path(
         "template.css", TemplateView.as_view(template_name="template.css", content_type="text/css"), name="template_css"
     ),
+    # The response is conditional as opposed to wrapping the path() call in an if statement to be able to test the setting with current test setup
+    path(
+        "robots.txt",
+        lambda x: HttpResponse("User-Agent: *\nDisallow: /", content_type="text/plain")
+        if settings.PUBLISH_ROBOTS_TXT
+        else HttpResponseNotFound(),
+        name="robots_txt",
+    ),
 ]
 
 

nautobot/dcim/forms.py

@@ -792,7 +792,7 @@ class DeviceFamilyFilterForm(NautobotFilterForm):
     tags = TagFilterField(model)
 
 
-class DeviceFamilyBulkEditForm(NautobotBulkEditForm, TagsBulkEditFormMixin):
+class DeviceFamilyBulkEditForm(TagsBulkEditFormMixin, NautobotBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=DeviceFamily.objects.all(), widget=forms.MultipleHiddenInput())
     description = forms.CharField(required=False)
 
@@ -3183,9 +3183,6 @@ class InterfaceBulkEditForm(
     untagged_vlan = DynamicModelChoiceField(
         queryset=VLAN.objects.all(),
         required=False,
-        query_params={
-            "locations": "null",
-        },
     )
     tagged_vlans = DynamicModelMultipleChoiceField(
         queryset=VLAN.objects.all(),
@@ -3235,8 +3232,12 @@ class InterfaceBulkEditForm(
             # Limit VLAN choices by Location
             if locations.count() == 1:
                 location = locations.first()
-                self.fields["untagged_vlan"].widget.add_query_param("locations", location.pk)
+                # In the case of a single location, use the available_on_device query param to limit untagged VLAN choices
+                # to those available on the devices in that location and in the ancestors of the location.
+                self.fields["untagged_vlan"].widget.add_query_param("available_on_device", device.pk)
                 self.fields["tagged_vlans"].widget.add_query_param("locations", location.pk)
+            else:
+                self.fields["tagged_vlans"].widget.add_query_param("locations", "null")
 
         # Restrict parent/bridge/LAG interface assignment by device (or VC master)
         if device_count == 1:

nautobot/dcim/models/devices.py

@@ -47,6 +47,7 @@ __all__ = (
     "Controller",
     "ControllerManagedDeviceGroup",
     "Device",
+    "DeviceFamily",
     "DeviceRedundancyGroup",
     "DeviceType",
     "Manufacturer",

nautobot/dcim/tests/test_forms.py

@@ -1,8 +1,16 @@
 from django.test import TestCase
 
 from nautobot.core.testing.forms import FormTestCases
+from nautobot.core.testing.mixins import NautobotTestCaseMixin
 from nautobot.dcim.choices import DeviceFaceChoices, InterfaceModeChoices, InterfaceTypeChoices, RackWidthChoices
-from nautobot.dcim.forms import DeviceFilterForm, DeviceForm, InterfaceCreateForm, InterfaceForm, RackForm
+from nautobot.dcim.forms import (
+    DeviceFilterForm,
+    DeviceForm,
+    InterfaceBulkEditForm,
+    InterfaceCreateForm,
+    InterfaceForm,
+    RackForm,
+)
 from nautobot.dcim.models import (
     Device,
     DeviceType,
@@ -320,7 +328,7 @@ class RackTestCase(TestCase):
         self.assertTrue(form.is_valid())
 
 
-class InterfaceTestCase(TestCase):
+class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.device = Device.objects.first()
@@ -380,3 +388,44 @@ class InterfaceTestCase(TestCase):
         self.vlan.locations.clear()
         form = InterfaceForm(data=self.data, instance=self.interface)
         self.assertTrue(form.is_valid())
+
+    def test_untagged_vlans_dropdown_options_align_in_interface_edit_form_and_bulk_edit_form(self):
+        """
+        Assert that untagged_vlans field dropdown are populated correctly in InterfaceForm and InterfaceBulkEditForm,
+        and that the queryset is the same for both forms.
+        """
+        status = Status.objects.get_for_model(Interface).first()
+        location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        devices = Device.objects.all()[:3]
+        for device in devices:
+            device.location = location
+            device.save()
+        interfaces = (
+            Interface.objects.create(
+                device=devices[0],
+                name="Test Interface 1",
+                type=InterfaceTypeChoices.TYPE_2GFC_SFP,
+                status=status,
+            ),
+            Interface.objects.create(
+                device=devices[1],
+                name="Test Interface 2",
+                type=InterfaceTypeChoices.TYPE_LAG,
+                status=status,
+            ),
+            Interface.objects.create(
+                device=devices[2],
+                name="Test Interface 3",
+                type=InterfaceTypeChoices.TYPE_100ME_FIXED,
+                status=status,
+            ),
+        )
+        edit_form = InterfaceForm(data=self.data, instance=interfaces[0])
+        bulk_edit_form = InterfaceBulkEditForm(
+            model=Interface,
+            data={"pks": [interface.pk for interface in interfaces]},
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            edit_form.fields["untagged_vlan"].queryset,
+            bulk_edit_form.fields["untagged_vlan"].queryset,
+        )

nautobot/extras/forms/mixins.py

@@ -837,13 +837,21 @@ class StatusModelFilterFormMixin(forms.Form):
         self.order_fields(self.field_order)  # Reorder fields again
 
 
-class TagsBulkEditFormMixin(forms.Form):
+class TagsBulkEditFormMixin(BulkEditForm):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         # Add add/remove tags fields
-        self.fields["add_tags"] = DynamicModelMultipleChoiceField(queryset=Tag.objects.all(), required=False)
-        self.fields["remove_tags"] = DynamicModelMultipleChoiceField(queryset=Tag.objects.all(), required=False)
+        self.fields["add_tags"] = DynamicModelMultipleChoiceField(
+            queryset=Tag.objects.all(),
+            query_params={"content_types": self.model._meta.label_lower},
+            required=False,
+        )
+        self.fields["remove_tags"] = DynamicModelMultipleChoiceField(
+            queryset=Tag.objects.all(),
+            query_params={"content_types": self.model._meta.label_lower},
+            required=False,
+        )
 
 
 # 2.2 TODO: Names below are only for backward compatibility with Nautobot 1.3 and earlier. Remove in 2.2

nautobot/extras/jobs.py

@@ -98,13 +98,15 @@ class BaseJob:
 
         - name (str)
         - description (str)
-        - hidden (bool)
-        - field_order (list)
         - approval_required (bool)
-        - soft_time_limit (int)
-        - time_limit (int)
+        - dryrun_default (bool)
+        - field_order (list)
         - has_sensitive_variables (bool)
+        - hidden (bool)
+        - soft_time_limit (int)
         - task_queues (list)
+        - template_name (str)
+        - time_limit (int)
         """
 
     def __init__(self):

nautobot/extras/models/customfields.py

@@ -578,7 +578,13 @@ class CustomField(
             )
 
     def to_form_field(
-        self, set_initial=True, enforce_required=True, for_csv_import=False, simple_json_filter=False, label=None
+        self,
+        set_initial=True,
+        enforce_required=True,
+        for_csv_import=False,
+        simple_json_filter=False,
+        label=None,
+        for_filter_form=False,
     ):
         """
         Return a form field suitable for setting a CustomField's value for an object.
@@ -590,6 +596,7 @@ class CustomField(
                 this is *not* used for CSV imports since 2.0, but it *is* used for JSON/YAML import of DeviceTypes.
             simple_json_filter: Return a TextInput widget for JSON filtering instead of the default TextArea widget.
             label: Set the input label manually (if required); otherwise, defaults to field's __str__() implementation.
+            for_filter_form: If True return the relevant form field for filter form
         """
         initial = self.default if set_initial else None
         required = self.required if enforce_required else False
@@ -676,7 +683,7 @@ class CustomField(
             default_choice = self.custom_field_choices.filter(value=self.default).first()
 
             # Set the initial value to the first available choice (if any)
-            if self.type == CustomFieldTypeChoices.TYPE_SELECT:
+            if self.type == CustomFieldTypeChoices.TYPE_SELECT and not for_filter_form:
                 if not required or default_choice is None:
                     choices = add_blank_choice(choices)
                 field_class = CSVChoiceField if for_csv_import else forms.ChoiceField
@@ -704,16 +711,10 @@ class CustomField(
 
     def to_filter_form_field(self, lookup_expr="exact", *args, **kwargs):
         """Return a filter form field suitable for filtering a CustomField's value for an object."""
-        form_field = self.to_form_field(*args, **kwargs)
-        # We would handle type selection differently because:
-        # 1. We'd need to use StaticSelect2Multiple for lookup_type 'exact' because self.type `select` uses StaticSelect2 by default.
-        # 2. Remove the blank choice since StaticSelect2Multiple is always blank and interprets the blank choice as an extra option.
-        # 3. If lookup_type is not the same as exact, use MultiValueCharInput
+        form_field = self.to_form_field(*args, **kwargs, for_filter_form=True)
+        # We would handle type selection differently because: If lookup_type is not the same as exact, use MultiValueCharInput
         if self.type == CustomFieldTypeChoices.TYPE_SELECT:
-            if lookup_expr in ["exact", "contains"]:
-                choices = form_field.choices[1:]
-                form_field.widget = StaticSelect2Multiple(choices=choices)
-            else:
+            if lookup_expr not in ["exact", "contains"]:
                 form_field.widget = MultiValueCharInput()
         return form_field
 

nautobot/extras/tests/integration/test_plugin_banner.py

@@ -4,8 +4,6 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class PluginBannerTestCase(SeleniumTestCase):
     """Integration test for rendering of plugin-injected banner content."""
 
-    fixtures = ("user-data",)
-
     def test_banner_not_rendered(self):
         """As implemented, plugin banner does not render if the user is not logged in.
 

nautobot/extras/tests/test_forms.py

@@ -4,12 +4,13 @@ import warnings
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Q
+from django.forms import ChoiceField, MultipleChoiceField
 from django.test import override_settings, TestCase
 
 from nautobot.dcim.forms import DeviceForm, LocationBulkEditForm, LocationForm
 import nautobot.dcim.models as dcim_models
 from nautobot.dcim.models import Device, Location, LocationType
-from nautobot.extras.choices import RelationshipTypeChoices
+from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
 from nautobot.extras.forms import (
     ConfigContextFilterForm,
     ConfigContextForm,
@@ -25,6 +26,7 @@ from nautobot.extras.forms import (
     WebhookForm,
 )
 from nautobot.extras.models import (
+    CustomField,
     Job,
     JobButton,
     JobHook,
@@ -1217,3 +1219,20 @@ class CustomFieldModelFormMixinTestCase(TestCase):
 
         custom_field_form = TestForm()
         self.assertIn("_custom_field_data", custom_field_form.fields)
+
+
+class CustomFieldTestCase(TestCase):
+    def test_to_form_field_type_select(self):
+        """Verify that `to_form_field` and `to_filter_form_field` return the correct field types for a select-type CustomField."""
+        custom_field = CustomField.objects.create(
+            type=CustomFieldTypeChoices.TYPE_SELECT,
+            label="Custom Field Select",
+        )
+        form = custom_field.to_filter_form_field()
+        self.assertIsInstance(form, MultipleChoiceField)
+
+        form = custom_field.to_form_field(for_filter_form=True)
+        self.assertIsInstance(form, MultipleChoiceField)
+
+        form = custom_field.to_form_field(for_filter_form=False)
+        self.assertIsInstance(form, ChoiceField)