nautobot 3.0.0a2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

nautobot/dcim/tests/test_api.py

@@ -13,7 +13,9 @@ from nautobot.core.testing import APITestCase, APIViewTestCases
 from nautobot.core.testing.utils import generate_random_device_asset_tag_of_specified_size, get_deletable_objects
 from nautobot.dcim.choices import (
     ConsolePortTypeChoices,
+    InterfaceDuplexChoices,
     InterfaceModeChoices,
+    InterfaceSpeedChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
     PowerFeedBreakerPoleChoices,
@@ -1177,6 +1179,7 @@ class PowerOutletTemplateTest(Mixins.ModularDeviceComponentTemplateMixin, Mixins
 
 class InterfaceTemplateTest(Mixins.ModularDeviceComponentTemplateMixin, Mixins.BasePortTemplateTestMixin):
     model = InterfaceTemplate
+    choices_fields = ["duplex", "type"]
     modular_component_create_data = {"type": InterfaceTypeChoices.TYPE_1GE_FIXED}
 
     @classmethod
@@ -1200,6 +1203,62 @@ class InterfaceTemplateTest(Mixins.ModularDeviceComponentTemplateMixin, Mixins.B
             },
         ]
 
+    def test_create_base_t_with_speed_and_duplex(self):
+        self.add_permissions("dcim.add_interfacetemplate", "dcim.view_interfacetemplate", "dcim.view_devicetype")
+        url = self._get_list_url()
+        payload = {
+            "device_type": self.device_type.pk,
+            "name": "Eth1",
+            "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+            "mgmt_only": False,
+            "speed": InterfaceSpeedChoices.SPEED_1G,
+            "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+        }
+        response = self.client.post(url, data=payload, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        obj = InterfaceTemplate.objects.get(pk=response.data["id"])  # type: ignore[index]
+        self.assertEqual(obj.speed, InterfaceSpeedChoices.SPEED_1G)
+        self.assertEqual(obj.duplex, InterfaceDuplexChoices.DUPLEX_FULL)
+
+    def test_create_sfp_with_duplex_rejected(self):
+        self.add_permissions("dcim.add_interfacetemplate", "dcim.view_interfacetemplate", "dcim.view_devicetype")
+        url = self._get_list_url()
+        payload = {
+            "device_type": self.device_type.pk,
+            "name": "SFP1",
+            "type": InterfaceTypeChoices.TYPE_1GE_SFP,
+            "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+        }
+        response = self.client.post(url, data=payload, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("duplex", response.data)
+
+    def test_create_lag_with_speed_rejected(self):
+        self.add_permissions("dcim.add_interfacetemplate", "dcim.view_interfacetemplate", "dcim.view_devicetype")
+        url = self._get_list_url()
+        payload = {
+            "device_type": self.device_type.pk,
+            "name": "Port-Channel1",
+            "type": InterfaceTypeChoices.TYPE_LAG,
+            "speed": InterfaceSpeedChoices.SPEED_1G,
+        }
+        response = self.client.post(url, data=payload, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("speed", response.data)
+
+    def test_create_virtual_with_speed_rejected(self):
+        self.add_permissions("dcim.add_interfacetemplate", "dcim.view_interfacetemplate", "dcim.view_devicetype")
+        url = self._get_list_url()
+        payload = {
+            "device_type": self.device_type.pk,
+            "name": "V0",
+            "type": InterfaceTypeChoices.TYPE_VIRTUAL,
+            "speed": InterfaceSpeedChoices.SPEED_1G,
+        }
+        response = self.client.post(url, data=payload, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("speed", response.data)
+
 
 class FrontPortTemplateTest(Mixins.BasePortTemplateTestMixin):
     model = FrontPortTemplate
@@ -1471,6 +1530,9 @@ class PlatformTest(APIViewTestCases.APIViewTestCase):
 class DeviceTest(APIViewTestCases.APIViewTestCase):
     model = Device
     choices_fields = ["face"]
+    validation_excluded_fields = [
+        "software_image_files",  # M2M field, excluded by default
+    ]
 
     @classmethod
     def setUpTestData(cls):
@@ -2167,7 +2229,10 @@ class PowerOutletTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMix
 class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin):
     model = Interface
     peer_termination_type = Interface
-    choices_fields = ["mode", "type"]
+    choices_fields = ["duplex", "mode", "type"]
+    validation_excluded_fields = [
+        "tagged_vlans",  # M2M field, excluded by default
+    ]
 
     @classmethod
     def setUpTestData(cls):
@@ -2208,14 +2273,14 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
             Interface.objects.create(
                 device=cls.devices[0],
                 name="Test Interface 1",
-                type="1000base-t",
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
                 status=non_default_status,
                 role=intf_role,
             ),
             Interface.objects.create(
                 device=cls.devices[0],
                 name="Test Interface 2",
-                type="1000base-t",
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
                 status=non_default_status,
             ),
             Interface.objects.create(
@@ -2266,7 +2331,7 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
             {
                 "device": cls.devices[0].pk,
                 "name": "Test Interface 8",
-                "type": "1000base-t",
+                "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
                 "status": interface_status.pk,
                 "role": intf_role.pk,
                 "mode": InterfaceModeChoices.MODE_TAGGED,
@@ -2277,7 +2342,7 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
             {
                 "device": cls.devices[0].pk,
                 "name": "Test Interface 9",
-                "type": "1000base-t",
+                "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
                 "status": interface_status.pk,
                 "role": intf_role.pk,
                 "mode": InterfaceModeChoices.MODE_TAGGED,
@@ -2289,13 +2354,35 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
             {
                 "device": cls.devices[0].pk,
                 "name": "Test Interface 10",
-                "type": "virtual",
+                "type": InterfaceTypeChoices.TYPE_VIRTUAL,
                 "status": interface_status.pk,
                 "mode": InterfaceModeChoices.MODE_TAGGED,
                 "parent_interface": cls.interfaces[1].pk,
                 "tagged_vlans": [cls.vlans[0].pk, cls.vlans[1].pk],
                 "untagged_vlan": cls.vlans[2].pk,
             },
+            {
+                "device": cls.devices[0].pk,
+                "name": "Test Interface 11",
+                "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+                "status": interface_status.pk,
+                "speed": InterfaceSpeedChoices.SPEED_1G,
+            },
+            {
+                "device": cls.devices[0].pk,
+                "name": "Test Interface 12",
+                "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+                "status": interface_status.pk,
+                "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+            },
+            {
+                "device": cls.devices[0].pk,
+                "name": "Test Interface 13",
+                "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+                "status": interface_status.pk,
+                "speed": InterfaceSpeedChoices.SPEED_1G,
+                "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+            },
         ]
 
         cls.untagged_vlan_data = {
@@ -2504,6 +2591,105 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
             response = self.client.patch(self._get_detail_url(interface), data=payload, format="json", **self.header)
             self.assertHttpStatus(response, status.HTTP_200_OK)
 
+    def test_speed_duplex_invalid_by_type(self):
+        """Test that API rejects speed/duplex for disallowed interface types."""
+        self.add_permissions("dcim.add_interface", "dcim.view_interface", "dcim.view_device", "extras.view_status")
+
+        # LAG disallows speed/duplex
+        for field, value in (("speed", InterfaceSpeedChoices.SPEED_1G), ("duplex", InterfaceDuplexChoices.DUPLEX_FULL)):
+            with self.subTest(if_type=InterfaceTypeChoices.TYPE_LAG, field=field):
+                payload = {
+                    "device": self.devices[0].pk,
+                    "name": f"if-lag-{field}",
+                    "type": InterfaceTypeChoices.TYPE_LAG,
+                    "status": Status.objects.get_for_model(Interface).first().pk,
+                    field: value,
+                }
+                response = self.client.post(self._get_list_url(), data=payload, format="json", **self.header)
+                self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+                self.assertIn(field, response.data)
+
+        # Virtual/wireless disallow speed/duplex
+        for if_type in (InterfaceTypeChoices.TYPE_VIRTUAL, InterfaceTypeChoices.TYPE_80211AC):
+            for field, value in (
+                ("speed", InterfaceSpeedChoices.SPEED_1G),
+                ("duplex", InterfaceDuplexChoices.DUPLEX_FULL),
+            ):
+                with self.subTest(if_type=if_type, field=field):
+                    payload = {
+                        "device": self.devices[0].pk,
+                        "name": f"if-{if_type}-{field}",
+                        "type": if_type,
+                        "status": Status.objects.get_for_model(Interface).first().pk,
+                        field: value,
+                    }
+                    response = self.client.post(self._get_list_url(), data=payload, format="json", **self.header)
+                    self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+                    self.assertIn(field, response.data)
+
+        # Optical disallows duplex
+        with self.subTest(if_type=InterfaceTypeChoices.TYPE_10GE_SFP_PLUS, field="duplex"):
+            payload = {
+                "device": self.devices[0].pk,
+                "name": "if-opt-duplex",
+                "type": InterfaceTypeChoices.TYPE_10GE_SFP_PLUS,
+                "status": Status.objects.get_for_model(Interface).first().pk,
+                "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+            }
+            response = self.client.post(self._get_list_url(), data=payload, format="json", **self.header)
+            self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+            self.assertIn("duplex", response.data)
+
+    def test_update_type_to_optical_fails_when_duplex_set(self):
+        """Test that changing a copper interface with duplex set to an optical type fails."""
+        self.add_permissions("dcim.change_interface")
+        interface = self.interfaces[0]  # 1000base-t
+
+        # Ensure duplex is set on copper via API
+        response = self.client.patch(
+            self._get_detail_url(interface),
+            data={"duplex": InterfaceDuplexChoices.DUPLEX_FULL},
+            format="json",
+            **self.header,
+        )
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(response.data["duplex"]["value"], InterfaceDuplexChoices.DUPLEX_FULL)
+
+        # Attempt to change type to optical while duplex remains set
+        response = self.client.patch(
+            self._get_detail_url(interface),
+            data={"type": InterfaceTypeChoices.TYPE_10GE_SFP_PLUS},
+            format="json",
+            **self.header,
+        )
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("duplex", response.data)
+
+    def test_update_type_to_optical_succeeds_when_unsetting_duplex(self):
+        """Test that changing type with duplex set to optical while unsetting duplex in the same request succeeds."""
+        self.add_permissions("dcim.change_interface")
+        interface = self.interfaces[1]  # 1000base-t
+
+        # Ensure duplex is set on copper first
+        response = self.client.patch(
+            self._get_detail_url(interface),
+            data={"duplex": InterfaceDuplexChoices.DUPLEX_FULL},
+            format="json",
+            **self.header,
+        )
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(response.data["duplex"]["value"], InterfaceDuplexChoices.DUPLEX_FULL)
+
+        # Change to optical and unset duplex in same call
+        response = self.client.patch(
+            self._get_detail_url(interface),
+            data={"type": InterfaceTypeChoices.TYPE_10GE_SFP_PLUS, "duplex": ""},
+            format="json",
+            **self.header,
+        )
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertIsNone(response.data["duplex"])
+
 
 class FrontPortTest(Mixins.BasePortTestMixin):
     model = FrontPort
@@ -3588,6 +3774,7 @@ class DeviceTypeToSoftwareImageFileTestCase(
 
 class ControllerTestCase(APIViewTestCases.APIViewTestCase):
     model = Controller
+    choices_fields = ("capabilities",)
 
     def get_deletable_object(self):
         # This method is used in `test_recreate_object_csv`,
@@ -3647,6 +3834,7 @@ class ControllerTestCase(APIViewTestCases.APIViewTestCase):
 
 class ControllerManagedDeviceGroupTestCase(APIViewTestCases.APIViewTestCase):
     model = ControllerManagedDeviceGroup
+    choices_fields = ("capabilities",)
 
     def get_deletable_object(self):
         # This method is used in `test_recreate_object_csv`,

nautobot/dcim/tests/test_custom_validators.py

@@ -0,0 +1,229 @@
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
+from django.test import override_settings, TestCase
+
+from nautobot.core.testing.mixins import NautobotTestCaseMixin
+from nautobot.data_validation.models import RequiredValidationRule
+from nautobot.dcim.choices import DeviceUniquenessChoices
+from nautobot.dcim.models import Device, DeviceType, Location
+from nautobot.extras.models import Role, Status
+from nautobot.tenancy.models import Tenant
+
+
+class DeviceUniquenessValidatorTest(NautobotTestCaseMixin, TestCase):
+    """Tests for the DeviceUniquenessValidator custom validator."""
+
+    def setUp(self):
+        super().setUp()
+        self.device_status = Status.objects.get_for_model(Device).first()
+        self.device_type = DeviceType.objects.first()
+        self.device_role = Role.objects.get_for_model(Device).first()
+        self.location = Location.objects.first()
+        self.tenant = Tenant.objects.create(name="Tenant")
+        self.device_name = "Device"
+        self.device = Device.objects.create(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=self.location,
+            status=self.device_status,
+            tenant=self.tenant,
+        )
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+    def test_duplicate_same_location_tenant_name_fails(self):
+        """Same name, tenant, and location should raise ValidationError."""
+        dup_device = Device(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=self.location,
+            status=self.device_status,
+            tenant=self.tenant,
+        )
+        with self.assertRaises(ValidationError) as contextmanager:
+            dup_device.full_clean()
+        self.assertIn(
+            f"A device named '{self.device_name}' already exists in this location: {self.location} and tenant: {self.tenant}. ",
+            str(contextmanager.exception),
+        )
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+    def test_different_tenant_allows_duplicate_name(self):
+        """Same name and location, different tenant should be allowed."""
+        tenant = Tenant.objects.create(name="Tenant2")
+        non_dup_device = Device(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=self.location,
+            status=self.device_status,
+            tenant=tenant,
+        )
+        non_dup_device.full_clean()  # should not raise
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+    def test_different_location_allows_duplicate_name(self):
+        """Same name and tenant, different location should be allowed."""
+        location = Location.objects.last()
+        non_dup_device = Device(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=location,
+            status=self.device_status,
+            tenant=self.tenant,
+        )
+        non_dup_device.full_clean()  # should not raise
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+    def test_duplicate_name_with_null_tenant_fails(self):
+        """Duplicate name with tenant=None should raise ValidationError."""
+        Device.objects.create(
+            name="Device-2",
+            location=self.location,
+            tenant=None,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        dup = Device(
+            name="Device-2",
+            location=self.location,
+            tenant=None,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        with self.assertRaises(ValidationError) as contextmanager:
+            dup.full_clean()
+        self.assertIn(
+            f"A device named '{dup.name}' with no tenant already exists in this location: {self.location}. ",
+            str(contextmanager.exception),
+        )
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME)
+    def test_duplicate_name_globally_fails(self):
+        """Duplicate name should raise ValidationError."""
+        tenant = Tenant.objects.create(name="Tenant2")
+        location = Location.objects.last()
+        dup_device = Device(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=location,
+            status=self.device_status,
+            tenant=tenant,
+        )
+        with self.assertRaises(ValidationError) as contextmanager:
+            dup_device.full_clean()
+        self.assertIn(
+            f"At least one other device named '{dup_device.name}' already exists. ", str(contextmanager.exception)
+        )
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME)
+    def test_different_name_succeeds(self):
+        """Different name should be allowed globally."""
+        non_dup_device = Device(
+            name="Device-2",
+            device_type=self.device_type,
+            role=self.device_role,
+            location=self.location,
+            status=self.device_status,
+            tenant=self.tenant,
+        )
+        non_dup_device.full_clean()  # should not raise
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME)
+    def test_unnamed_device_allowed_if_name_not_required(self):
+        """Unnamed device allowed if DEVICE_NAME_REQUIRED is False."""
+        Device.objects.create(
+            name=None,
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        unnamed2 = Device(
+            name=None,
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        self.assertFalse(
+            RequiredValidationRule.objects.filter(
+                content_type=ContentType.objects.get_for_model(Device), field="name"
+            ).exists()
+        )
+        unnamed2.full_clean()  # should not raise
+
+    def test_unnamed_device_fails_if_name_is_required(self):
+        """Unnamed device should raise a ValidationError if DEVICE_NAME_REQUIRED is True."""
+        unnamed = Device(
+            name=None,
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        RequiredValidationRule.objects.create(content_type=ContentType.objects.get_for_model(Device), field="name")
+        with self.assertRaises(ValidationError) as contextmanager:
+            unnamed.full_clean()
+        # This error is from RequiredValidationRule
+        self.assertIn("{'name': ['This field cannot be blank.']}", str(contextmanager.exception))
+
+    def test_empty_device_fails_if_name_is_required(self):
+        """Empty name device should raise a ValidationError if DEVICE_NAME_REQUIRED is True."""
+        unnamed = Device(
+            name="",
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        RequiredValidationRule.objects.create(content_type=ContentType.objects.get_for_model(Device), field="name")
+        with self.assertRaises(ValidationError) as contextmanager:
+            unnamed.full_clean()
+        # This error is from RequiredValidationRule
+        self.assertIn("{'name': ['This field cannot be blank.']}", str(contextmanager.exception))
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NONE)
+    def test_no_uniqueness_enforced(self):
+        """Devices should not trigger validation errors when uniqueness is disabled."""
+        dup_device = Device(
+            name=self.device.name,
+            location=self.location,
+            tenant=self.tenant,
+            role=self.device_role,
+            device_type=self.device_type,
+            status=self.device_status,
+        )
+
+        # Should NOT raise any error since uniqueness enforcement is off
+        dup_device.full_clean()
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NONE)
+    def test_allow_duplicate_devices_with_empty_name_when_uniqueness_is_none(self):
+        """Allow duplicate devices with empty name when DEVICE_UNIQUENESS="none"."""
+        Device.objects.create(
+            name="",
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        empty_name = Device(
+            name="",
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        empty_name.full_clean()

nautobot/dcim/tests/test_filters.py

@@ -11,7 +11,9 @@ from nautobot.dcim.choices import (
     CableLengthUnitChoices,
     CableTypeChoices,
     DeviceFaceChoices,
+    InterfaceDuplexChoices,
     InterfaceModeChoices,
+    InterfaceSpeedChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
     PowerFeedBreakerPoleChoices,
@@ -124,9 +126,10 @@ from nautobot.dcim.models import (
     VirtualChassis,
     VirtualDeviceContext,
 )
-from nautobot.extras.filters.mixins import RoleFilter, StatusFilter
+from nautobot.extras.filter_mixins import RoleFilter, StatusFilter
 from nautobot.extras.models import ExternalIntegration, Role, SecretsGroup, Status, Tag
-from nautobot.ipam.models import IPAddress, Namespace, Prefix, Service, VLAN, VLANGroup
+from nautobot.extras.tests.test_customfields_filters import CustomFieldsFilters
+from nautobot.ipam.models import IPAddress, Namespace, Prefix, Service, VLAN, VLANGroup, VRF, VRFDeviceAssignment
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import Cluster, ClusterType, VirtualMachine
 from nautobot.wireless.models import RadioProfile, WirelessNetwork
@@ -1039,7 +1042,9 @@ class PathEndpointModelTestMixin:
             )
 
 
-class LocationTypeFilterSetTestCase(FilterTestCases.FilterTestCase):
+class LocationTypeFilterSetTestCase(
+    FilterTestCases.FilterTestCase, CustomFieldsFilters.CustomFieldsFilterSetTestCaseMixin
+):
     queryset = LocationType.objects.all()
     filterset = LocationTypeFilterSet
     generic_filter_tests = [
@@ -1076,7 +1081,10 @@ class LocationTypeFilterSetTestCase(FilterTestCases.FilterTestCase):
             )
 
 
-class LocationFilterSetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
+class LocationFilterSetTestCase(
+    FilterTestCases.FilterTestCase,
+    FilterTestCases.TenancyFilterTestCaseMixin,
+):
     queryset = Location.objects.all()
     filterset = LocationFilterSet
     tenancy_related_name = "locations"
@@ -1149,7 +1157,7 @@ class LocationFilterSetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.
         )
 
 
-class RackGroupTestCase(FilterTestCases.FilterTestCase):
+class RackGroupTestCase(FilterTestCases.FilterTestCase, CustomFieldsFilters.CustomFieldsFilterSetTestCaseMixin):
     queryset = RackGroup.objects.all()
     filterset = RackGroupFilterSet
     generic_filter_tests = [
@@ -1357,7 +1365,7 @@ class RackReservationTestCase(FilterTestCases.FilterTestCase, FilterTestCases.Te
         common_test_data(cls)
 
 
-class ManufacturerTestCase(FilterTestCases.FilterTestCase):
+class ManufacturerTestCase(FilterTestCases.FilterTestCase, CustomFieldsFilters.CustomFieldsFilterSetTestCaseMixin):
     queryset = Manufacturer.objects.all()
     filterset = ManufacturerFilterSet
     generic_filter_tests = [
@@ -1393,7 +1401,7 @@ class DeviceFamilyTestCase(FilterTestCases.FilterTestCase):
     ]
 
 
-class DeviceTypeTestCase(FilterTestCases.FilterTestCase):
+class DeviceTypeTestCase(FilterTestCases.FilterTestCase, CustomFieldsFilters.CustomFieldsFilterSetTestCaseMixin):
     queryset = DeviceType.objects.all()
     filterset = DeviceTypeFilterSet
     generic_filter_tests = [
@@ -1822,6 +1830,8 @@ class DeviceTestCase(
         ("vc_priority",),
         ("virtual_chassis", "virtual_chassis__id"),
         ("virtual_chassis", "virtual_chassis__name"),
+        ("vrfs", "vrfs__id"),
+        ("vrfs", "vrfs__rd"),
         ("wireless_networks", "controller_managed_device_group__wireless_networks__id"),
         ("wireless_networks", "controller_managed_device_group__wireless_networks__name"),
     ]
@@ -1928,6 +1938,14 @@ class DeviceTestCase(
         virtual_chassis_2 = VirtualChassis.objects.create(name="vc2", master=devices[2])
         Device.objects.filter(pk=devices[2].pk).update(virtual_chassis=virtual_chassis_2, vc_position=1, vc_priority=1)
 
+        # VRF assignment for filtering
+        vrfs = (
+            VRF.objects.create(name="VRF 1", rd="1:1"),
+            VRF.objects.create(name="VRF 2", rd="1:2"),
+        )
+        VRFDeviceAssignment.objects.create(device=devices[0], vrf=vrfs[0])
+        VRFDeviceAssignment.objects.create(device=devices[1], vrf=vrfs[1])
+
     def test_special_filters(self):
         # TODO: Not a generic_filter_test because this is a single-value filter
         with self.subTest("face"):
@@ -2247,6 +2265,8 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         ("name",),
         ("parent_interface", "parent_interface__id"),
         ("parent_interface", "parent_interface__name"),
+        ("speed",),
+        ("duplex",),
         ("role", "role__id"),
         ("role", "role__name"),
         ("status", "status__id"),
@@ -2326,6 +2346,8 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
             mtu=100,
             status=interface_statuses[0],
             untagged_vlan=vlans[0],
+            speed=InterfaceSpeedChoices.SPEED_1G,
+            duplex=InterfaceDuplexChoices.DUPLEX_FULL,
         )
 
         Interface.objects.filter(pk=cabled_interfaces[1].pk).update(
@@ -2335,6 +2357,8 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
             mtu=200,
             status=interface_statuses[3],
             untagged_vlan=vlans[1],
+            speed=InterfaceSpeedChoices.SPEED_10G,
+            duplex=InterfaceDuplexChoices.DUPLEX_HALF,
         )
 
         Interface.objects.filter(pk=cabled_interfaces[2].pk).update(
@@ -2348,6 +2372,16 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         for interface in cabled_interfaces:
             interface.refresh_from_db()
 
+        # Additional optical interface for speed filtering (no duplex)
+        Interface.objects.create(
+            device=devices[2],
+            name="Filter Optical IF",
+            type=InterfaceTypeChoices.TYPE_10GE_SFP_PLUS,
+            status=interface_statuses[0],
+            speed=InterfaceSpeedChoices.SPEED_10G,
+            duplex="",
+        )
+
         cable_statuses = Status.objects.get_for_model(Cable)
         connected_status = cable_statuses.get(name="Connected")
 
@@ -2543,6 +2577,20 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         params = {"mode": [InterfaceModeChoices.MODE_ACCESS]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
+    def test_speed_multi(self):
+        params = {"speed": [InterfaceSpeedChoices.SPEED_1G, InterfaceSpeedChoices.SPEED_10G]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(speed__in=params["speed"]),
+        )
+
+    def test_speed_and_duplex(self):
+        params = {"speed": [InterfaceSpeedChoices.SPEED_10G], "duplex": [InterfaceDuplexChoices.DUPLEX_HALF]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(speed__in=params["speed"], duplex__in=params["duplex"]),
+        )
+
     def test_device_with_common_vc(self):
         """Assert only interfaces belonging to devices with common VC are returned"""
         device_type = DeviceType.objects.first()