nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/core/tests/test_filters.py

@@ -323,102 +323,106 @@ class NaturalKeyOrPKMultipleChoiceFilterTest(TestCase, testing.NautobotTestCaseM
         self.power_panel3 = dcim_models.PowerPanel.objects.create(location=self.locations[0], name="test-power-panel3")
         self.power_panel3a = dcim_models.PowerPanel.objects.create(location=self.locations[1], name="test-power-panel3")
 
-    def test_filter_single_name(self):
-        kwargs = {"power_panels": ["test-power-panel1"]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
+    def test_filter_params(self):
+        with self.subTest("Verify automatic label construction"):
+            self.assertEqual("Power panels (name or ID)", self.LocationFilterSet().filters["power_panels"].label)
 
-        self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0]])
+        with self.subTest("Single name"):
+            kwargs = {"power_panels": ["test-power-panel1"]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
 
-    def test_filter_single_pk(self):
-        kwargs = {"power_panels": [self.power_panel1.pk]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0]])
 
-        self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0]])
+        with self.subTest("Single PK"):
+            kwargs = {"power_panels": [self.power_panel1.pk]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
 
-    def test_filter_multiple_name(self):
-        kwargs = {"power_panels": ["test-power-panel1", "test-power-panel2"]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0]])
 
-        self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0], self.locations[1]])
+        with self.subTest("Multiple names"):
+            kwargs = {"power_panels": ["test-power-panel1", "test-power-panel2"]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
 
-    def test_filter_duplicate_name(self):
-        kwargs = {"power_panels": ["test-power-panel3"]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0], self.locations[1]])
 
-        self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0], self.locations[1]])
+        with self.subTest("Duplicated name"):
+            kwargs = {"power_panels": ["test-power-panel3"]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
 
-    def test_filter_null(self):
-        kwargs = {"power_panels": [settings.FILTERS_NULL_CHOICE_VALUE]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
-        expected_result = dcim_models.Location.objects.filter(power_panels__isnull=True)
+            self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0], self.locations[1]])
 
-        self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
+        with self.subTest("Null-value filter"):
+            kwargs = {"power_panels": [settings.FILTERS_NULL_CHOICE_VALUE]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            expected_result = dcim_models.Location.objects.filter(power_panels__isnull=True)
 
-    def test_filter_combined_name(self):
-        kwargs = {"power_panels": ["test-power-panel1", settings.FILTERS_NULL_CHOICE_VALUE]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
-        expected_result = dcim_models.Location.objects.filter(
-            power_panels__isnull=True
-        ) | dcim_models.Location.objects.filter(power_panels__name__in=["test-power-panel1"])
+            self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
 
-        self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
+        with self.subTest("Name and null-value filter"):
+            kwargs = {"power_panels": ["test-power-panel1", settings.FILTERS_NULL_CHOICE_VALUE]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            expected_result = dcim_models.Location.objects.filter(
+                power_panels__isnull=True
+            ) | dcim_models.Location.objects.filter(power_panels__name__in=["test-power-panel1"])
 
-    def test_filter_combined_pk(self):
-        kwargs = {"power_panels": [self.power_panel2.pk, settings.FILTERS_NULL_CHOICE_VALUE]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
-        expected_result = dcim_models.Location.objects.filter(
-            power_panels__isnull=True
-        ) | dcim_models.Location.objects.filter(power_panels__pk__in=[self.power_panel2.pk])
+            self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
 
-        self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
+        with self.subTest("PK and null-value filter"):
+            kwargs = {"power_panels": [self.power_panel2.pk, settings.FILTERS_NULL_CHOICE_VALUE]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            expected_result = dcim_models.Location.objects.filter(
+                power_panels__isnull=True
+            ) | dcim_models.Location.objects.filter(power_panels__pk__in=[self.power_panel2.pk])
 
-    def test_filter_single_name_exclude(self):
-        kwargs = {"power_panels__n": ["test-power-panel1"]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
-        expected_result = dcim_models.Location.objects.exclude(power_panels__name__in=["test-power-panel1"])
+            self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
 
-        self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
+        with self.subTest("Exclude single name"):
+            kwargs = {"power_panels__n": ["test-power-panel1"]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            expected_result = dcim_models.Location.objects.exclude(power_panels__name__in=["test-power-panel1"])
 
-    def test_filter_single_pk_exclude(self):
-        kwargs = {"power_panels__n": [self.power_panel2.pk]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
-        expected_result = dcim_models.Location.objects.exclude(power_panels__pk__in=[self.power_panel2.pk])
+            self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
 
-        self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
+        with self.subTest("Exclude single PK"):
+            kwargs = {"power_panels__n": [self.power_panel2.pk]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            expected_result = dcim_models.Location.objects.exclude(power_panels__pk__in=[self.power_panel2.pk])
 
-    def test_filter_multiple_name_exclude(self):
-        kwargs = {"power_panels__n": ["test-power-panel1", "test-power-panel2"]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
-        expected_result = dcim_models.Location.objects.exclude(power_panels__name__in=["test-power-panel1"]).exclude(
-            power_panels__name__in=["test-power-panel2"]
-        )
+            self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
 
-        self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
+        with self.subTest("Exclude multiple names"):
+            kwargs = {"power_panels__n": ["test-power-panel1", "test-power-panel2"]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            expected_result = dcim_models.Location.objects.exclude(
+                power_panels__name__in=["test-power-panel1"]
+            ).exclude(power_panels__name__in=["test-power-panel2"])
 
-    def test_filter_duplicate_name_exclude(self):
-        kwargs = {"power_panels__n": ["test-power-panel3"]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
-        expected_result = dcim_models.Location.objects.exclude(power_panels__name__in=["test-power-panel3"])
+            self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
 
-        self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
+        with self.subTest("Exclude a duplicated name"):
+            kwargs = {"power_panels__n": ["test-power-panel3"]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            expected_result = dcim_models.Location.objects.exclude(power_panels__name__in=["test-power-panel3"])
 
-    def test_filter_null_exclude(self):
-        kwargs = {"power_panels__n": [settings.FILTERS_NULL_CHOICE_VALUE]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            self.assertQuerysetEqualAndNotEmpty(qs, expected_result)
 
-        self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0], self.locations[1]])
+        with self.subTest("Exclude null-value filter"):
+            kwargs = {"power_panels__n": [settings.FILTERS_NULL_CHOICE_VALUE]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
 
-    def test_filter_combined_name_exclude(self):
-        kwargs = {"power_panels__n": ["test-power-panel1", settings.FILTERS_NULL_CHOICE_VALUE]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0], self.locations[1]])
 
-        self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[1]])
+        with self.subTest("Exclude name and null-value filter"):
+            kwargs = {"power_panels__n": ["test-power-panel1", settings.FILTERS_NULL_CHOICE_VALUE]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
 
-    def test_filter_combined_pk_exclude(self):
-        kwargs = {"power_panels__n": [self.power_panel2.pk, settings.FILTERS_NULL_CHOICE_VALUE]}
-        qs = self.LocationFilterSet(kwargs, self.queryset).qs
+            self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[1]])
 
-        self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0]])
+        with self.subTest("Exclude PK and null-value filter"):
+            kwargs = {"power_panels__n": [self.power_panel2.pk, settings.FILTERS_NULL_CHOICE_VALUE]}
+            qs = self.LocationFilterSet(kwargs, self.queryset).qs
+
+            self.assertQuerysetEqualAndNotEmpty(qs, [self.locations[0]])
 
     def test_get_filter_predicate(self):
         """
@@ -966,279 +970,282 @@ class DynamicFilterLookupExpressionTest(TestCase):
                 "comments",
             ]
 
-    def test_location_name_negation(self):
-        params = {"name__n": ["Location 1"]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.exclude(name="Location 1"),
-        )
-
-    def test_location_name_icontains(self):
-        params = {"name__ic": ["-1"]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(name__icontains="-1"),
-        )
-
-    def test_location_name_icontains_negation(self):
-        params = {"name__nic": ["-1"]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.exclude(name__icontains="-1"),
-        )
-
-    def test_location_name_startswith(self):
-        startswith = dcim_models.Location.objects.first().name[:3]
-        params = {"name__isw": [startswith]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(name__istartswith=startswith),
-        )
+    def test_location_name_filter(self):
+        with self.subTest("name__n"):
+            params = {"name__n": ["Location 1"]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.exclude(name="Location 1"),
+            )
 
-    def test_location_name_startswith_negation(self):
-        startswith = dcim_models.Location.objects.first().name[:3]
-        params = {"name__nisw": [startswith]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.exclude(name__icontains=startswith),
-        )
+        with self.subTest("name__ic"):
+            params = {"name__ic": ["-1"]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(name__icontains="-1"),
+            )
 
-    def test_location_name_endswith(self):
-        endswith = dcim_models.Location.objects.first().name[-2:]
-        params = {"name__iew": [endswith]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(name__iendswith=endswith),
-        )
+        with self.subTest("name__nic"):
+            params = {"name__nic": ["-1"]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.exclude(name__icontains="-1"),
+            )
 
-    def test_location_name_endswith_negation(self):
-        endswith = dcim_models.Location.objects.first().name[-2:]
-        params = {"name__niew": [endswith]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.exclude(name__iendswith=endswith),
-        )
+        with self.subTest("name__isw"):
+            startswith = dcim_models.Location.objects.first().name[:3]
+            params = {"name__isw": [startswith]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(name__istartswith=startswith),
+            )
 
-    def test_location_name_regex(self):
-        params = {"name__re": ["-1$"]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(name__regex="-1$"),
-        )
+        with self.subTest("name__nisw"):
+            startswith = dcim_models.Location.objects.first().name[:3]
+            params = {"name__nisw": [startswith]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.exclude(name__icontains=startswith),
+            )
 
-    def test_location_name_regex_negation(self):
-        params = {"name__nre": ["-1$"]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.exclude(name__regex="-1$"),
-        )
+        with self.subTest("name__iew"):
+            endswith = dcim_models.Location.objects.first().name[-2:]
+            params = {"name__iew": [endswith]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(name__iendswith=endswith),
+            )
 
-    def test_location_name_iregex(self):
-        params = {"name__ire": ["location"]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(name__iregex="location"),
-        )
+        with self.subTest("name__niew"):
+            endswith = dcim_models.Location.objects.first().name[-2:]
+            params = {"name__niew": [endswith]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.exclude(name__iendswith=endswith),
+            )
 
-    def test_location_name_iregex_negation(self):
-        params = {"name__nire": ["location"]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.exclude(name__iregex="location"),
-        )
+        with self.subTest("name__re"):
+            params = {"name__re": ["-1$"]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(name__regex="-1$"),
+            )
 
-    def test_location_asn_lt(self):
-        asn = dcim_models.Location.objects.filter(asn__isnull=False).first().asn
-        params = {"asn__lt": [asn]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(asn__lt=asn),
-        )
+        with self.subTest("name__nre"):
+            params = {"name__nre": ["-1$"]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.exclude(name__regex="-1$"),
+            )
 
-    def test_location_asn_lte(self):
-        asn = dcim_models.Location.objects.filter(asn__isnull=False).first().asn
-        params = {"asn__lte": [asn]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(asn__lte=asn),
-        )
+        with self.subTest("name__ire"):
+            params = {"name__ire": ["location"]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(name__iregex="location"),
+            )
 
-    def test_location_asn_gt(self):
-        asn = dcim_models.Location.objects.filter(asn__isnull=False).first().asn
-        params = {"asn__gt": [asn]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(asn__gt=asn),
-        )
+        with self.subTest("name__nire"):
+            params = {"name__nire": ["location"]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.exclude(name__iregex="location"),
+            )
 
-    def test_location_asn_gte(self):
+    def test_location_asn_filter(self):
         asn = dcim_models.Location.objects.filter(asn__isnull=False).first().asn
-        params = {"asn__gte": [asn]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.filter(asn__gte=asn),
-        )
-
-    def test_location_parent_negation(self):
-        params = {"parent__n": [self.locations[0].parent.name]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.exclude(parent__name__in=[self.locations[0].parent.name]),
-        )
-
-    def test_location_parent_id_negation(self):
-        params = {"parent__n": [self.locations[0].parent.pk]}
-        self.assertQuerysetEqual(
-            dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
-            dcim_models.Location.objects.exclude(parent__in=[self.locations[0].parent.pk]),
-        )
-
-    def test_device_name_eq(self):
-        params = {"name": ["Device 1"]}
-        self.assertQuerysetEqual(
-            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(name="Device 1"),
-        )
-
-    def test_device_name_negation(self):
-        params = {"name__n": ["Device 1"]}
-        self.assertQuerysetEqual(
-            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
-            dcim_models.Device.objects.exclude(name="Device 1"),
-        )
-
-    def test_device_name_startswith(self):
-        params = {"name__isw": ["Device"]}
-        self.assertQuerysetEqual(
-            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(name__istartswith="Device"),
-        )
-
-    def test_device_name_startswith_negation(self):
-        params = {"name__nisw": ["Device 1"]}
-        self.assertQuerysetEqual(
-            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
-            dcim_models.Device.objects.exclude(name__istartswith="Device 1"),
-        )
-
-    def test_device_name_endswith(self):
-        params = {"name__iew": [" 1"]}
-        self.assertQuerysetEqual(
-            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(name__iendswith=" 1"),
-        )
-
-    def test_device_name_endswith_negation(self):
-        params = {"name__niew": [" 1"]}
-        self.assertQuerysetEqual(
-            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
-            dcim_models.Device.objects.exclude(name__iendswith=" 1"),
-        )
+        with self.subTest("asn__lt"):
+            params = {"asn__lt": [asn]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(asn__lt=asn),
+            )
 
-    def test_device_name_icontains(self):
-        params = {"name__ic": [" 2"]}
-        self.assertQuerysetEqual(
-            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(name__icontains=" 2"),
-        )
+        with self.subTest("asn__lte"):
+            params = {"asn__lte": [asn]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(asn__lte=asn),
+            )
 
-    def test_device_name_icontains_negation(self):
-        params = {"name__nic": [" "]}
-        self.assertQuerysetEqual(
-            dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
-            dcim_models.Device.objects.exclude(name__icontains=" "),
-        )
+        with self.subTest("asn__gt"):
+            params = {"asn__gt": [asn]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(asn__gt=asn),
+            )
 
-    def test_device_mac_address_negation(self):
-        params = {"mac_address__n": ["00-00-00-00-00-01", "aa-00-00-00-00-01"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+        with self.subTest("asn__gte"):
+            params = {"asn__gte": [asn]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.filter(asn__gte=asn),
+            )
 
-    def test_device_mac_address_startswith(self):
-        params = {"mac_address__isw": ["aa:"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+    def test_location_parent_filter(self):
+        with self.subTest("parent__n: name"):
+            params = {"parent__n": [self.locations[0].parent.name]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.exclude(parent__name__in=[self.locations[0].parent.name]),
+            )
 
-    def test_device_mac_address_startswith_negation(self):
-        params = {"mac_address__nisw": ["aa:"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+        with self.subTest("parent__n: id"):
+            params = {"parent__n": [self.locations[0].parent.pk]}
+            self.assertQuerysetEqual(
+                dcim_filters.LocationFilterSet(params, self.location_queryset).qs,
+                dcim_models.Location.objects.exclude(parent__in=[self.locations[0].parent.pk]),
+            )
 
-    def test_device_mac_address_endswith(self):
-        params = {"mac_address__iew": [":02"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+    def test_device_name_filter(self):
+        with self.subTest("name"):
+            params = {"name": ["Device 1"]}
+            self.assertQuerysetEqual(
+                dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(name="Device 1"),
+            )
 
-    def test_device_mac_address_endswith_negation(self):
-        params = {"mac_address__niew": [":02"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+        with self.subTest("name__n"):
+            params = {"name__n": ["Device 1"]}
+            self.assertQuerysetEqual(
+                dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+                dcim_models.Device.objects.exclude(name="Device 1"),
+            )
 
-    def test_device_mac_address_icontains(self):
-        params = {"mac_address__ic": ["aa:", "bb"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+        with self.subTest("name__isw"):
+            params = {"name__isw": ["Device"]}
+            self.assertQuerysetEqual(
+                dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(name__istartswith="Device"),
+            )
 
-    def test_device_mac_address_icontains_negation(self):
-        params = {"mac_address__nic": ["aa:", "bb"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+        with self.subTest("name__nisw"):
+            params = {"name__nisw": ["Device 1"]}
+            self.assertQuerysetEqual(
+                dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+                dcim_models.Device.objects.exclude(name__istartswith="Device 1"),
+            )
 
-    def test_device_mac_address_regex(self):
-        params = {"mac_address__re": ["^AA:"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+        with self.subTest("name__iew"):
+            params = {"name__iew": [" 1"]}
+            self.assertQuerysetEqual(
+                dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(name__iendswith=" 1"),
+            )
 
-    def test_device_mac_address_iregex(self):
-        params = {"mac_address__ire": ["^aa:"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+        with self.subTest("name__niew"):
+            params = {"name__niew": [" 1"]}
+            self.assertQuerysetEqual(
+                dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+                dcim_models.Device.objects.exclude(name__iendswith=" 1"),
+            )
 
-    def test_device_mac_address_regex_negation(self):
-        params = {"mac_address__nre": ["^AA:"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+        with self.subTest("name__ic"):
+            params = {"name__ic": [" 2"]}
+            self.assertQuerysetEqual(
+                dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(name__icontains=" 2"),
+            )
 
-    def test_device_mac_address_iregex_negation(self):
-        params = {"mac_address__nire": ["^aa:"]}
-        self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+        with self.subTest("name__nic"):
+            params = {"name__nic": [" "]}
+            self.assertQuerysetEqual(
+                dcim_filters.DeviceFilterSet(params, self.device_queryset).qs,
+                dcim_models.Device.objects.exclude(name__icontains=" "),
+            )
 
-    def test_device_comments_multiple_value_charfield(self):
-        params = {"comments": ["Device 1 comments"]}
-        self.assertQuerysetEqual(
-            self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(comments="Device 1 comments"),
-        )
-        params = {"comments": ["Device 1 comments", "Device 2 comments"]}
-        self.assertQuerysetEqual(
-            self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(comments__in=["Device 1 comments", "Device 2 comments"]),
-        )
-        params = {"comments": ["Device 1 comments", "Device 2 comments", "Device 3 comments"]}
-        self.assertQuerysetEqual(
-            self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(
-                comments__in=["Device 1 comments", "Device 2 comments", "Device 3 comments"]
-            ),
-        )
+    def test_device_mac_address_filter(self):
+        with self.subTest("mac_address__n"):
+            params = {"mac_address__n": ["00-00-00-00-00-01", "aa-00-00-00-00-01"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+
+        with self.subTest("mac_address__isw"):
+            params = {"mac_address__isw": ["aa:"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+
+        with self.subTest("mac_address__nisw"):
+            params = {"mac_address__nisw": ["aa:"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+
+        with self.subTest("mac_address__iew"):
+            params = {"mac_address__iew": [":02"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+
+        with self.subTest("mac_address__niew"):
+            params = {"mac_address__niew": [":02"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+
+        with self.subTest("mac_address__ic"):
+            params = {"mac_address__ic": ["aa:", "bb"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+
+        with self.subTest("mac_address__nic"):
+            params = {"mac_address__nic": ["aa:", "bb"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+
+        with self.subTest("mac_address__re"):
+            params = {"mac_address__re": ["^AA:"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+
+        with self.subTest("mac_address__ire"):
+            params = {"mac_address__ire": ["^aa:"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 1)
+
+        with self.subTest("mac_address__nre"):
+            params = {"mac_address__nre": ["^AA:"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+
+        with self.subTest("mac_address__nire"):
+            params = {"mac_address__nire": ["^aa:"]}
+            self.assertEqual(dcim_filters.DeviceFilterSet(params, self.device_queryset).qs.count(), 2)
+
+    def test_device_comments_filter(self):
+        with self.subTest("comments"):
+            params = {"comments": ["Device 1 comments"]}
+            self.assertQuerysetEqual(
+                self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(comments="Device 1 comments"),
+            )
+            params = {"comments": ["Device 1 comments", "Device 2 comments"]}
+            self.assertQuerysetEqual(
+                self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(comments__in=["Device 1 comments", "Device 2 comments"]),
+            )
+            params = {"comments": ["Device 1 comments", "Device 2 comments", "Device 3 comments"]}
+            self.assertQuerysetEqual(
+                self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(
+                    comments__in=["Device 1 comments", "Device 2 comments", "Device 3 comments"]
+                ),
+            )
 
-    def test_device_comments_multiple_value_charfield_regex(self):
-        params = {"comments__re": ["^Device"]}
-        self.assertQuerysetEqual(
-            self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(comments__regex="^Device"),
-        )
+        with self.subTest("comments__re"):
+            params = {"comments__re": ["^Device"]}
+            self.assertQuerysetEqual(
+                self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(comments__regex="^Device"),
+            )
 
-    def test_device_comments_multiple_value_charfield_regex_negation(self):
-        params = {"comments__nre": ["^Device"]}
-        self.assertQuerysetEqual(
-            self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
-            dcim_models.Device.objects.exclude(comments__regex="^Device"),
-        )
+        with self.subTest("comments__nre"):
+            params = {"comments__nre": ["^Device"]}
+            self.assertQuerysetEqual(
+                self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
+                dcim_models.Device.objects.exclude(comments__regex="^Device"),
+            )
 
-    def test_device_comments_multiple_value_charfield_iregex(self):
-        params = {"comments__ire": ["^device"]}
-        self.assertQuerysetEqual(
-            self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
-            dcim_models.Device.objects.filter(comments__iregex="^device"),
-        )
+        with self.subTest("comments__ire"):
+            params = {"comments__ire": ["^device"]}
+            self.assertQuerysetEqual(
+                self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
+                dcim_models.Device.objects.filter(comments__iregex="^device"),
+            )
 
-    def test_device_comments_multiple_value_charfield_iregex_negation(self):
-        params = {"comments__nire": ["^device"]}
-        self.assertQuerysetEqual(
-            self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
-            dcim_models.Device.objects.exclude(comments__iregex="^device"),
-        )
+        with self.subTest("comments__nire"):
+            params = {"comments__nire": ["^device"]}
+            self.assertQuerysetEqual(
+                self.DeviceFilterSetWithComments(params, self.device_queryset).qs,
+                dcim_models.Device.objects.exclude(comments__iregex="^device"),
+            )
 
 
 class GetFiltersetTestValuesTest(testing.FilterTestCases.BaseFilterTestCase):
@@ -1372,12 +1379,13 @@ class SearchFilterTest(TestCase, testing.NautobotTestCaseMixin):
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset_class(params, self.queryset).qs, self.queryset.filter(asn__exact=12345)
         )
-        asn = (
-            dcim_models.Location.objects.exclude(asn="12345")
-            .exclude(asn__isnull=True)
-            .values_list("asn", flat=True)
-            .first()
-        )
+        asn = 1111111
+        first_location = dcim_models.Location.objects.first()
+        first_location.asn = 1111111
+        first_location.save()
+        last_location = dcim_models.Location.objects.last()
+        last_location.asn = 1111111
+        last_location.save()
         params = {"q": str(asn)}
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset_class(params, self.queryset).qs, self.queryset.filter(asn__exact=asn)