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

nautobot/dcim/tests/test_filters.py

@@ -1,4 +1,3 @@
-# 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
@@ -45,6 +44,7 @@ from nautobot.dcim.filters import (
     InterfaceRedundancyGroupAssociationFilterSet,
     InterfaceRedundancyGroupFilterSet,
     InterfaceTemplateFilterSet,
+    InterfaceVDCAssignmentFilterSet,
     InventoryItemFilterSet,
     LocationFilterSet,
     LocationTypeFilterSet,
@@ -68,6 +68,7 @@ from nautobot.dcim.filters import (
     SoftwareImageFileFilterSet,
     SoftwareVersionFilterSet,
     VirtualChassisFilterSet,
+    VirtualDeviceContextFilterSet,
 )
 from nautobot.dcim.models import (
     Cable,
@@ -90,6 +91,7 @@ from nautobot.dcim.models import (
     InterfaceRedundancyGroup,
     InterfaceRedundancyGroupAssociation,
     InterfaceTemplate,
+    InterfaceVDCAssignment,
     InventoryItem,
     Location,
     LocationType,
@@ -113,11 +115,13 @@ from nautobot.dcim.models import (
     SoftwareImageFile,
     SoftwareVersion,
     VirtualChassis,
+    VirtualDeviceContext,
 )
 from nautobot.extras.models import ExternalIntegration, Role, SecretsGroup, Status, Tag
 from nautobot.ipam.models import IPAddress, Namespace, Prefix, Service, VLAN, VLANGroup
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import Cluster, ClusterType, VirtualMachine
+from nautobot.wireless.models import RadioProfile, WirelessNetwork
 
 # Use the proper swappable User model
 User = get_user_model()
@@ -594,7 +598,6 @@ def common_test_data(cls):
     )
 
     device_statuses = Status.objects.get_for_model(Device)
-
     cls.devices = (
         Device.objects.create(
             name="Device 1",
@@ -995,11 +998,12 @@ class PathEndpointModelTestMixin:
             )
 
 
-class LocationTypeFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class LocationTypeFilterSetTestCase(FilterTestCases.FilterTestCase):
     queryset = LocationType.objects.all()
     filterset = LocationTypeFilterSet
     generic_filter_tests = [
         ("description",),
+        ("name",),
         ("parent", "parent__id"),
         ("parent", "parent__name"),
     ]
@@ -1031,7 +1035,7 @@ class LocationTypeFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase):
             )
 
 
-class LocationFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
+class LocationFilterSetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = Location.objects.all()
     filterset = LocationFilterSet
     tenancy_related_name = "locations"
@@ -1052,6 +1056,7 @@ class LocationFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase, FilterTe
         ("longitude",),
         ("location_type", "location_type__id"),
         ("location_type", "location_type__name"),
+        ("name",),
         ("parent", "parent__id"),
         ("parent", "parent__name"),
         ("physical_address",),
@@ -1102,17 +1107,13 @@ class LocationFilterSetTestCase(FilterTestCases.NameOnlyFilterTestCase, FilterTe
             Location.objects.filter(location_type__content_types=ct),
         )
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, self.queryset.filter(pk=value))
 
-
-class RackGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class RackGroupTestCase(FilterTestCases.FilterTestCase):
     queryset = RackGroup.objects.all()
     filterset = RackGroupFilterSet
     generic_filter_tests = [
         ("description",),
+        ("name",),
         ("parent", "parent__id"),
         ("parent", "parent__name"),
         ("power_panels", "power_panels__id"),
@@ -1231,11 +1232,6 @@ class RackTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilter
             params = {"outer_unit": [RackDimensionUnitChoices.UNIT_MILLIMETER]}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class RackReservationTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = RackReservation.objects.all()
@@ -1255,13 +1251,8 @@ class RackReservationTestCase(FilterTestCases.FilterTestCase, FilterTestCases.Te
     def setUpTestData(cls):
         common_test_data(cls)
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
 
-
-class ManufacturerTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class ManufacturerTestCase(FilterTestCases.FilterTestCase):
     queryset = Manufacturer.objects.all()
     filterset = ManufacturerFilterSet
     generic_filter_tests = [
@@ -1270,6 +1261,7 @@ class ManufacturerTestCase(FilterTestCases.NameOnlyFilterTestCase):
         ("device_types", "device_types__model"),
         ("inventory_items", "inventory_items__id"),
         ("inventory_items", "inventory_items__name"),
+        ("name",),
         ("platforms", "platforms__id"),
         ("platforms", "platforms__name"),
     ]
@@ -1285,13 +1277,14 @@ class ManufacturerTestCase(FilterTestCases.NameOnlyFilterTestCase):
         InventoryItem.objects.create(device=devices[2], name="Inventory Item 3", manufacturer=cls.manufacturers[2])
 
 
-class DeviceFamilyTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class DeviceFamilyTestCase(FilterTestCases.FilterTestCase):
     queryset = DeviceFamily.objects.all()
     filterset = DeviceFamilyFilterSet
     generic_filter_tests = [
         ("description",),
         ("device_types", "device_types__id"),
         ("device_types", "device_types__model"),
+        ("name",),
     ]
 
 
@@ -1481,11 +1474,6 @@ class DeviceTypeTestCase(FilterTestCases.FilterTestCase):
                 self.queryset.exclude(device_bay_templates__isnull=False),
             )
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class ConsolePortTemplateTestCase(ModularComponentTemplateTestMixin, FilterTestCases.FilterTestCase):
     queryset = ConsolePortTemplate.objects.all()
@@ -1633,7 +1621,7 @@ class DeviceBayTemplateTestCase(ComponentTemplateTestMixin, FilterTestCases.Filt
     filterset = DeviceBayTemplateFilterSet
 
 
-class PlatformTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class PlatformTestCase(FilterTestCases.FilterTestCase):
     queryset = Platform.objects.all()
     filterset = PlatformFilterSet
     generic_filter_tests = [
@@ -1641,6 +1629,7 @@ class PlatformTestCase(FilterTestCases.NameOnlyFilterTestCase):
         ("devices", "devices__id"),
         ("manufacturer", "manufacturer__id"),
         ("manufacturer", "manufacturer__name"),
+        ("name",),
         ("napalm_driver",),
         ("virtual_machines", "virtual_machines__id"),
     ]
@@ -1702,7 +1691,6 @@ 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"),
@@ -1717,6 +1705,8 @@ class DeviceTestCase(
         ("rack", "rack__name"),
         ("rack_group", "rack__rack_group__id"),
         ("rack_group", "rack__rack_group__name"),
+        ("radio_profiles", "controller_managed_device_group__radio_profiles__id"),
+        ("radio_profiles", "controller_managed_device_group__radio_profiles__name"),
         ("rear_ports", "rear_ports__id"),
         ("role", "role__id"),
         ("role", "role__name"),
@@ -1732,6 +1722,8 @@ class DeviceTestCase(
         ("vc_priority",),
         ("virtual_chassis", "virtual_chassis__id"),
         ("virtual_chassis", "virtual_chassis__name"),
+        ("wireless_networks", "controller_managed_device_group__wireless_networks__id"),
+        ("wireless_networks", "controller_managed_device_group__wireless_networks__name"),
     ]
 
     @classmethod
@@ -1773,6 +1765,14 @@ class DeviceTestCase(
         Service.objects.create(device=devices[1], name="dns", protocol="udp", ports=[53])
 
         cls.controller_managed_device_groups = list(ControllerManagedDeviceGroup.objects.all()[:2])
+        cls.controller_managed_device_groups[0].radio_profiles.set(RadioProfile.objects.all()[:2])
+        cls.controller_managed_device_groups[0].wireless_networks.set(
+            WirelessNetwork.objects.filter(controller_managed_device_groups__isnull=True)[:2]
+        )
+        cls.controller_managed_device_groups[1].radio_profiles.set(RadioProfile.objects.all()[2:4])
+        cls.controller_managed_device_groups[1].wireless_networks.set(
+            WirelessNetwork.objects.filter(controller_managed_device_groups__isnull=True)[2:4]
+        )
         cls.device_redundancy_groups = list(DeviceRedundancyGroup.objects.all()[:2])
         Device.objects.filter(pk=devices[0].pk).update(
             controller_managed_device_group=cls.controller_managed_device_groups[0],
@@ -1876,14 +1876,6 @@ 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():
@@ -1929,45 +1921,6 @@ class DeviceTestCase(
                 Device.objects.filter(local_config_context_data__isnull=True),
             )
 
-    def test_search(self):
-        filter_fields = (
-            "name",
-            "serial",
-            "inventory_items__serial",
-            "asset_tag",
-            "device_type__manufacturer__name",
-            "comments",
-        )
-        for filter_field in filter_fields:
-            with self.subTest(f"test q filter by field {filter_field}"):
-                value = (
-                    self.queryset.values_list(filter_field, flat=True)
-                    .exclude(**{f"{filter_field}__in": ["", None]})
-                    .first()
-                )
-                params = {"q": value}
-                # TODO: Remove pylint disable after issue is resolved (see: https://github.com/PyCQA/pylint/issues/7381)
-                # pylint: disable=unsupported-binary-operation
-                qs_filter = (
-                    Q(name__icontains=value)
-                    | Q(serial__icontains=value.strip())
-                    | Q(inventory_items__serial__icontains=value.strip())
-                    | Q(asset_tag__icontains=value.strip())
-                    | Q(device_type__manufacturer__name__icontains=value.strip())
-                    | Q(comments__icontains=value)
-                )
-                self.assertQuerysetEqualAndNotEmpty(
-                    self.filterset(params, self.queryset).qs,
-                    self.queryset.filter(qs_filter),
-                )
-
-        with self.subTest("test q filter by field pk"):
-            value = self.queryset.values_list("pk", flat=True).first()
-            params = {"q": value}
-            self.assertQuerysetEqualAndNotEmpty(
-                self.filterset(params, self.queryset).qs, self.queryset.filter(id=value)
-            )
-
 
 class ConsolePortTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMixin, FilterTestCases.FilterTestCase):
     queryset = ConsolePort.objects.all()
@@ -2178,7 +2131,6 @@ 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"),
@@ -2200,6 +2152,8 @@ class InterfaceTestCase(PathEndpointModelTestMixin, ModularDeviceComponentTestMi
         ("tagged_vlans", "tagged_vlans__vid"),
         ("untagged_vlan", "untagged_vlan__id"),
         ("untagged_vlan", "untagged_vlan__vid"),
+        ("virtual_device_contexts", "virtual_device_contexts__id"),
+        ("virtual_device_contexts", "virtual_device_contexts__name"),
     ]
 
     @classmethod
@@ -2424,20 +2378,17 @@ 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 = [
+            VirtualDeviceContext.objects.create(
+                device=devices[2], status=vdc_status, identifier=200 + idx, name=f"Test VDC {idx}"
+            )
+            for idx in range(3)
+        ]
+        vdcs[0].interfaces.set(lag_interfaces)
+        vdcs[1].interfaces.set(lag_interfaces)
+        vdcs[2].interfaces.set(lag_interfaces)
 
     def test_enabled(self):
         # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
@@ -2672,14 +2623,6 @@ 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
@@ -3089,11 +3032,6 @@ class InventoryItemTestCase(DeviceComponentTestMixin, FilterTestCases.FilterTest
             params = {"serial": "abc"}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class VirtualChassisTestCase(FilterTestCases.FilterTestCase):
     queryset = VirtualChassis.objects.all()
@@ -3178,11 +3116,6 @@ class VirtualChassisTestCase(FilterTestCases.FilterTestCase):
         Device.objects.filter(pk=devices[3].pk).update(virtual_chassis=virtual_chassis[1])
         Device.objects.filter(pk=devices[5].pk).update(virtual_chassis=virtual_chassis[2])
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class CableTestCase(FilterTestCases.FilterTestCase):
     queryset = Cable.objects.all()
@@ -3976,6 +3909,8 @@ class ControllerFilterSetTestCase(FilterTestCases.FilterTestCase):
         ("controller_device", "controller_device__name"),
         ("controller_device_redundancy_group", "controller_device_redundancy_group__id"),
         ("controller_device_redundancy_group", "controller_device_redundancy_group__name"),
+        ("wireless_networks", "controller_managed_device_groups__wireless_networks__id"),
+        ("wireless_networks", "controller_managed_device_groups__wireless_networks__name"),
     )
 
     @classmethod
@@ -4118,3 +4053,130 @@ class ModuleBayTestCase(FilterTestCases.FilterTestCase):
         module_bays = ModuleBay.objects.all()[:2]
         module_bays[0].tags.set(Tag.objects.get_for_model(ModuleBay))
         module_bays[1].tags.set(Tag.objects.get_for_model(ModuleBay)[:3])
+
+
+class VirtualDeviceContextTestCase(FilterTestCases.FilterTestCase, FilterTestCases):
+    queryset = VirtualDeviceContext.objects.all()
+    filterset = VirtualDeviceContextFilterSet
+    generic_filter_tests = [
+        ("description",),
+        ("device", "device__name"),
+        ("device", "device__id"),
+        ("tenant", "tenant__name"),
+        ("tenant", "tenant__id"),
+        ("interfaces", "interfaces__id"),
+        ("interfaces", "interfaces__name"),
+        ("name",),
+        ("role", "role__name"),
+        ("status", "status__name"),
+        ("role", "role__id"),
+        ("status", "status__id"),
+    ]
+
+    @classmethod
+    def setUpTestData(cls):
+        device = Device.objects.first()
+        intf_status = Status.objects.get_for_model(Interface).first()
+        vdc_status = Status.objects.get_for_model(VirtualDeviceContext).first()
+        intf_role = Role.objects.get_for_model(Interface).first()
+        interface = Interface.objects.create(
+            name="Int1", device=device, status=intf_status, role=intf_role, type=InterfaceTypeChoices.TYPE_100GE_CFP
+        )
+        cls.ips_v4 = IPAddress.objects.filter(ip_version=4)[:3]
+        cls.ips_v6 = IPAddress.objects.filter(ip_version=6)[:3]
+        interface.add_ip_addresses([*cls.ips_v4, *cls.ips_v6])
+        vdcs = [
+            VirtualDeviceContext.objects.create(
+                device=device,
+                status=vdc_status,
+                identifier=200 + idx,
+                name=f"Test VDC {idx}",
+                primary_ip4=cls.ips_v4[idx],
+                primary_ip6=cls.ips_v6[idx],
+            )
+            for idx in range(3)
+        ]
+        vdcs[0].tags.set(Tag.objects.get_for_model(VirtualDeviceContext))
+        vdcs[1].tags.set(Tag.objects.get_for_model(VirtualDeviceContext)[:3])
+
+        interfaces = [
+            Interface.objects.create(
+                device=device,
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                name=f"Interface 00{idx}",
+                status=intf_status,
+            )
+            for idx in range(3)
+        ]
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[0], interface=interfaces[0])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[0])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[1])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[2], interface=interfaces[2])
+
+    def test_has_primary_ip(self):
+        # TODO: Not a generic_filter_test because this is a boolean filter but not a RelatedMembershipBooleanFilter
+        with self.subTest():
+            params = {"has_primary_ip": True}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                VirtualDeviceContext.objects.filter(Q(primary_ip4__isnull=False) | Q(primary_ip6__isnull=False)),
+            )
+        with self.subTest():
+            params = {"has_primary_ip": False}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs,
+                VirtualDeviceContext.objects.filter(primary_ip4__isnull=True, primary_ip6__isnull=True),
+            )
+
+    def test_primary_ip4(self):
+        params = {"primary_ip4": ["192.0.2.1/24", self.ips_v4[0].pk]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, VirtualDeviceContext.objects.filter(primary_ip4=self.ips_v4[0])
+        )
+
+    def test_primary_ip6(self):
+        params = {"primary_ip6": ["fe80::8ef:3eff:fe4c:3895/24", self.ips_v6[1].pk]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, VirtualDeviceContext.objects.filter(primary_ip6=self.ips_v6[1])
+        )
+
+
+class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = InterfaceVDCAssignment.objects.all()
+    filterset = InterfaceVDCAssignmentFilterSet
+    generic_filter_tests = [
+        ("virtual_device_context", "virtual_device_context__id"),
+        ("virtual_device_context", "virtual_device_context__name"),
+        ("interface", "interface__id"),
+        ("interface", "interface__name"),
+        ("device", "interface__device__id"),
+        ("device", "interface__device__name"),
+    ]
+
+    @classmethod
+    def setUpTestData(cls):
+        device = Device.objects.first()
+        vdc_status = Status.objects.get_for_model(VirtualDeviceContext)[0]
+        interface_status = Status.objects.get_for_model(Interface)[0]
+        interfaces = [
+            Interface.objects.create(
+                device=device,
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                name=f"Interface 00{idx}",
+                status=interface_status,
+            )
+            for idx in range(3)
+        ]
+        vdcs = [
+            VirtualDeviceContext.objects.create(
+                device=device,
+                status=vdc_status,
+                identifier=200 + idx,
+                name=f"Test VDC {idx}",
+            )
+            for idx in range(3)
+        ]
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[0], interface=interfaces[0])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[0])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[1])
+        InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[2], interface=interfaces[2])

nautobot/dcim/tests/test_forms.py

@@ -1,16 +1,8 @@
 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,
-    InterfaceBulkEditForm,
-    InterfaceCreateForm,
-    InterfaceForm,
-    RackForm,
-)
+from nautobot.dcim.forms import DeviceFilterForm, DeviceForm, InterfaceCreateForm, InterfaceForm, RackForm
 from nautobot.dcim.models import (
     Device,
     DeviceType,
@@ -328,7 +320,7 @@ class RackTestCase(TestCase):
         self.assertTrue(form.is_valid())
 
 
-class InterfaceTestCase(NautobotTestCaseMixin, TestCase):
+class InterfaceTestCase(TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.device = Device.objects.first()
@@ -388,44 +380,3 @@ class InterfaceTestCase(NautobotTestCaseMixin, 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,55 +83,3 @@ 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"], "")