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

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)

nautobot/dcim/tests/test_models.py

@@ -2,6 +2,7 @@ from decimal import Decimal
 
 from constance.test import override_config
 from django.contrib.contenttypes.models import ContentType
+from django.core.cache import caches
 from django.core.exceptions import ValidationError
 from django.db import IntegrityError
 from django.db.models import Model
@@ -16,7 +17,10 @@ from nautobot.dcim.choices import (
     CableTypeChoices,
     ConsolePortTypeChoices,
     DeviceFaceChoices,
+    DeviceUniquenessChoices,
+    InterfaceDuplexChoices,
     InterfaceModeChoices,
+    InterfaceSpeedChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
     PowerFeedBreakerPoleChoices,
@@ -725,6 +729,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
@@ -1423,6 +1522,10 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
     model = Device
 
     def setUp(self):
+        # clear Constance cache
+        cache = caches[settings.CONSTANCE_DATABASE_CACHE_BACKEND]
+        cache.clear()
+
         manufacturer = Manufacturer.objects.first()
         self.device_type = DeviceType.objects.create(
             manufacturer=manufacturer,
@@ -1532,12 +1635,25 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
 
     def test_natural_key_overrides(self):
         """Ensure that the natural-key for Device is affected by settings/Constance."""
-        with override_config(DEVICE_NAME_AS_NATURAL_KEY=True):
+        with override_config(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME):
             self.assertEqual([self.device.name], self.device.natural_key())
             # self.assertEqual(construct_composite_key([self.device.name]), self.device.composite_key)  # TODO: Revist this if we reintroduce composite keys
             self.assertEqual(self.device, Device.objects.get_by_natural_key([self.device.name]))
             # self.assertEqual(self.device, Device.objects.get(composite_key=self.device.composite_key))  # TODO: Revist this if we reintroduce composite keys
 
+        with override_config(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME):
+            self.assertEqual(
+                [self.device.name, self.device.tenant, self.device.location.name], self.device.natural_key()
+            )
+            self.assertEqual(
+                self.device,
+                Device.objects.get_by_natural_key([self.device.name, self.device.tenant, self.device.location]),
+            )
+
+        with override_config(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NONE):
+            self.assertEqual([str(self.device.pk)], self.device.natural_key())
+            self.assertEqual(self.device, Device.objects.get_by_natural_key([self.device.pk]))
+
         with override_config(LOCATION_NAME_AS_NATURAL_KEY=True):
             self.assertEqual([self.device.name, None, self.device.location.name], self.device.natural_key())
             # self.assertEqual(
@@ -2760,6 +2876,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,
@@ -2899,6 +3016,11 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.assertEqual(count, 1)
         self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ips[-1], interface=interface).count(), 1)
 
+        # add a single instance which is already there
+        count = interface.add_ip_addresses(ips[-1])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ips[-1], interface=interface).count(), 1)
+
         # add multiple instances
         count = interface.add_ip_addresses(ips[:5])
         self.assertEqual(count, 5)
@@ -2906,6 +3028,20 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         for ip in ips[:5]:
             self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, interface=interface).count(), 1)
 
+        # add multiple instances all of which are already there
+        count = interface.add_ip_addresses(ips[:5])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 6)
+        for ip in ips[:5]:
+            self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, interface=interface).count(), 1)
+
+        # add multiple IPs some of which are there
+        count = interface.add_ip_addresses(ips[3:7])
+        self.assertEqual(count, 2)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 8)
+        for ip in ips[3:7]:
+            self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, interface=interface).count(), 1)
+
     def test_remove_ip_addresses(self):
         """Test the `remove_ip_addresses` helper method on `Interface`"""
         interface = Interface.objects.create(
@@ -2928,13 +3064,28 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.assertEqual(count, 1)
         self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 9)
 
+        # remove a single instance which has already been removed
+        count = interface.remove_ip_addresses(ips[-1])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 9)
+
         # remove multiple instances
         count = interface.remove_ip_addresses(ips[:5])
         self.assertEqual(count, 5)
         self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 4)
 
+        # remove multiple instances all which have already been removed
+        count = interface.remove_ip_addresses(ips[:5])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 4)
+
+        # remove multiple instances some of which have already been removed
+        count = interface.remove_ip_addresses(ips[3:7])
+        self.assertEqual(count, 2)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 2)
+
         count = interface.remove_ip_addresses(ips)
-        self.assertEqual(count, 4)
+        self.assertEqual(count, 2)
         self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 0)
 
         # Test the pre_delete signal for IPAddressToInterface instances
@@ -2942,13 +3093,186 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.device.primary_ip4 = interface.ip_addresses.all().filter(ip_version=4).first()
         self.device.primary_ip6 = interface.ip_addresses.all().filter(ip_version=6).first()
         self.device.save()
-        interface.remove_ip_addresses(self.device.primary_ip4)
+
+        count = interface.remove_ip_addresses(self.device.primary_ip4)
+        self.assertEqual(count, 1)
         self.device.refresh_from_db()
         self.assertEqual(self.device.primary_ip4, None)
-        interface.remove_ip_addresses(self.device.primary_ip6)
+        # NOTE: This effectively tests what happens when you pass remove_ip_addresses None; it
+        # NOTE: does not remove a v6 address, because there are no v6 IPs created in this test
+        # NOTE: class.
+        count = interface.remove_ip_addresses(self.device.primary_ip6)
+        self.assertEqual(count, 0)
         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