nautobot 2.4.0b1__py3-none-any.whl → 2.4.2__py3-none-any.whl

nautobot/dcim/tests/integration/test_controller_managed_device_group.py

@@ -0,0 +1,71 @@
+from django.urls import reverse
+
+from nautobot.core.testing.integration import SeleniumTestCase
+from nautobot.extras.models import JobResult
+
+
+class ControllerManagedDeviceGroupsTestCase(SeleniumTestCase):
+    """
+    Perform set of Controller Managed Device Group tests using Selenium.
+    """
+
+    def test_controller_managed_device_groups_bulk_edit(self):
+        """
+        This test goes through the process of creating a Controller Managed Device Group and performing bulk edit.
+        """
+        self.user.is_superuser = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+
+        # Create LocationType
+        self.click_navbar_entry("Organization", "Location Types")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:locationtype_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:locationtype_add"))
+        self.fill_select2_multiselect_field("content_types", "dcim | controller")
+        self.browser.fill("name", "Test Location Type 1")
+        self.click_edit_form_create_button()
+
+        # Create Location
+        self.click_navbar_entry("Organization", "Locations")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:location_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:location_add"))
+        self.fill_select2_field("location_type", "Test Location Type 1")
+        self.fill_select2_field("status", "")  # pick first status
+        self.browser.fill("name", "Test Location 1")
+        self.click_edit_form_create_button()
+
+        # Create Controller
+        self.click_navbar_entry("Devices", "Controllers")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:controller_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:controller_add"))
+        self.browser.fill("name", "Test Controller Integration Test 1")
+        self.fill_select2_field("location", "Test Location 1")
+        self.fill_select2_field("status", "")  # pick first status
+        self.click_edit_form_create_button()
+
+        # Create Controller Managed Device Group
+        self.click_navbar_entry("Devices", "Device Groups")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:controllermanageddevicegroup_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:controllermanageddevicegroup_add"))
+        self.browser.fill("name", "Test Controller Managed Device Group Integration Test 1")
+        self.fill_select2_field("controller", "Test Controller Integration Test 1")
+        self.click_edit_form_create_button()
+
+        # Test bulk edit
+        self.click_navbar_entry("Devices", "Device Groups")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:controllermanageddevicegroup_list"))
+        self.browser.find_by_xpath("//input[@name='pk']").click()
+        bulk_edit_url = reverse("dcim:controllermanageddevicegroup_bulk_edit")
+        self.browser.find_by_xpath(f"//button[@formaction='{bulk_edit_url}']").click()
+
+        # Submit bulk edit form without any changes
+        self.browser.find_by_xpath("//button[@name='_apply']", wait_time=5).click()
+
+        job_result = JobResult.objects.filter(name="Bulk Edit Objects").first()
+        self.assertEqual(
+            self.browser.url, self.live_server_url + reverse("extras:jobresult", args=[job_result.pk]) + "?tab=main"
+        )

nautobot/dcim/tests/integration/test_device_bulk_operations.py

@@ -0,0 +1,30 @@
+import uuid
+
+from nautobot.core.testing.integration import (
+    BulkOperationsTestCases,
+)
+from nautobot.dcim.models import Device
+from nautobot.extras.tests.integration import create_test_device
+
+
+class DeviceBulkOperationsTestCase(BulkOperationsTestCases.BulkOperationsTestCase):
+    """
+    Test devices bulk edit / delete operations.
+    """
+
+    model_menu_path = ("Devices", "Devices")
+    model_base_viewname = "dcim:device"
+    model_edit_data = {"serial": "Test serial"}
+    model_filter_by = {"location": "Test Location 2"}
+    model_class = Device
+
+    def setup_items(self):
+        Device.objects.all().delete()
+        test_uuid = str(uuid.uuid4())
+
+        # Create device for test
+        create_test_device("Test Device Integration Test 1", test_uuid=test_uuid)
+        create_test_device("Test Device Integration Test 2", test_uuid=test_uuid)
+        create_test_device("Test Device Integration Test 3", test_uuid=test_uuid)
+        create_test_device("Test Device Integration Test 4", "Test Location 2", test_uuid=test_uuid)
+        create_test_device("Test Device Integration Test 5", "Test Location 2", test_uuid=test_uuid)

nautobot/dcim/tests/integration/test_location_bulk_operations.py

@@ -0,0 +1,43 @@
+from django.contrib.contenttypes.models import ContentType
+
+from nautobot.core.testing.integration import (
+    BulkOperationsTestCases,
+)
+from nautobot.dcim.models import Device, Location, LocationType
+from nautobot.extras.models import Status
+
+
+class LocationBulkOperationsTestCase(BulkOperationsTestCases.BulkOperationsTestCase):
+    """
+    Test locations bulk edit / delete operations.
+    """
+
+    model_menu_path = ("Organization", "Locations")
+    model_base_viewname = "dcim:location"
+    model_edit_data = {"description": "Test description"}
+    model_filter_by = {"location_type": "External"}
+    model_class = Location
+
+    def setup_items(self):
+        Location.objects.all().delete()
+
+        # Create locations for test
+        self.create_location("Test Location Integration Test 1")
+        self.create_location("Test Location Integration Test 2")
+        self.create_location("Test Location Integration Test 3")
+        self.create_location("Test Location Integration Test 4", "External")
+        self.create_location("Test Location Integration Test 5", "External")
+
+    @staticmethod
+    def create_location(location_name, location_type="Internal"):
+        location_type, location_type_created = LocationType.objects.get_or_create(name=location_type)
+        if location_type_created:
+            location_type.content_types.add(ContentType.objects.get_for_model(Device))
+            location_type.save()
+
+        location_status = Status.objects.get_for_model(Location).first()
+        Location.objects.get_or_create(
+            name=location_name,
+            status=location_status,
+            location_type=location_type,
+        )

nautobot/dcim/tests/test_api.py

@@ -1469,11 +1469,24 @@ class DeviceTest(APIViewTestCases.APIViewTestCase):
             SecretsGroup.objects.create(name="Secrets Group 2"),
         )
 
-        device_type = DeviceType.objects.filter(software_image_files__isnull=False).first()
+        device_type = DeviceType.objects.first()
         device_role = Role.objects.get_for_model(Device).first()
 
-        software_version = SoftwareVersion.objects.filter(software_image_files__device_types=device_type).first()
-        software_image_files = SoftwareImageFile.objects.exclude(software_version=software_version)[:2]
+        software_version = SoftwareVersion.objects.first()
+        software_image_files = (
+            SoftwareImageFile.objects.create(
+                status=Status.objects.get_for_model(SoftwareImageFile).first(),
+                software_version=software_version,
+                image_file_name="test_software_image_file_1.bin",
+            ),
+            SoftwareImageFile.objects.create(
+                status=Status.objects.get_for_model(SoftwareImageFile).last(),
+                software_version=software_version,
+                image_file_name="test_software_image_file_2.bin",
+            ),
+        )
+        for software_image_file in software_image_files:
+            software_image_file.device_types.add(device_type)
 
         Device.objects.create(
             device_type=device_type,
@@ -3353,7 +3366,6 @@ class ControllerTestCase(APIViewTestCases.APIViewTestCase):
                 "status": statuses[1].pk,
                 "role": roles[1].pk,
                 "location": locations[1].pk,
-                "capabilities": [],
             },
             {
                 "name": "Controller 3",
@@ -3389,7 +3401,6 @@ class ControllerManagedDeviceGroupTestCase(APIViewTestCases.APIViewTestCase):
                 "name": "ControllerManagedDeviceGroup 2",
                 "controller": controllers[1].pk,
                 "weight": 150,
-                "capabilities": [],
             },
             {
                 "name": "ControllerManagedDeviceGroup 3",

nautobot/dcim/tests/test_filters.py

@@ -1,3 +1,4 @@
+# pylint: disable=no-member  # it doesn't recognize the class attributes assigned in common_test_data()
 import uuid
 
 from django.contrib.auth import get_user_model
@@ -1691,6 +1692,7 @@ class DeviceTestCase(
         ("front_ports", "front_ports__id"),
         ("interfaces", "interfaces__id"),
         ("interfaces", "interfaces__name"),
+        ("ip_addresses", "interfaces__ip_addresses__id"),
         ("mac_address", "interfaces__mac_address"),
         ("manufacturer", "device_type__manufacturer__id"),
         ("manufacturer", "device_type__manufacturer__name"),
@@ -1876,6 +1878,14 @@ class DeviceTestCase(
                 Device.objects.filter(primary_ip4__isnull=True, primary_ip6__isnull=True),
             )
 
+    def test_ip_addresses(self):
+        addresses = list(IPAddress.objects.filter(interfaces__isnull=False)[:2])
+        params = {"ip_addresses": [addresses[0].address, addresses[1].id]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(interfaces__ip_addresses__in=addresses).distinct(),
+        )
+
     def test_virtual_chassis_member(self):
         # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
         with self.subTest():
@@ -2131,6 +2141,7 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         ("child_interfaces", "child_interfaces__name"),
         ("description",),
         # ("device", "device__id"),  # TODO - InterfaceFilterSet overrides device as a MultiValueCharFilter on name only
+        ("ip_addresses", "ip_addresses__id"),
         ("label",),
         ("lag", "lag__id"),
         ("lag", "lag__name"),
@@ -2378,6 +2389,20 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
             status=interface_statuses[3],
         )
 
+        ipaddr_status = Status.objects.get_for_model(IPAddress).first()
+        prefix_status = Status.objects.get_for_model(Prefix).first()
+        namespace = Namespace.objects.first()
+        Prefix.objects.create(prefix="192.0.2.0/24", namespace=namespace, status=prefix_status)
+        Prefix.objects.create(prefix="2600::/64", namespace=namespace, status=prefix_status)
+        ipaddresses = (
+            IPAddress.objects.create(address="192.0.2.1/24", namespace=namespace, status=ipaddr_status),
+            IPAddress.objects.create(address="192.0.2.2/24", namespace=namespace, status=ipaddr_status),
+            IPAddress.objects.create(address="2600::1/120", namespace=namespace, status=ipaddr_status),
+            IPAddress.objects.create(address="2600::0100/120", namespace=namespace, status=ipaddr_status),
+        )
+
+        cabled_interfaces[0].add_ip_addresses([ipaddresses[0], ipaddresses[2]])
+        cabled_interfaces[1].add_ip_addresses([ipaddresses[1], ipaddresses[3]])
         # Virtual Device Context
         vdc_status = Status.objects.get_for_model(VirtualDeviceContext).first()
         vdcs = [
@@ -2623,6 +2648,14 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         with self.subTest("device (pk) filter with an invalid uuid"):
             self.assertFalse(self.filterset({"device": [uuid.uuid4()]}, self.queryset).is_valid())
 
+    def test_ip_addresses(self):
+        addresses = list(IPAddress.objects.filter(interfaces__isnull=False)[:2])
+        params = {"ip_addresses": [addresses[0].address, addresses[1].id]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(ip_addresses__in=addresses).distinct(),
+        )
+
     def test_kind(self):
         # TODO: Not a generic_filter_test because this is a single-value filter
         # 2.0 TODO: Support filtering for multiple values

nautobot/dcim/tests/test_forms.py

@@ -1,8 +1,16 @@
 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.forms import DeviceFilterForm, DeviceForm, InterfaceCreateForm, InterfaceForm, RackForm
+from nautobot.dcim.forms import (
+    DeviceFilterForm,
+    DeviceForm,
+    InterfaceBulkEditForm,
+    InterfaceCreateForm,
+    InterfaceForm,
+    RackForm,
+)
 from nautobot.dcim.models import (
     Device,
     DeviceType,
@@ -320,7 +328,7 @@ class RackTestCase(TestCase):
         self.assertTrue(form.is_valid())
 
 
-class InterfaceTestCase(TestCase):
+class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.device = Device.objects.first()
@@ -380,3 +388,44 @@ class InterfaceTestCase(TestCase):
         self.vlan.locations.clear()
         form = InterfaceForm(data=self.data, instance=self.interface)
         self.assertTrue(form.is_valid())
+
+    def test_untagged_vlans_dropdown_options_align_in_interface_edit_form_and_bulk_edit_form(self):
+        """
+        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:
+            device.location = location
+            device.save()
+        interfaces = (
+            Interface.objects.create(
+                device=devices[0],
+                name="Test Interface 1",
+                type=InterfaceTypeChoices.TYPE_2GFC_SFP,
+                status=status,
+            ),
+            Interface.objects.create(
+                device=devices[1],
+                name="Test Interface 2",
+                type=InterfaceTypeChoices.TYPE_LAG,
+                status=status,
+            ),
+            Interface.objects.create(
+                device=devices[2],
+                name="Test Interface 3",
+                type=InterfaceTypeChoices.TYPE_100ME_FIXED,
+                status=status,
+            ),
+        )
+        edit_form = InterfaceForm(data=self.data, instance=interfaces[0])
+        bulk_edit_form = InterfaceBulkEditForm(
+            model=Interface,
+            data={"pks": [interface.pk for interface in interfaces]},
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            edit_form.fields["untagged_vlan"].queryset,
+            bulk_edit_form.fields["untagged_vlan"].queryset,
+        )

nautobot/dcim/tests/test_graphql.py

@@ -83,3 +83,55 @@ class GraphQLTestCase(TestCase):
             self.assertEqual(
                 resp["data"]["devices"][0]["platform"]["network_driver_mappings"]["scrapli"], "cisco_iosxe"
             )
+
+        with self.subTest("device serial number query"):
+            non_empty_serial_device = Device.objects.first()
+            non_empty_serial_device.serial = "1234567890abceFGHIJKL"
+            non_empty_serial_device.save()
+
+            # Test device serial query default behavior: serial__ie
+            query = 'query { devices (serial: " ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertEqual(device["serial"], "")
+
+            # Test device serial default filter with non-empty serial number
+            query = 'query { devices (serial:"' + non_empty_serial_device.serial.lower() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            self.assertEqual(resp["data"]["devices"][0]["serial"], non_empty_serial_device.serial)
+
+            # Test device serial iexact filter with non-empty serial number
+            query = 'query { devices (serial__ie:"' + non_empty_serial_device.serial.upper() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            self.assertEqual(resp["data"]["devices"][0]["serial"], non_empty_serial_device.serial)
+
+            # Test device serial__nie filter with non-empty serial number
+            query = 'query { devices (serial__nie:"' + non_empty_serial_device.serial.lower() + '") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], non_empty_serial_device.serial)
+
+            # Test device serial__ie filter with empty serial number
+            query = 'query { devices (serial__ie:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertEqual(device["serial"], "")
+
+            # Test device serial__nie filter with empty serial number
+            query = 'query { devices (serial__nie:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], "")
+
+            # Test device serial__n filter with empty serial number
+            query = 'query { devices (serial__n:" ") { name serial } }'
+            resp = execute_query(query, user=self.user).to_dict()
+            self.assertFalse(resp["data"].get("error"))
+            for device in resp["data"]["devices"]:
+                self.assertNotEqual(device["serial"], "")

nautobot/dcim/tests/test_jobs.py

@@ -0,0 +1,118 @@
+from django.contrib.contenttypes.models import ContentType
+
+from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
+from nautobot.dcim.models import (
+    Device,
+    DeviceType,
+    DeviceTypeToSoftwareImageFile,
+    Location,
+    LocationType,
+    Manufacturer,
+    Platform,
+    SoftwareImageFile,
+    SoftwareVersion,
+)
+from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.models import JobLogEntry, Role, Status
+
+
+def create_common_data_for_software_related_test_cases():
+    manufacturer = Manufacturer.objects.create(name="Manufacturer 1")
+    Platform.objects.create(name="Platform 1")
+    platform = Platform.objects.create(name="Platform 2", manufacturer=manufacturer)
+
+    status = Status.objects.first()
+    software_version_ct = ContentType.objects.get_for_model(SoftwareVersion)
+    software_image_file_ct = ContentType.objects.get_for_model(SoftwareImageFile)
+    status.content_types.add(software_version_ct)
+    status.content_types.add(software_image_file_ct)
+
+    software_version = SoftwareVersion.objects.create(
+        platform=platform,
+        version="Test version 1.0.0",
+        status=status,
+    )
+    software_image_file = SoftwareImageFile.objects.create(
+        software_version=software_version,
+        image_file_name="software_image_file_qs_test_1.bin",
+        status=status,
+    )
+
+    device_type = DeviceType.objects.create(
+        manufacturer=manufacturer,
+        model="Cisco CSR1000v",
+        u_height=0,
+    )
+
+    device_ct = ContentType.objects.get_for_model(Device)
+
+    device_role = Role.objects.create(name="Device Status")
+    device_role.content_types.set([device_ct])
+
+    location_type = LocationType.objects.create(name="Test Location Type")
+    location_type.content_types.set([device_ct])
+    location = Location.objects.create(
+        name="Device Location",
+        location_type=location_type,
+        status=Status.objects.get_for_model(Location).first(),
+    )
+    device_status = Status.objects.get_for_model(Device).first()
+    Device.objects.create(
+        device_type=device_type,
+        role=device_role,
+        name="Device 1",
+        location=location,
+        status=device_status,
+        software_version=software_version,
+    )
+    DeviceTypeToSoftwareImageFile.objects.create(device_type=device_type, software_image_file=software_image_file)
+
+
+class TestSoftwareImageFileTestCase(TransactionTestCase):
+    def test_correct_handling_for_model_protected_error(self):
+        create_common_data_for_software_related_test_cases()
+        software_image_file = SoftwareImageFile.objects.first()
+
+        self.add_permissions("dcim.delete_softwareimagefile")
+        pk_list = [str(software_image_file.pk)]
+        initial_count = SoftwareImageFile.objects.all().count()
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=ContentType.objects.get_for_model(SoftwareImageFile).id,
+            delete_all=False,
+            filter_query_params={},
+            pk_list=pk_list,
+            username=self.user.username,
+        )
+        logs = JobLogEntry.objects.filter(job_result=job_result)
+        print([(log.message, log.log_level) for log in logs])
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn("Caught ProtectedError while attempting to delete objects", error_log.message)
+        self.assertEqual(initial_count, SoftwareImageFile.objects.all().count())
+
+
+class TestSoftwareVersionTestCase(TransactionTestCase):
+    def test_correct_handling_for_model_protected_error(self):
+        create_common_data_for_software_related_test_cases()
+        software_version = SoftwareVersion.objects.first()
+
+        initial_count = SoftwareVersion.objects.all().count()
+        self.add_permissions("dcim.delete_softwareversion")
+        pk_list = [str(software_version.pk)]
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=ContentType.objects.get_for_model(SoftwareVersion).id,
+            delete_all=False,
+            filter_query_params={},
+            pk_list=pk_list,
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn("Caught ProtectedError while attempting to delete objects", error_log.message)
+        self.assertEqual(initial_count, SoftwareVersion.objects.all().count())

nautobot/dcim/tests/test_models.py

@@ -4,6 +4,7 @@ from constance.test import override_config
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.db import IntegrityError
+from django.db.models import Model
 from django.test import TestCase
 from django.test.utils import override_settings
 
@@ -77,7 +78,7 @@ class ModularDeviceComponentTestCaseMixin:
 
     # fields required to create instances of the model, with the exception of name, device_field and module_field
     modular_component_create_data = {}
-    model = None
+    model: type[Model]
     device_field = "device"  # field name for the parent device
     module_field = "module"  # field name for the parent module
 
@@ -1954,6 +1955,8 @@ class CableTestCase(ModelTestCases.BaseModelTestCase):
 
     @classmethod
     def setUpTestData(cls):
+        cls.interface_choices = {section[0]: dict(section[1]) for section in InterfaceTypeChoices.CHOICES}
+
         location = Location.objects.first()
         manufacturer = Manufacturer.objects.first()
         devicetype = DeviceType.objects.create(
@@ -2182,19 +2185,59 @@ class CableTestCase(ModelTestCases.BaseModelTestCase):
         """
         A cable cannot terminate to a virtual interface
         """
-        virtual_interface = Interface(device=self.device1, name="V1", type=InterfaceTypeChoices.TYPE_VIRTUAL)
-        cable = Cable(termination_a=self.interface2, termination_b=virtual_interface)
-        with self.assertRaises(ValidationError):
-            cable.clean()
+        virtual_interface_choices = self.interface_choices["Virtual interfaces"]
+
+        self.cable.delete()
+        interface_status = Status.objects.get_for_model(Interface).first()
+
+        for virtual_interface_type in virtual_interface_choices:
+            virtual_interface = Interface.objects.create(
+                device=self.device1,
+                name=f"V-{virtual_interface_type}",
+                type=virtual_interface_type,
+                status=interface_status,
+            )
+            with self.assertRaises(
+                ValidationError,
+                msg=f"Virtual interface type '{virtual_interface_choices[virtual_interface_type]}' should not accept a cable.",
+            ) as cm:
+                Cable(
+                    termination_a=self.interface2,
+                    termination_b=virtual_interface,
+                ).clean()
+
+            self.assertIn(
+                f"Cables cannot be terminated to {virtual_interface_choices[virtual_interface_type]} interfaces",
+                str(cm.exception),
+            )
 
     def test_cable_cannot_terminate_to_a_wireless_interface(self):
         """
         A cable cannot terminate to a wireless interface
         """
-        wireless_interface = Interface(device=self.device1, name="W1", type=InterfaceTypeChoices.TYPE_80211A)
-        cable = Cable(termination_a=self.interface2, termination_b=wireless_interface)
-        with self.assertRaises(ValidationError):
-            cable.clean()
+        wireless_interface_choices = self.interface_choices["Wireless"]
+
+        self.cable.delete()
+        interface_status = Status.objects.get_for_model(Interface).first()
+
+        for wireless_interface_type in wireless_interface_choices:
+            wireless_interface = Interface.objects.create(
+                device=self.device1,
+                name=f"W-{wireless_interface_type}",
+                type=wireless_interface_type,
+                status=interface_status,
+            )
+
+            with self.assertRaises(
+                ValidationError,
+                msg=f"Wireless interface type '{wireless_interface_choices[wireless_interface_type]}' should not accept a cable.",
+            ) as cm:
+                Cable(termination_a=self.interface2, termination_b=wireless_interface).clean()
+
+            self.assertIn(
+                f"Cables cannot be terminated to {wireless_interface_choices[wireless_interface_type]} interfaces",
+                str(cm.exception),
+            )
 
     def test_create_cable_with_missing_status_connected(self):
         """Test for https://github.com/nautobot/nautobot/issues/2081"""