nautobot 3.0.0a3__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
@@ -2170,7 +2229,7 @@ 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
     ]
@@ -2214,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(
@@ -2272,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,
@@ -2283,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,
@@ -2295,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 = {
@@ -2510,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

nautobot/dcim/tests/test_filters.py

@@ -11,7 +11,9 @@ from nautobot.dcim.choices import (
     CableLengthUnitChoices,
     CableTypeChoices,
     DeviceFaceChoices,
+    InterfaceDuplexChoices,
     InterfaceModeChoices,
+    InterfaceSpeedChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
     PowerFeedBreakerPoleChoices,
@@ -127,7 +129,7 @@ from nautobot.dcim.models import (
 from nautobot.extras.filter_mixins import RoleFilter, StatusFilter
 from nautobot.extras.models import ExternalIntegration, Role, SecretsGroup, Status, Tag
 from nautobot.extras.tests.test_customfields_filters import CustomFieldsFilters
-from nautobot.ipam.models import IPAddress, Namespace, Prefix, Service, VLAN, VLANGroup
+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
@@ -1828,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"),
     ]
@@ -1934,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"):
@@ -2253,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"),
@@ -2332,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(
@@ -2341,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(
@@ -2354,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")
 
@@ -2549,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()

nautobot/dcim/tests/test_forms.py

@@ -1,8 +1,17 @@
+from constance.test import override_config
 from django.test import TestCase
 
 from nautobot.core.testing.forms import FormTestCases
 from nautobot.core.testing.mixins import NautobotTestCaseMixin
-from nautobot.dcim.choices import DeviceFaceChoices, InterfaceModeChoices, InterfaceTypeChoices, RackWidthChoices
+from nautobot.dcim.choices import (
+    DeviceFaceChoices,
+    InterfaceDuplexChoices,
+    InterfaceModeChoices,
+    InterfaceSpeedChoices,
+    InterfaceTypeChoices,
+    RackWidthChoices,
+)
+from nautobot.dcim.constants import RACK_U_HEIGHT_DEFAULT
 from nautobot.dcim.forms import (
     DeviceFilterForm,
     DeviceForm,
@@ -327,24 +336,56 @@ class RackTestCase(TestCase):
         form = RackForm(data=data, instance=racks[0])
         self.assertTrue(form.is_valid())
 
+    def test_rack_form_initial_u_height_default(self):
+        """Test that RackForm sets initial u_height from default Constance config (42)."""
+        # Create a new form (not bound to an instance)
+        form = RackForm()
+
+        # The initial value should be 42 (default Constance config)
+        self.assertEqual(form.fields["u_height"].initial, RACK_U_HEIGHT_DEFAULT)
+
+    @override_config(RACK_DEFAULT_U_HEIGHT=48)
+    def test_rack_form_initial_u_height_custom(self):
+        """Test that RackForm sets initial u_height from custom Constance config."""
+        # Create a new form (not bound to an instance)
+        form = RackForm()
+
+        # The initial value should be 48 (from Constance config)
+        self.assertEqual(form.fields["u_height"].initial, 48)
+
+    def test_rack_form_initial_u_height_not_set_on_edit(self):
+        """Test that RackForm does NOT override u_height when editing an existing rack."""
+        location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        status = Status.objects.get(name="Active")
+
+        # Create a rack with u_height of 24
+        rack = Rack.objects.create(name="Test Rack", location=location, status=status, u_height=24)
+
+        # Create a form bound to the existing rack
+        form = RackForm(instance=rack)
+
+        # The initial value should NOT be overridden - it should use the rack's actual value
+        # (The form will show the model instance's value, not the Constance config)
+        self.assertEqual(form.initial["u_height"], 24)
+
 
 class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.device = Device.objects.first()
-        status = Status.objects.get_for_model(Interface).first()
+        cls.status = Status.objects.get_for_model(Interface).first()
         cls.interface = Interface.objects.create(
             device=cls.device,
             name="test interface form 0.0",
             type=InterfaceTypeChoices.TYPE_2GFC_SFP,
-            status=status,
+            status=cls.status,
         )
         cls.vlan = VLAN.objects.first()
         cls.data = {
             "device": cls.device.pk,
             "name": "test interface form 0.0",
             "type": InterfaceTypeChoices.TYPE_2GFC_SFP,
-            "status": status.pk,
+            "status": cls.status.pk,
             "mode": InterfaceModeChoices.MODE_TAGGED,
             "tagged_vlans": [cls.vlan.pk],
         }
@@ -394,7 +435,6 @@ class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
         Assert that untagged_vlans field dropdown are populated correctly in InterfaceForm and InterfaceBulkEditForm,
         and that the queryset is the same for both forms.
         """
-        status = Status.objects.get_for_model(Interface).first()
         location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
         devices = Device.objects.all()[:3]
         for device in devices:
@@ -405,19 +445,19 @@ class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
                 device=devices[0],
                 name="Test Interface 1",
                 type=InterfaceTypeChoices.TYPE_2GFC_SFP,
-                status=status,
+                status=self.status,
             ),
             Interface.objects.create(
                 device=devices[1],
                 name="Test Interface 2",
                 type=InterfaceTypeChoices.TYPE_LAG,
-                status=status,
+                status=self.status,
             ),
             Interface.objects.create(
                 device=devices[2],
                 name="Test Interface 3",
                 type=InterfaceTypeChoices.TYPE_100ME_FIXED,
-                status=status,
+                status=self.status,
             ),
         )
         edit_form = InterfaceForm(data=self.data, instance=interfaces[0])
@@ -429,3 +469,65 @@ class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
             edit_form.fields["untagged_vlan"].queryset,
             bulk_edit_form.fields["untagged_vlan"].queryset,
         )
+
+    def test_interface_form_fields_and_blank(self):
+        data = {
+            "device": self.device.pk,
+            "name": self.interface.name,
+            "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+            "status": self.status.pk,
+            "speed": "",  # blank should coerce to None
+            "duplex": "",  # blank allowed
+        }
+        form = InterfaceForm(data=data, instance=self.interface)
+        self.assertIn("speed", form.fields)
+        self.assertIn("duplex", form.fields)
+        self.assertTrue(form.is_valid())
+        self.assertIsNone(form.cleaned_data["speed"])  # TypedChoiceField(empty->None)
+        self.assertEqual(form.cleaned_data["duplex"], "")
+
+    def test_interface_form_speed_choice_coerces_int(self):
+        speed_choice = InterfaceSpeedChoices.SPEED_10G
+        data = {
+            "device": self.device.pk,
+            "name": self.interface.name,
+            "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+            "status": self.status.pk,
+            # Posted value is a string; TypedChoiceField should coerce to int
+            "speed": str(speed_choice),
+            "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+        }
+        form = InterfaceForm(data=data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+        self.assertIsInstance(form.cleaned_data["speed"], int)
+        self.assertEqual(form.cleaned_data["speed"], speed_choice)
+        self.assertEqual(form.cleaned_data["duplex"], InterfaceDuplexChoices.DUPLEX_FULL)
+
+    def test_interface_create_form_blank_and_choice(self):
+        # Blank speed
+        data_blank = {
+            "device": self.device.pk,
+            "name_pattern": "eth1",
+            "status": self.status.pk,
+            "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+            "speed": "",
+            "duplex": "",
+        }
+        form_blank = InterfaceCreateForm(data_blank)
+        self.assertTrue(form_blank.is_valid())
+        self.assertIsNone(form_blank.cleaned_data["speed"])  # TypedChoiceField(empty->None)
+
+        # With a specific choice
+        speed_choice = InterfaceSpeedChoices.SPEED_1G
+        data_choice = {
+            "device": self.device.pk,
+            "name_pattern": "eth2",
+            "status": self.status.pk,
+            "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+            "speed": str(speed_choice),
+            "duplex": InterfaceDuplexChoices.DUPLEX_AUTO,
+        }
+        form_choice = InterfaceCreateForm(data_choice)
+        self.assertTrue(form_choice.is_valid())
+        self.assertEqual(form_choice.cleaned_data["speed"], speed_choice)
+        self.assertEqual(form_choice.cleaned_data["duplex"], InterfaceDuplexChoices.DUPLEX_AUTO)

nautobot/dcim/tests/test_graphql.py

@@ -3,7 +3,7 @@ from django.test import override_settings
 
 from nautobot.core.graphql import execute_query
 from nautobot.core.testing import create_test_user, TestCase
-from nautobot.dcim.choices import InterfaceTypeChoices
+from nautobot.dcim.choices import InterfaceDuplexChoices, InterfaceSpeedChoices, InterfaceTypeChoices
 from nautobot.dcim.models import (
     Controller,
     Device,
@@ -52,6 +52,22 @@ class GraphQLTestCase(TestCase):
                 type=InterfaceTypeChoices.TYPE_VIRTUAL,
                 mac_address=None,
             ),
+            Interface.objects.create(
+                device=self.device,
+                name="eth2",
+                status=interface_status,
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                speed=InterfaceSpeedChoices.SPEED_1G,
+                duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+            ),
+            Interface.objects.create(
+                device=self.device,
+                name="eth3",
+                status=interface_status,
+                type=InterfaceTypeChoices.TYPE_10GE_SFP_PLUS,
+                speed=InterfaceSpeedChoices.SPEED_10G,
+                duplex="",
+            ),
         )
         for interface in self.interfaces:
             interface.validated_save()
@@ -131,3 +147,30 @@ class GraphQLTestCase(TestCase):
             self.assertIsNone(resp.errors)
             for device in resp.data["devices"]:
                 self.assertNotEqual(device["serial"], "")
+
+        with self.subTest("interface speed/duplex fields on device query"):
+            query = "query { devices { name interfaces { name speed duplex } } }"
+            resp = execute_query(query, user=self.user)
+            self.assertFalse(resp.errors)
+            interfaces = [i for d in resp.data["devices"] if d["name"] == self.device.name for i in d["interfaces"]]
+            eth2 = next(i for i in interfaces if i["name"] == "eth2")
+            eth3 = next(i for i in interfaces if i["name"] == "eth3")
+            self.assertEqual(eth2["speed"], InterfaceSpeedChoices.SPEED_1G)
+            self.assertEqual(eth2["duplex"].lower(), InterfaceDuplexChoices.DUPLEX_FULL)
+            self.assertEqual(eth3["speed"], InterfaceSpeedChoices.SPEED_10G)
+            self.assertEqual(eth3["duplex"], None)
+
+        with self.subTest("interfaces root filter by speed and duplex"):
+            query = f"query {{ interfaces(speed: {InterfaceSpeedChoices.SPEED_1G}) {{ name }} }}"
+            resp = execute_query(query, user=self.user)
+            self.assertFalse(resp.errors)
+            names = {i["name"] for i in resp.data["interfaces"]}
+            self.assertIn("eth2", names)
+            self.assertNotIn("eth3", names)
+
+            query = 'query { interfaces(duplex: ["full"]) { name } }'
+            resp = execute_query(query, user=self.user)
+            self.assertFalse(resp.errors)
+            names = {i["name"] for i in resp.data["interfaces"]}
+            self.assertIn("eth2", names)
+            self.assertNotIn("eth3", names)