nautobot 2.4.14__py3-none-any.whl → 2.4.16__py3-none-any.whl

nautobot/core/testing/filters.py

@@ -15,6 +15,7 @@ from nautobot.core.filters import (
     ContentTypeChoiceFilter,
     ContentTypeFilter,
     ContentTypeMultipleChoiceFilter,
+    NaturalKeyOrPKMultipleChoiceFilter,
     RelatedMembershipBooleanFilter,
     SearchFilter,
 )
@@ -207,15 +208,29 @@ class FilterTestCases:
                     qs_result = self.queryset.filter(**{f"{field_name}__in": test_data}).distinct()
                     self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result, ordered=False)
 
+        def test_automagic_filters(self):
+            """https://github.com/nautobot/nautobot/issues/6656"""
+            self.assertIsNotNone(self.filterset)
+            fs = self.filterset()  # pylint: disable=not-callable
+            if getattr(self.queryset.model, "is_contact_associable_model", False):
+                self.assertIsInstance(fs.filters["contacts"], NaturalKeyOrPKMultipleChoiceFilter)
+                self.assertIsInstance(fs.filters["contacts__n"], NaturalKeyOrPKMultipleChoiceFilter)
+                self.assertIsInstance(fs.filters["teams"], NaturalKeyOrPKMultipleChoiceFilter)
+                self.assertIsInstance(fs.filters["teams__n"], NaturalKeyOrPKMultipleChoiceFilter)
+
+            if getattr(self.queryset.model, "is_dynamic_group_associable_model", False):
+                self.assertIsInstance(fs.filters["dynamic_groups"], NaturalKeyOrPKMultipleChoiceFilter)
+                self.assertIsInstance(fs.filters["dynamic_groups__n"], NaturalKeyOrPKMultipleChoiceFilter)
+
         def test_boolean_filters_generic(self):
-            """Test all `RelatedMembershipBooleanFilter` filters found in `self.filterset.get_filters()`
+            """Test all `RelatedMembershipBooleanFilter` filters found in `self.filterset.filters`
             except for the ones with custom filter logic defined in its `method` attribute.
 
             This test asserts that `filter=True` matches `self.queryset.filter(field__isnull=False)` and
             that `filter=False` matches `self.queryset.filter(field__isnull=True)`.
             """
             self.assertIsNotNone(self.filterset)
-            for filter_name, filter_object in self.filterset.get_filters().items():
+            for filter_name, filter_object in self.filterset().filters.items():  # pylint: disable=not-callable
                 if not isinstance(filter_object, RelatedMembershipBooleanFilter):
                     continue
                 if filter_object.method is not None:
@@ -380,6 +395,8 @@ class FilterTestCases:
                     self._assert_q_filter_predicate_validity(obj, obj_field_name, filter_field_name, lookup_method)
 
         def test_content_type_related_fields_uses_content_type_filter(self):
+            self.assertIsNotNone(self.filterset)
+            fs = self.filterset()  # pylint: disable=not-callable
             for field in self.queryset.model._meta.fields:
                 related_model = getattr(field, "related_model", None)
                 if not related_model or related_model != ContentType:
@@ -387,7 +404,7 @@ class FilterTestCases:
                 with self.subTest(
                     f"Assert {self.filterset.__class__.__name__}.{field.name} implements ContentTypeFilter"
                 ):
-                    filter_field = self.filterset.get_filters().get(field.name)
+                    filter_field = fs.filters.get(field.name)
                     if not filter_field:
                         # This field is not part of the Filterset.
                         continue

nautobot/core/testing/forms.py

@@ -24,7 +24,7 @@ class FormTestCases:
                         self.skipTest(f"{self.form_class.__name__}.{field_name} has no query_params")
                     field_model = field_class.queryset.model
                     filterset_class = get_filterset_for_model(field_model)
-                    filterset_fields = set(filterset_class.get_filters().keys())
+                    filterset_fields = set(filterset_class().filters.keys())
                     invalid_query_params = query_params_fields - filterset_fields
                     self.assertFalse(
                         invalid_query_params,

nautobot/core/tests/integration/test_filters.py

@@ -148,7 +148,7 @@ class ListViewFilterTestCase(SeleniumTestCase):
 
     def test_input_field_gets_updated(self):
         """Assert that a filter input/select field on Dynamic Filter Form updates if same field is updated."""
-        self.browser.visit(f'{self.live_server_url}{reverse("dcim:location_list")}')
+        self.browser.visit(f"{self.live_server_url}{reverse('dcim:location_list')}")
 
         text_field_name = self.custom_fields[0].add_prefix_to_cf_key()
         integer_field_name = self.custom_fields[1].add_prefix_to_cf_key()
@@ -225,7 +225,7 @@ class ListViewFilterTestCase(SeleniumTestCase):
     def test_advanced_filter_application(self):
         """Assert that filters are applied successfully when using the advanced filter."""
         # Go to the location list view
-        self.browser.visit(f'{self.live_server_url}{reverse("dcim:location_list")}')
+        self.browser.visit(f"{self.live_server_url}{reverse('dcim:location_list')}")
         # create a new tag
         tag = Tag.objects.create(name="Tag1")
         tag.content_types.set([ContentType.objects.get_for_model(Location)])

nautobot/core/tests/test_breadcrumbs.py

@@ -0,0 +1,366 @@
+"""
+Unit tests for the updated breadcrumbs.py following Nautobot testing conventions.
+"""
+
+from operator import itemgetter
+from unittest.mock import patch
+
+from django.template import Context
+from django.utils.http import urlencode
+
+from nautobot.core.testing import TestCase
+from nautobot.core.ui.breadcrumbs import (
+    BaseBreadcrumbItem,
+    Breadcrumbs,
+    InstanceBreadcrumbItem,
+    ModelBreadcrumbItem,
+    ViewNameBreadcrumbItem,
+)
+from nautobot.dcim.models import Device, LocationType
+
+
+class BreadcrumbItemsTestCase(TestCase):
+    """Test cases for BreadcrumbItem class."""
+
+    @classmethod
+    def setUpTestData(cls):
+        """Create test data."""
+        cls.location_type = LocationType.objects.create(name="Test Location Type Breadcrumbs")
+
+    def test_view_name_item(self):
+        """Test breadcrumb view name item."""
+        item = ViewNameBreadcrumbItem(view_name="home", label="Home")
+        context = Context({})
+
+        url, label = item.as_pair(context)
+
+        self.assertEqual(url, "/")
+        self.assertEqual(label, "Home")
+
+    def test_view_name_item_with_kwargs_and_query_params(self):
+        """Test breadcrumb view name item and kwargs."""
+        item = ViewNameBreadcrumbItem(
+            view_name="dcim:locationtype",
+            reverse_kwargs={"pk": self.location_type.pk},
+            reverse_query_params={"name": "test"},
+            label="Filtered Locations Types",
+        )
+        context = Context({})
+
+        url, label = item.as_pair(context)
+
+        self.assertEqual(url, f"/dcim/location-types/{self.location_type.pk}/?name=test")
+        self.assertEqual(label, "Filtered Locations Types")
+
+    def test_view_name_item_with_kwargs_and_query_params_callable(self):
+        """Test breadcrumb view name item and kwargs."""
+        item = ViewNameBreadcrumbItem(
+            view_name="dcim:locationtype",
+            reverse_kwargs=lambda c: {"pk": c["object"].pk},
+            reverse_query_params=lambda c: {"name": c["object"].name},
+            label="Filtered Locations Types",
+        )
+        context = Context({"object": self.location_type})
+
+        url, label = item.as_pair(context)
+
+        self.assertEqual(
+            url, f"/dcim/location-types/{self.location_type.pk}/?{urlencode({'name': self.location_type.name})}"
+        )
+        self.assertEqual(label, "Filtered Locations Types")
+
+    def test_callable_label_and_view_name(self):
+        """Test label and view_name as callables."""
+        item = ViewNameBreadcrumbItem(
+            view_name=lambda _: "home",
+            label=lambda context: f"Hi, {context['user']}!",
+        )
+        context = Context({"user": "Frodo"})
+        url, label = item.as_pair(context)
+        self.assertEqual(url, "/")
+        self.assertEqual(label, "Hi, Frodo!")
+
+    def test_model_items(self):
+        """Test breadcrumb model items."""
+        test_cases = [
+            {
+                "name": "model_class",
+                "kwargs": {"model": Device},
+                "expected_url": "/dcim/devices/",
+                "expected_label": "Devices",
+            },
+            {
+                "name": "model_instance",
+                "kwargs": {"model": self.location_type},
+                "expected_url": "/dcim/location-types/",
+                "expected_label": "Location Types",
+            },
+            {
+                "name": "model_instance_callable",
+                "kwargs": {"model": itemgetter("object")},
+                "expected_url": "/dcim/location-types/",
+                "expected_label": "Location Types",
+            },
+            {
+                "name": "model_str",
+                "kwargs": {"model": "dcim.device"},
+                "expected_url": "/dcim/devices/",
+                "expected_label": "Devices",
+            },
+            {
+                "name": "model_class_custom_url_action",
+                "kwargs": {"model": Device, "action": "add", "label_type": "singular"},
+                "expected_url": "/dcim/devices/add/",
+                "expected_label": "Device",
+            },
+            {
+                "name": "model_class_with_kwargs",
+                "kwargs": {
+                    "model": Device,
+                    "action": "",
+                    "label_type": "singular",
+                    "reverse_kwargs": {"pk": "947a8a80-9e62-5605-ab18-7a47c588f0ad"},
+                },
+                "expected_url": "/dcim/devices/947a8a80-9e62-5605-ab18-7a47c588f0ad/",
+                "expected_label": "Device",
+            },
+            {
+                "name": "model_class_with_query_params",
+                "kwargs": {"model": Device, "reverse_query_params": {"filter": "abc"}},
+                "expected_url": "/dcim/devices/?filter=abc",
+                "expected_label": "Devices",
+            },
+            {
+                "name": "model_class_with_query_params_callable",
+                "kwargs": {
+                    "model": itemgetter("model_type"),
+                    "reverse_query_params": lambda c: {"name": c["device_name"]},
+                },
+                "expected_url": "/dcim/devices/?name=abc",
+                "expected_label": "Devices",
+            },
+        ]
+        for test_case in test_cases:
+            with self.subTest(action=test_case["name"]):
+                item = ModelBreadcrumbItem(**test_case["kwargs"])
+                context = Context({"object": self.location_type, "model_type": Device, "device_name": "abc"})
+
+                url, label = item.as_pair(context)
+
+                self.assertEqual(url, test_case["expected_url"])
+                self.assertEqual(label, test_case["expected_label"])
+
+    def test_model_item_from_context(self):
+        """Test breadcrumb item with model from context."""
+        item = ModelBreadcrumbItem(model_key="object")
+        context = Context({"object": self.location_type})
+
+        url, label = item.as_pair(context)
+
+        self.assertEqual(url, "/dcim/location-types/")
+        self.assertEqual(label, "Location Types")
+
+    def test_instance_item(self):
+        """Test breadcrumb item with instance from context."""
+        item = InstanceBreadcrumbItem(instance_key="object")
+        context = Context({"object": self.location_type})
+
+        url, label = item.as_pair(context)
+
+        self.assertEqual(url, f"/dcim/location-types/{self.location_type.pk}/")
+        self.assertEqual(label, str(self.location_type))
+
+    def test_label_override(self):
+        """Test that explicit label overrides automatic label generation."""
+        items = [
+            ViewNameBreadcrumbItem(view_name="dcim:locationtype", label="Custom Label"),
+            ModelBreadcrumbItem(model=LocationType, label="Custom Label"),
+            InstanceBreadcrumbItem(label="Custom Label"),
+        ]
+
+        context = Context({"object": self.location_type})
+
+        for item in items:
+            with self.subTest():
+                _, label = item.as_pair(context)
+                self.assertEqual(label, "Custom Label")
+
+    def test_no_reverse_match(self):
+        """Test handling of NoReverseMatch exception."""
+        item = ViewNameBreadcrumbItem(view_name="nonexistent")
+        context = Context({})
+
+        url, label = item.as_pair(context)
+
+        self.assertEqual(url, "")
+        self.assertEqual(label, "")
+
+    def test_empty_context_keys(self):
+        """Test breadcrumb item when context keys are missing."""
+        context = Context({})
+        item = InstanceBreadcrumbItem(instance_key="missing_key")
+
+        url, label = item.as_pair(context)
+        self.assertEqual(url, "")
+        self.assertEqual(label, "")
+
+        item = ModelBreadcrumbItem(model_key="missing_key")
+        url, label = item.as_pair(context)
+        self.assertEqual(url, "")
+        self.assertEqual(label, "")
+
+
+class BreadcrumbsTestCase(TestCase):
+    """Test cases for Breadcrumbs class."""
+
+    @classmethod
+    def setUpTestData(cls):
+        """Create test data."""
+        cls.location_type = LocationType.objects.create(name="Test Location Type Breadcrumbs")
+
+    def test_default_initialization(self):
+        """Test that Breadcrumbs initializes with default values."""
+        breadcrumbs = Breadcrumbs()
+
+        # Should have defaults for list and details
+        self.assertEqual(len(breadcrumbs.items["list"]), 2)
+        self.assertEqual(len(breadcrumbs.items["detail"]), 3)
+
+        # Verify adding items
+        new_item = BaseBreadcrumbItem()
+        breadcrumbs = Breadcrumbs(items={"detail": [new_item], "list": [new_item], "custom_action": [new_item]})
+
+        self.assertEqual(len(breadcrumbs.items["list"]), 1)
+        self.assertEqual(breadcrumbs.items["list"][0], new_item)
+
+        self.assertEqual(len(breadcrumbs.items["detail"]), 2)
+        self.assertEqual(breadcrumbs.items["detail"][0], new_item)
+
+        self.assertEqual(len(breadcrumbs.items["custom_action"]), 1)
+        self.assertEqual(breadcrumbs.items["custom_action"][0], new_item)
+
+    def test_custom_items(self):
+        """Test Breadcrumbs with custom items."""
+        custom_list_item = ViewNameBreadcrumbItem(view_name="home", label="Home")
+        custom_items = {
+            "list": [ViewNameBreadcrumbItem(view_name="home", label="Home")],
+        }
+        breadcrumbs = Breadcrumbs(items=custom_items)
+
+        self.assertEqual(len(breadcrumbs.items["list"]), 1)
+        self.assertEqual(breadcrumbs.items["list"][0], custom_list_item)
+
+        # Other defaults should still exist
+        self.assertIn("detail", breadcrumbs.items)
+        self.assertEqual(len(breadcrumbs.items["detail"]), 3)
+
+    def test_get_items_from_action_static_method(self):
+        """Test the _get_items_from_action static method."""
+        test_items = {
+            "list": [ViewNameBreadcrumbItem(view_name="", label="List Item")],
+            "detail": [ViewNameBreadcrumbItem(view_name="", label="Detail Item")],
+        }
+
+        # Test specific action found
+        result = Breadcrumbs.get_items_for_action(test_items, "list", False)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0].label, "List Item")
+
+        # Test fallback to detail when action not found and detail=True
+        result = Breadcrumbs.get_items_for_action(test_items, "nonexistent", True)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0].label, "Detail Item")
+
+        # Test no fallback when detail=False
+        result = Breadcrumbs.get_items_for_action(test_items, "nonexistent", False)
+        self.assertEqual(len(result), 0)
+        self.assertEqual(result, [])
+
+    def test_detail_fallback_behavior(self):
+        """Test that detail fallback works correctly in get_breadcrumbs_items."""
+        breadcrumbs = Breadcrumbs()
+        expected_items = [
+            ("/dcim/location-types/", "Location Types"),
+            (f"/dcim/location-types/{self.location_type.pk}/", str(self.location_type)),
+        ]
+
+        # Test with an action that doesn't exist but detail=True
+        context = Context(
+            {"view_action": "custom_action", "detail": True, "model": LocationType, "object": self.location_type}
+        )
+
+        items = breadcrumbs.get_breadcrumbs_items(context)
+
+        # Should get 2 items from detail fallback
+        self.assertEqual(len(items), 2)
+        self.assertEqual(items, expected_items)
+
+    def test_render_method(self):
+        """Test the render method."""
+        breadcrumbs = Breadcrumbs()
+        context = Context({"view_action": "list", "model": Device})
+
+        html = breadcrumbs.render(context)
+
+        expected_html = """<ol class="breadcrumb"><li><a href="/dcim/devices/">Devices</a></li></ol>"""
+        self.assertHTMLEqual(html, expected_html)
+
+    def test_get_extra_context(self):
+        """Test that get_extra_context can be extended."""
+
+        class CustomBreadcrumbs(Breadcrumbs):
+            def get_extra_context(self, context: Context):
+                return {"custom_key": "custom_value"}
+
+        render_context = {}
+
+        def capture_context(template, context, **kwargs):
+            nonlocal render_context
+            render_context = context.flatten()
+            return ""
+
+        breadcrumbs = CustomBreadcrumbs(items={"list": []})
+        context = Context({})
+
+        with patch("nautobot.core.ui.breadcrumbs.render_component_template", side_effect=capture_context):
+            breadcrumbs.render(context)
+
+        # Check that custom context was passed
+        self.assertEqual(render_context.get("custom_key"), "custom_value")
+
+    def test_should_render_skips_items(self):
+        """Breadcrumbs should skip items where should_render(context) is False."""
+
+        item_visible = ViewNameBreadcrumbItem(view_name="home", label="Visible", should_render=lambda _: True)
+        item_hidden = ViewNameBreadcrumbItem(view_name="home", label="Hidden", should_render=lambda _: False)
+        breadcrumbs = Breadcrumbs(items={"custom_action": [item_visible, item_hidden]})
+        context = Context({"view_action": "custom_action"})
+
+        items = breadcrumbs.get_breadcrumbs_items(context)
+        self.assertEqual(len(items), 1)
+        self.assertIn(("/", "Visible"), items)
+        self.assertNotIn(("/", "Hidden"), items)
+
+    def test_filter_breadcrumbs_items_removes_empty_pairs(self):
+        """filter_breadcrumbs_items should remove items where label is empty or None."""
+
+        breadcrumbs = Breadcrumbs()
+        # (url, label) pairs: only the last should remain
+        pairs = [
+            ("", ""),  # empty
+            ("", "   "),  # whitespace
+            ("", "\t"),  # whitespace
+            ("", "Non-empty"),  # label not empty
+            ("/foo", ""),  # url not empty
+            ("/foo", "Label"),  # url, label not empty
+            (None, None),  # both None
+            (None, "Label"),  # label not None
+            ("/bar", None),  # url not None
+        ]
+        expected = [
+            ("", "Non-empty"),
+            ("/foo", "Label"),
+            (None, "Label"),
+        ]
+        filtered = breadcrumbs.filter_breadcrumbs_items(pairs, Context({}))
+        self.assertEqual(filtered, expected)

nautobot/core/tests/test_commands.py

@@ -1,9 +1,13 @@
 from io import StringIO
 
 from django.core.management import call_command
+from django.utils.timezone import now
 import yaml
 
+from nautobot.core.management.commands.check_job_approval_status import ApprovalRequiredScheduledJobsError
 from nautobot.core.testing import TestCase
+from nautobot.extras.choices import JobExecutionType
+from nautobot.extras.models import Job, ScheduledJob
 
 
 class ManagementCommandTestCase(TestCase):
@@ -29,3 +33,39 @@ class ManagementCommandTestCase(TestCase):
                 self.assertHttpStatus(
                     response, 200, f"{view_name}: {endpoint} returns status Code {response.status_code} instead of 200"
                 )
+
+    def test_check_job_approval_status_no_jobs(self):
+        out = StringIO()
+        # update all jobs to not have approval_required=True
+        Job.objects.update(approval_required=False)
+        call_command("check_job_approval_status", stdout=out)
+        output = out.getvalue()
+        self.assertIn("No approval_required jobs or scheduled jobs found.", output)
+
+    def test_check_job_approval_status_with__with_approval_required_jobs(self):
+        out = StringIO()
+        self.assertTrue(Job.objects.filter(approval_required=True).exists())
+        self.assertFalse(ScheduledJob.objects.filter(approval_required=True).exists())
+        call_command("check_job_approval_status", stdout=out)
+        output = out.getvalue()
+        self.assertIn("Following jobs still have `approval_required=True`.", output)
+
+    def test_check_job_approval_status_with_approval_required_scheduled_jobs(self):
+        job = Job.objects.first()
+        scheduled_job = ScheduledJob.objects.create(
+            name="Scheduled Job",
+            task="test_managment_command.TestManagmentCommand",
+            job_model=job,
+            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            user=self.user,
+            approval_required=True,
+            start_time=now(),
+        )
+        self.assertTrue(ScheduledJob.objects.filter(approval_required=True).exists())
+        with self.assertRaises(ApprovalRequiredScheduledJobsError) as cm:
+            call_command("check_job_approval_status")
+
+        self.assertIn(
+            "These need to be approved (and run) or denied before upgrading to Nautobot v3", str(cm.exception)
+        )
+        self.assertIn(scheduled_job.name, str(cm.exception))

nautobot/core/tests/test_filters.py

@@ -19,10 +19,60 @@ from nautobot.core.utils import lookup
 from nautobot.dcim import choices as dcim_choices, filters as dcim_filters, models as dcim_models
 from nautobot.dcim.models import Controller, Device
 from nautobot.extras import models as extras_models
-from nautobot.extras.utils import FeatureQuery
+from nautobot.extras.utils import FeatureQuery, RoleModelsQuery
 from nautobot.ipam import models as ipam_models
 
 
+class ContentTypeMultipleChoiceFilterTest(testing.TestCase):
+    class RoleFilterSet(filters.BaseFilterSet):
+        content_types = filters.ContentTypeMultipleChoiceFilter(
+            choices=RoleModelsQuery().get_choices,
+            conjoined=False,
+        )
+
+        class Meta:
+            model = extras_models.Role
+            fields = ["content_types"]
+
+    def test_filter_variations(self):
+        with self.subTest("single label"):
+            filterset = self.RoleFilterSet({"content_types": ["ipam.ipaddress"]}, extras_models.Role.objects.all())
+            qs = extras_models.Role.objects.filter(
+                content_types__in=[ContentType.objects.get_for_model(ipam_models.IPAddress)]
+            )
+            self.assertQuerysetEqualAndNotEmpty(filterset.qs, qs)
+
+        with self.subTest("multiple labels"):
+            filterset = self.RoleFilterSet(
+                {"content_types": ["ipam.ipaddress", "dcim.rack"]}, extras_models.Role.objects.all()
+            )
+            # remember, conjoined=False
+            qs = extras_models.Role.objects.filter(
+                django_models.Q(content_types__in=[ContentType.objects.get_for_model(ipam_models.IPAddress)])
+                | django_models.Q(content_types__in=[ContentType.objects.get_for_model(dcim_models.Rack)])
+            ).distinct()
+            self.assertQuerysetEqualAndNotEmpty(filterset.qs, qs)
+
+        with self.subTest("exclude single label"):
+            filterset = self.RoleFilterSet({"content_types__n": ["ipam.ipaddress"]}, extras_models.Role.objects.all())
+            qs = extras_models.Role.objects.exclude(
+                content_types__in=[ContentType.objects.get_for_model(ipam_models.IPAddress)]
+            )
+            self.assertQuerysetEqualAndNotEmpty(filterset.qs, qs)
+
+        with self.subTest("exclude multiple labels"):
+            filterset = self.RoleFilterSet(
+                {"content_types__n": ["ipam.ipaddress", "dcim.rack"]}, extras_models.Role.objects.all()
+            )
+            self.assertTrue(filterset.is_valid(), filterset.errors)
+            # remember, conjoined=False
+            qs = extras_models.Role.objects.exclude(
+                django_models.Q(content_types__in=[ContentType.objects.get_for_model(ipam_models.IPAddress)])
+                | django_models.Q(content_types__in=[ContentType.objects.get_for_model(dcim_models.Rack)])
+            ).distinct()
+            self.assertQuerysetEqualAndNotEmpty(filterset.qs, qs)
+
+
 class TreeNodeMultipleChoiceFilterTest(TestCase):
     class LocationFilterSet(filters.BaseFilterSet):
         parent = filters.TreeNodeMultipleChoiceFilter(queryset=dcim_models.Location.objects.all())

nautobot/core/tests/test_forms.py

@@ -581,7 +581,7 @@ class JSONFieldTest(testing.TestCase):
         device_content_type = ContentType.objects.get_for_model(dcim_models.Device)
         custom_field.content_types.set([device_content_type])
         # Fetch URL with filter parameter
-        response = self.client.get(f'{reverse("dcim:device_list")}?name=Foo%20Device')
+        response = self.client.get(f"{reverse('dcim:device_list')}?name=Foo%20Device")
         self.assertIn("Foo Device", str(response.content))
 
     def test_prepare_value_with_utf8(self):

nautobot/core/tests/test_graphql.py

@@ -527,18 +527,18 @@ class GraphQLAPIPermissionTest(GraphQLTestCaseBase):
         for i in range(2):
             # Rack permission
             rack_obj_permission = ObjectPermission.objects.create(
-                name=f"Permission Rack {i+1}",
+                name=f"Permission Rack {i + 1}",
                 actions=["view", "add", "change", "delete"],
-                constraints={"location__name": f"Location {i+1}"},
+                constraints={"location__name": f"Location {i + 1}"},
             )
             rack_obj_permission.object_types.add(rack_object_type)
             rack_obj_permission.groups.add(cls.groups[i])
             rack_obj_permission.users.add(cls.users[i])
 
             location_obj_permission = ObjectPermission.objects.create(
-                name=f"Permission Location {i+1}",
+                name=f"Permission Location {i + 1}",
                 actions=["view", "add", "change", "delete"],
-                constraints={"name": f"Location {i+1}"},
+                constraints={"name": f"Location {i + 1}"},
             )
             location_obj_permission.object_types.add(location_object_type)
             location_obj_permission.groups.add(cls.groups[i])