nautobot 2.4.21__py3-none-any.whl → 2.4.22__py3-none-any.whl

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()
@@ -135,3 +151,30 @@ class GraphQLTestCase(TestCase):
             self.assertFalse(resp["data"].get("error"))
             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).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            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).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            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).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            names = {i["name"] for i in resp["data"]["interfaces"]}
+            self.assertIn("eth2", names)
+            self.assertNotIn("eth3", names)

nautobot/dcim/tests/test_models.py

@@ -16,7 +16,9 @@ from nautobot.dcim.choices import (
     CableTypeChoices,
     ConsolePortTypeChoices,
     DeviceFaceChoices,
+    InterfaceDuplexChoices,
     InterfaceModeChoices,
+    InterfaceSpeedChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
     PowerFeedBreakerPoleChoices,
@@ -724,6 +726,101 @@ class InterfaceTemplateTestCase(ModularDeviceComponentTemplateTestCaseMixin, Tes
         first_status = Status.objects.get_for_model(Interface).first()
         self.assertIsNotNone(device_2.interfaces.get(name="Test_Template_1").status, first_status)
 
+    def test_speed_disallowed_for_lag_virtual_wireless(self):
+        """speed must be None for LAG, virtual, and wireless templates."""
+        manufacturer = Manufacturer.objects.first()
+        device_type = DeviceType.objects.create(manufacturer=manufacturer, model="SpeedGuard 1000")
+
+        for if_type in (
+            InterfaceTypeChoices.TYPE_LAG,
+            InterfaceTypeChoices.TYPE_VIRTUAL,
+            InterfaceTypeChoices.TYPE_80211N,
+        ):
+            with self.subTest(if_type=if_type):
+                with self.assertRaises(ValidationError) as cm:
+                    InterfaceTemplate(
+                        device_type=device_type,
+                        name=f"bad-{if_type}",
+                        type=if_type,
+                        speed=InterfaceSpeedChoices.SPEED_1G,
+                    ).full_clean()
+                self.assertIn("Speed is not applicable to this interface type.", str(cm.exception))
+
+    def test_duplex_disallowed_for_lag_virtual_wireless(self):
+        """duplex must be blank for LAG, virtual, and wireless templates."""
+        manufacturer = Manufacturer.objects.first()
+        device_type = DeviceType.objects.create(manufacturer=manufacturer, model="DuplexGuard 1000")
+
+        for itype in (
+            InterfaceTypeChoices.TYPE_LAG,
+            InterfaceTypeChoices.TYPE_VIRTUAL,
+            InterfaceTypeChoices.TYPE_80211N,
+        ):
+            with self.assertRaises(ValidationError):
+                InterfaceTemplate(
+                    device_type=device_type,
+                    name=f"bad-{itype}",
+                    type=itype,
+                    duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+                ).full_clean()
+
+    def test_duplex_disallowed_for_non_base_t(self):
+        """duplex must be blank for non-BASE-T physical types (e.g., SFP)."""
+        manufacturer = Manufacturer.objects.first()
+        device_type = DeviceType.objects.create(manufacturer=manufacturer, model="SfpGuard 1000")
+
+        with self.assertRaises(ValidationError) as cm:
+            InterfaceTemplate(
+                device_type=device_type,
+                name="sfp0",
+                type=InterfaceTypeChoices.TYPE_1GE_SFP,
+                duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+            ).full_clean()
+        self.assertIn("Duplex is only applicable to copper twisted-pair interfaces.", str(cm.exception))
+
+    def test_duplex_and_speed_allowed_for_base_t(self):
+        """BASE-T physical types accept duplex and speed values."""
+        manufacturer = Manufacturer.objects.first()
+        device_type = DeviceType.objects.create(manufacturer=manufacturer, model="CopperOK 1000")
+
+        tmpl = InterfaceTemplate(
+            device_type=device_type,
+            name="eth0",
+            type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+            speed=InterfaceSpeedChoices.SPEED_1G,
+            duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+        )
+        tmpl.full_clean()  # should not raise
+
+    def test_instantiation_propagates_speed_and_duplex(self):
+        """Interface created from template inherits speed and duplex."""
+        statuses = Status.objects.get_for_model(Device)
+        location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        manufacturer = Manufacturer.objects.first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device_type = DeviceType.objects.create(manufacturer=manufacturer, model="Propagate 2000")
+
+        InterfaceTemplate.objects.create(
+            device_type=device_type,
+            name="EthX",
+            type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+            mgmt_only=False,
+            speed=InterfaceSpeedChoices.SPEED_1G,
+            duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+        )
+
+        device = Device.objects.create(
+            device_type=device_type,
+            role=device_role,
+            status=statuses[0],
+            name="Device-Prop",
+            location=location,
+        )
+
+        iface = device.interfaces.get(name="EthX")
+        self.assertEqual(iface.speed, InterfaceSpeedChoices.SPEED_1G)
+        self.assertEqual(iface.duplex, InterfaceDuplexChoices.DUPLEX_FULL)
+
 
 class InterfaceRedundancyGroupTestCase(ModelTestCases.BaseModelTestCase):
     model = InterfaceRedundancyGroup
@@ -2695,6 +2792,7 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
             name="VLAN 1", vid=100, location=location, status=vlan_status, vlan_group=vlan_group
         )
         status = Status.objects.get_for_model(Device).first()
+        cls.intf_status = Status.objects.get_for_model(Interface).first()
         cls.device = Device.objects.create(
             name="Device 1",
             device_type=devicetype,
@@ -2924,6 +3022,173 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.device.refresh_from_db()
         self.assertEqual(self.device.primary_ip6, None)
 
+    def _assert_invalid_speed_duplex(self, if_type, speed=None, duplex="", expected_error=""):
+        iface = Interface(
+            device=self.device,
+            name=f"test-{if_type}",
+            type=if_type,
+            status=self.intf_status,
+            speed=speed,
+            duplex=duplex,
+        )
+        with self.assertRaises(ValidationError) as cm:
+            iface.full_clean()
+        self.assertIn(expected_error, str(cm.exception))
+
+    def test_disallowed_speed_and_duplex_matrix(self):
+        """Test that interface types with no speed or duplex disallow those settings."""
+        test_cases = [
+            # LAG
+            (
+                InterfaceTypeChoices.TYPE_LAG,
+                InterfaceSpeedChoices.SPEED_1M,
+                None,
+                "Speed is not applicable to this interface type.",
+            ),
+            (
+                InterfaceTypeChoices.TYPE_LAG,
+                None,
+                InterfaceDuplexChoices.DUPLEX_FULL,
+                "Duplex is not applicable to this interface type.",
+            ),
+            # Virtual
+            (
+                InterfaceTypeChoices.TYPE_VIRTUAL,
+                InterfaceSpeedChoices.SPEED_1M,
+                None,
+                "Speed is not applicable to this interface type.",
+            ),
+            (
+                InterfaceTypeChoices.TYPE_VIRTUAL,
+                None,
+                InterfaceDuplexChoices.DUPLEX_FULL,
+                "Duplex is not applicable to this interface type.",
+            ),
+            # Wireless
+            (
+                InterfaceTypeChoices.TYPE_80211AC,
+                InterfaceSpeedChoices.SPEED_1M,
+                None,
+                "Speed is not applicable to this interface type.",
+            ),
+            (
+                InterfaceTypeChoices.TYPE_80211AC,
+                None,
+                InterfaceDuplexChoices.DUPLEX_FULL,
+                "Duplex is not applicable to this interface type.",
+            ),
+            # Copper (negative speed is invalid)
+            (InterfaceTypeChoices.TYPE_1GE_FIXED, -100, None, "Ensure this value is greater than or equal to 0."),
+            # Copper (speed as a string is invalid)
+            (InterfaceTypeChoices.TYPE_1GE_FIXED, "100 Mbps", None, "value must be an integer."),
+            # Copper (invalid duplex is invalid)
+            (
+                InterfaceTypeChoices.TYPE_1GE_FIXED,
+                InterfaceSpeedChoices.SPEED_1M,
+                "invalid",
+                "Value 'invalid' is not a valid choice.",
+            ),
+            # Optical (no duplex allowed)
+            (
+                InterfaceTypeChoices.TYPE_10GE_SFP_PLUS,
+                InterfaceSpeedChoices.SPEED_1M,
+                InterfaceDuplexChoices.DUPLEX_FULL,
+                "Duplex is only applicable to copper twisted-pair interfaces.",
+            ),
+        ]
+        for if_type, speed, duplex, expected_error in test_cases:
+            with self.subTest(f"{if_type} with speed={speed} and duplex={duplex}"):
+                self._assert_invalid_speed_duplex(if_type, speed, duplex, expected_error)
+
+    def test_copper_allows_duplex_and_non_negative_speed(self):
+        """Test that copper interfaces allow duplex and non-negative speed."""
+        iface = Interface(
+            device=self.device,
+            name="eth1",
+            type=InterfaceTypeChoices.TYPE_1GE_FIXED,  # 1000BASE-T
+            status=self.intf_status,
+            speed=InterfaceSpeedChoices.SPEED_1G,
+            duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+        )
+        # Should not raise
+        iface.full_clean()
+
+        iface.speed = 0
+        iface.full_clean()
+
+    def test_lag_allows_no_speed_or_duplex(self):
+        """Test that LAG interfaces pass validation when speed and duplex are not set."""
+        iface = Interface(
+            device=self.device,
+            name="Port-Channel1",
+            type=InterfaceTypeChoices.TYPE_LAG,
+            status=self.intf_status,
+        )
+        # Should not raise when speed and duplex are not set
+        iface.full_clean()
+
+    def test_optical_disallows_duplex_allows_speed(self):
+        """Test that optical interfaces do not allow duplex and allow positive speed."""
+        # Duplex set should error
+        iface_bad = Interface(
+            device=self.device,
+            name="xe0",
+            type=InterfaceTypeChoices.TYPE_10GE_SFP_PLUS,
+            status=self.intf_status,
+            duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+        )
+        with self.assertRaises(ValidationError) as cm:
+            iface_bad.full_clean()
+        self.assertIn("Duplex is only applicable to copper twisted-pair interfaces.", str(cm.exception))
+
+        # Speed positive should pass
+        iface_ok = Interface(
+            device=self.device,
+            name="xe1",
+            type=InterfaceTypeChoices.TYPE_10GE_SFP_PLUS,
+            status=self.intf_status,
+            speed=InterfaceSpeedChoices.SPEED_10G,
+        )
+        iface_ok.full_clean()
+
+    def test_changing_copper_interface_with_speed_and_duplex_to_optical_fails(self):
+        """Test that changing a copper interface with speed and duplex to an optical interface fails."""
+
+        with self.subTest("speed"):
+            iface = Interface(
+                device=self.device,
+                name="eth3",
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                status=self.intf_status,
+                speed=InterfaceSpeedChoices.SPEED_1G,
+            )
+            iface.full_clean()
+
+            iface.type = InterfaceTypeChoices.TYPE_LAG
+            with self.assertRaises(ValidationError) as cm:
+                iface.full_clean()
+            self.assertIn("Speed is not applicable to this interface type.", str(cm.exception))
+
+        with self.subTest("duplex"):
+            iface = Interface(
+                device=self.device,
+                name="eth3",
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                status=self.intf_status,
+                duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+            )
+            iface.full_clean()
+
+            iface.type = InterfaceTypeChoices.TYPE_10GE_SFP_PLUS
+            with self.assertRaises(ValidationError) as cm:
+                iface.full_clean()
+            self.assertIn("Duplex is only applicable to copper twisted-pair interfaces.", str(cm.exception))
+
+        iface.type = InterfaceTypeChoices.TYPE_10GE_SFP_PLUS
+        with self.assertRaises(ValidationError) as cm:
+            iface.full_clean()
+        self.assertIn("Duplex is only applicable to copper twisted-pair interfaces.", str(cm.exception))
+
 
 class SoftwareImageFileTestCase(ModelTestCases.BaseModelTestCase):
     model = SoftwareImageFile

nautobot/dcim/tests/test_tables.py

@@ -0,0 +1,160 @@
+from django.test import TestCase
+
+from nautobot.dcim.choices import InterfaceDuplexChoices, InterfaceSpeedChoices, InterfaceTypeChoices
+from nautobot.dcim.models import Device, DeviceType, Interface, InterfaceTemplate, Location, LocationType, Manufacturer
+from nautobot.dcim.tables.devices import DeviceModuleInterfaceTable, InterfaceTable
+from nautobot.dcim.tables.devicetypes import InterfaceTemplateTable
+from nautobot.extras.models import Role, Status
+
+
+class InterfaceTableRenderMixin:
+    """Mixin for testing render_speed methods on interface tables."""
+
+    table_class = None
+
+    @classmethod
+    def setUpTestData(cls):
+        manufacturer = Manufacturer.objects.create(name="Test Manufacturer")
+        device_type = DeviceType.objects.create(manufacturer=manufacturer, model="Test Device Type")
+        device_role = Role.objects.get_for_model(Device).first()
+        location_type = LocationType.objects.get(name="Campus")
+        location = Location.objects.filter(location_type=location_type).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        cls.interface_status = Status.objects.get_for_model(Interface).first()
+
+        cls.device = Device.objects.create(
+            name="Test Device",
+            device_type=device_type,
+            role=device_role,
+            location=location,
+            status=device_status,
+        )
+
+    def test_render_speed_duplex_with_value(self):
+        """Test that the table renders humanized speed values."""
+        interface = Interface.objects.create(
+            device=self.device,
+            name="eth0",
+            type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+            status=self.interface_status,
+            speed=InterfaceSpeedChoices.SPEED_1G,
+            duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+        )
+
+        queryset = Interface.objects.filter(pk=interface.pk)
+        table = self.table_class(queryset)  # pylint: disable=not-callable
+        bound_row = table.rows[0]
+        rendered_speed = bound_row.get_cell("speed")
+        rendered_duplex = bound_row.get_cell("duplex")
+
+        self.assertEqual(rendered_speed, "1 Gbps")
+        self.assertEqual(rendered_duplex, "Full")
+
+    def test_render_speed_duplex_with_none(self):
+        """Test that the table handles None speed value and renders an emdash."""
+        emdash = "\u2014"
+        interface = Interface.objects.create(
+            device=self.device,
+            name="eth1",
+            type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+            status=self.interface_status,
+            speed=None,
+        )
+
+        queryset = Interface.objects.filter(pk=interface.pk)
+        table = self.table_class(queryset)  # pylint: disable=not-callable
+        bound_row = table.rows[0]
+        rendered_speed = bound_row.get_cell("speed")
+        rendered_duplex = bound_row.get_cell("duplex")
+
+        self.assertEqual(rendered_speed, emdash)
+        self.assertEqual(rendered_duplex, emdash)
+
+    def test_render_speed_various(self):
+        """Test that the table correctly humanizes various speed values."""
+        # Test all speed choices defined in InterfaceSpeedChoices
+        for speed_value, expected_output in InterfaceSpeedChoices.CHOICES:
+            with self.subTest(speed_value=speed_value, expected=expected_output):
+                interface = Interface.objects.create(
+                    device=self.device,
+                    name=f"eth-{speed_value}",
+                    type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                    status=self.interface_status,
+                    speed=speed_value,
+                )
+
+                queryset = Interface.objects.filter(pk=interface.pk)
+                table = self.table_class(queryset)  # pylint: disable=not-callable
+                bound_row = table.rows[0]
+                rendered_speed = bound_row.get_cell("speed")
+
+                self.assertEqual(rendered_speed, expected_output)
+
+    def test_render_duplex_various(self):
+        """Test that the table correctly renders various duplex values."""
+        for duplex_value, expected_output in InterfaceDuplexChoices.CHOICES:
+            with self.subTest(duplex_value=duplex_value, expected=expected_output):
+                interface = Interface.objects.create(
+                    device=self.device,
+                    name=f"eth-{duplex_value}",
+                    type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                    status=self.interface_status,
+                    duplex=duplex_value,
+                )
+
+                queryset = Interface.objects.filter(pk=interface.pk)
+                table = self.table_class(queryset)  # pylint: disable=not-callable
+                bound_row = table.rows[0]
+                rendered_duplex = bound_row.get_cell("duplex")
+
+                self.assertEqual(rendered_duplex, expected_output)
+
+
+class InterfaceTableTestCase(InterfaceTableRenderMixin, TestCase):
+    """Test cases for InterfaceTable."""
+
+    table_class = InterfaceTable
+
+
+class DeviceModuleInterfaceTableTestCase(InterfaceTableRenderMixin, TestCase):
+    """Test cases for DeviceModuleInterfaceTable."""
+
+    table_class = DeviceModuleInterfaceTable
+
+
+class InterfaceTemplateTableTestCase(TestCase):
+    """Render tests for InterfaceTemplateTable speed/duplex columns."""
+
+    @classmethod
+    def setUpTestData(cls):
+        manufacturer = Manufacturer.objects.create(name="Test Manuf Tmpl")
+        cls.device_type = DeviceType.objects.create(manufacturer=manufacturer, model="DT-Tmpl")
+
+    def test_render_speed_duplex_with_value(self):
+        interface_template = InterfaceTemplate.objects.create(
+            device_type=self.device_type,
+            name="tmpl-eth0",
+            type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+            speed=InterfaceSpeedChoices.SPEED_1G,
+            duplex=InterfaceDuplexChoices.DUPLEX_FULL,
+        )
+        table = InterfaceTemplateTable(InterfaceTemplate.objects.filter(pk=interface_template.pk))
+        bound_row = table.rows[0]
+        rendered_speed = bound_row.get_cell("speed")  # pylint: disable=no-member
+        rendered_duplex = bound_row.get_cell("duplex")  # pylint: disable=no-member
+        self.assertEqual(rendered_speed, "1 Gbps")
+        self.assertEqual(rendered_duplex, "Full")
+
+    def test_render_speed_duplex_with_none(self):
+        emdash = "\u2014"
+        interface_template = InterfaceTemplate.objects.create(
+            device_type=self.device_type,
+            name="tmpl-eth1",
+            type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+        )
+        table = InterfaceTemplateTable(InterfaceTemplate.objects.filter(pk=interface_template.pk))
+        bound_row = table.rows[0]
+        rendered_speed = bound_row.get_cell("speed")  # pylint: disable=no-member
+        rendered_duplex = bound_row.get_cell("duplex")  # pylint: disable=no-member
+        self.assertEqual(rendered_speed, emdash)
+        self.assertEqual(rendered_duplex, emdash)

nautobot/dcim/tests/test_views.py

@@ -30,6 +30,7 @@ from nautobot.dcim.choices import (
     ConsolePortTypeChoices,
     DeviceFaceChoices,
     DeviceRedundancyGroupFailoverStrategyChoices,
+    InterfaceDuplexChoices,
     InterfaceModeChoices,
     InterfaceRedundancyGroupProtocolChoices,
     InterfaceTypeChoices,
@@ -1837,6 +1838,68 @@ class InterfaceTemplateTestCase(ViewTestCases.DeviceComponentTemplateViewTestCas
             "description": "new test description",
         }
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_create_base_t_with_speed_and_duplex(self):
+        self.add_permissions("dcim.add_interfacetemplate", "dcim.view_devicetype")
+        url = reverse("dcim:interfacetemplate_add")
+        dt = DeviceType.objects.first()
+        data = {
+            "device_type": dt.pk,
+            "name_pattern": "Eth-View-1",
+            "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+            "mgmt_only": False,
+            "speed": 1_000_000,
+            "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+            "_create": True,
+        }
+        response = self.client.post(url, data)
+
+        # Successful create redirects (JobResult or object list)
+        self.assertIn(response.status_code, (302, 303))
+        interface_template = InterfaceTemplate.objects.get(name="Eth-View-1")
+        self.assertEqual(interface_template.speed, 1_000_000)
+        self.assertEqual(interface_template.duplex, InterfaceDuplexChoices.DUPLEX_FULL)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_create_sfp_with_duplex_rejected(self):
+        self.add_permissions("dcim.add_interfacetemplate", "dcim.view_devicetype")
+        url = reverse("dcim:interfacetemplate_add")
+        dt = DeviceType.objects.first()
+        data = {
+            "device_type": dt.pk,
+            "name_pattern": "SFP-View-1",
+            "type": InterfaceTypeChoices.TYPE_1GE_SFP,
+            "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+            "_create": True,
+        }
+        response = self.client.post(url, data)
+        # Form error returns 200 with field error displayed
+        self.assertEqual(response.status_code, 200)
+        content = response.content.decode(response.charset)
+        self.assertIn("Duplex is only applicable to copper twisted-pair interfaces.", content)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_bulk_create_with_speed_and_duplex(self):
+        self.add_permissions("dcim.add_interfacetemplate", "dcim.view_devicetype")
+        url = reverse("dcim:interfacetemplate_add")
+        dt = DeviceType.objects.first()
+        data = {
+            "device_type": dt.pk,
+            "name_pattern": "Et[1-2]",
+            "type": InterfaceTypeChoices.TYPE_1GE_FIXED,
+            "mgmt_only": False,
+            "speed": 1_000_000,
+            "duplex": InterfaceDuplexChoices.DUPLEX_FULL,
+            "_apply": True,
+        }
+        response = self.client.post(url, data)
+        self.assertIn(response.status_code, (302, 303))
+        objs = InterfaceTemplate.objects.filter(name__in=["Et1", "Et2"]).order_by("name")
+        self.assertEqual(objs.count(), 2)
+        for obj in objs:
+            self.assertEqual(obj.speed, 1_000_000)
+            self.assertEqual(obj.duplex, InterfaceDuplexChoices.DUPLEX_FULL)
+
 
 class FrontPortTemplateTestCase(ViewTestCases.DeviceComponentTemplateViewTestCase):
     model = FrontPortTemplate
@@ -4811,7 +4874,7 @@ class ControllerTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = Controller
     filterset = ControllerFilterSet
     custom_action_required_permissions = {
-        "dcim:controller_wirelessnetworks": [
+        "dcim:controller_wireless_networks": [
             "dcim.view_controller",
             "wireless.view_controllermanageddevicegroupwirelessnetworkassignment",
         ],