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

nautobot/dcim/tests/test_models.py

@@ -1,5 +1,3 @@
-from __future__ import annotations  # python 3.8
-
 from decimal import Decimal
 
 from constance.test import override_config
@@ -64,6 +62,7 @@ from nautobot.dcim.models import (
     RearPortTemplate,
     SoftwareImageFile,
     SoftwareVersion,
+    VirtualDeviceContext,
 )
 from nautobot.extras import context_managers
 from nautobot.extras.choices import CustomFieldTypeChoices
@@ -1956,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(
@@ -2184,20 +2185,46 @@ class CableTestCase(ModelTestCases.BaseModelTestCase):
         """
         A cable cannot terminate to a virtual interface
         """
-        virtual_interface = Interface(device=self.device1, name="V1", type=InterfaceTypeChoices.TYPE_VIRTUAL)
+        self.cable.delete()
+        interface_status = Status.objects.get_for_model(Interface).first()
+        virtual_interface = Interface.objects.create(
+            device=self.device1,
+            name="V1",
+            type=InterfaceTypeChoices.TYPE_VIRTUAL,
+            status=interface_status,
+        )
         cable = Cable(termination_a=self.interface2, termination_b=virtual_interface)
-        with self.assertRaises(ValidationError):
+        with self.assertRaises(ValidationError) as cm:
             cable.clean()
 
+        virtual_interface_choices = self.interface_choices["Virtual interfaces"]
+        self.assertIn(
+            f"Cables cannot be terminated to {virtual_interface_choices[InterfaceTypeChoices.TYPE_VIRTUAL]} 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)
+        self.cable.delete()
+        interface_status = Status.objects.get_for_model(Interface).first()
+        wireless_interface = Interface.objects.create(
+            device=self.device1,
+            name="W1",
+            type=InterfaceTypeChoices.TYPE_80211A,
+            status=interface_status,
+        )
         cable = Cable(termination_a=self.interface2, termination_b=wireless_interface)
-        with self.assertRaises(ValidationError):
+        with self.assertRaises(ValidationError) as cm:
             cable.clean()
 
+        wireless_interface_choices = self.interface_choices["Wireless"]
+        self.assertIn(
+            f"Cables cannot be terminated to {wireless_interface_choices[InterfaceTypeChoices.TYPE_80211A]} interfaces",
+            str(cm.exception),
+        )
+
     def test_create_cable_with_missing_status_connected(self):
         """Test for https://github.com/nautobot/nautobot/issues/2081"""
         # Delete all cables because some cables has connected status.
@@ -2364,6 +2391,30 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
                 address=f"1.1.1.{last_octet}/32", status=ip_address_status, namespace=cls.namespace
             )
 
+    def test_vdcs_validation_logic(self):
+        """Assert Interface raises error when adding virtual_device_contexts that do not belong to same device as the Interface device."""
+        interface = Interface.objects.create(
+            name="Int1",
+            type=InterfaceTypeChoices.TYPE_VIRTUAL,
+            device=self.device,
+            status=Status.objects.get_for_model(Interface).first(),
+            role=Role.objects.get_for_model(Interface).first(),
+        )
+        vdc = VirtualDeviceContext.objects.create(
+            name="Sample VDC",
+            device=Device.objects.exclude(pk=self.device.pk).first(),
+            identifier=100,
+            status=Status.objects.get_for_model(VirtualDeviceContext).first(),
+        )
+
+        with self.assertRaises(ValidationError) as err:
+            interface.virtual_device_contexts.add(vdc)
+        self.assertEqual(
+            err.exception.message_dict["virtual_device_contexts"][0],
+            f"Virtual Device Context with names {[vdc.name]} must all belong to the "
+            f"same device as the interface's device.",
+        )
+
     def test_tagged_vlan_raise_error_if_mode_not_set_to_tagged(self):
         interface = Interface.objects.create(
             name="Int1",
@@ -3224,3 +3275,103 @@ class ModuleTestCase(ModelTestCases.BaseModelTestCase):
 
 class ModuleTypeTestCase(ModelTestCases.BaseModelTestCase):
     model = ModuleType
+
+
+class VirtualDeviceContextTestCase(ModelTestCases.BaseModelTestCase):
+    model = VirtualDeviceContext
+
+    def test_assigning_primary_ip(self):
+        device = Device.objects.first()
+        vdc_status = Status.objects.get_for_model(VirtualDeviceContext).first()
+        vdc = VirtualDeviceContext(
+            device=device,
+            status=vdc_status,
+            identifier=100,
+            name="Test VDC 1",
+        )
+        vdc.validated_save()
+
+        ip_v4 = IPAddress.objects.filter(ip_version=4).first()
+        ip_v6 = IPAddress.objects.filter(ip_version=6).first()
+
+        vdc.primary_ip4 = ip_v6
+        with self.assertRaises(ValidationError) as err:
+            vdc.validated_save()
+        self.assertIn(
+            f"{ip_v6} is not an IPv4 address",
+            str(err.exception),
+        )
+
+        vdc.primary_ip4 = None
+        vdc.primary_ip6 = ip_v4
+        with self.assertRaises(ValidationError) as err:
+            vdc.validated_save()
+        self.assertIn(
+            f"{ip_v4} is not an IPv6 address",
+            str(err.exception),
+        )
+
+        namespace = Namespace.objects.create(name="test_name_space")
+        Prefix.objects.create(
+            prefix="10.1.1.0/24", namespace=namespace, status=Status.objects.get_for_model(Prefix).first()
+        )
+        vdc.primary_ip4 = IPAddress.objects.create(
+            address="10.1.1.1/24", namespace=namespace, status=Status.objects.get_for_model(IPAddress).first()
+        )
+        with self.assertRaises(ValidationError) as err:
+            vdc.validated_save()
+        self.assertIn(
+            f"{vdc.primary_ip4} is not part of an interface that belongs to this VDC's device.",
+            str(err.exception),
+        )
+
+        # TODO: Uncomment test case when VDC primary_ip interface validation is active
+        # interface = Interface.objects.create(
+        #     name="Int1", device=device, status=intf_status, role=intf_role, type=InterfaceTypeChoices.TYPE_100GE_CFP
+        # )
+        # intf_status = Status.objects.get_for_model(Interface).first()
+        # intf_role = Role.objects.get_for_model(Interface).first()
+        # vdc.primary_ip6 = ip_v6
+        # with self.assertRaises(ValidationError) as err:
+        #     vdc.validated_save()
+        # self.assertIn(
+        #     f"The specified IP address ({ip_v6}) is not assigned to this Virtual Device Context.",
+        #     str(err.exception),
+        # )
+        # interface.virtual_device_contexts.add(vdc)
+        # interface.add_ip_addresses([ip_v4, ip_v6])
+
+    def test_interfaces_validation_logic(self):
+        """Assert Virtual Device COntext raises error when adding interfaces that do not belong to same device as the VDC's device."""
+        device = Device.objects.first()
+        interface = Interface.objects.create(
+            name="Int1",
+            type=InterfaceTypeChoices.TYPE_VIRTUAL,
+            device=device,
+            status=Status.objects.get_for_model(Interface).first(),
+            role=Role.objects.get_for_model(Interface).first(),
+        )
+        vdc = VirtualDeviceContext.objects.create(
+            name="Sample VDC",
+            device=Device.objects.exclude(pk=device.pk).first(),
+            identifier=99,  # factory creates identifiers starting from 100
+            status=Status.objects.get_for_model(VirtualDeviceContext).first(),
+        )
+
+        with self.assertRaises(ValidationError) as err:
+            vdc.interfaces.add(interface)
+        self.assertEqual(
+            err.exception.message_dict["interfaces"][0],
+            f"Interfaces with names {[interface.name]} must all belong to the "
+            f"same device as the Virtual Device Context's device.",
+        )
+
+    def test_modifying_vdc_device_not_allowed(self):
+        vdc = VirtualDeviceContext.objects.first()
+        old_device = vdc.device
+        new_device = Device.objects.exclude(pk=old_device.pk).first()
+        with self.assertRaises(ValidationError) as err:
+            vdc.device = new_device
+            vdc.validated_save()
+
+        self.assertIn("Virtual Device Context's device cannot be changed once created", str(err.exception))

nautobot/dcim/tests/test_signals.py

@@ -104,6 +104,7 @@ class DeviceRedundancyGroupTest(TestCase):
         self.device.device_redundancy_group_priority = 1
         self.device.validated_save()
 
+        # Protected FK constraint prevents deletion of DeviceRedundancyGroup
         Controller.objects.all().delete()
         deviceredundancygroup.delete()
 

nautobot/dcim/tests/test_views.py

@@ -1,6 +1,7 @@
 import datetime
 from decimal import Decimal
 import unittest
+import zoneinfo
 
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
@@ -10,11 +11,6 @@ from django.urls import reverse
 from netaddr import EUI
 import yaml
 
-try:
-    import zoneinfo
-except ImportError:  # python 3.8
-    from backports import zoneinfo
-
 from nautobot.circuits.choices import CircuitTerminationSideChoices
 from nautobot.circuits.models import Circuit, CircuitTermination, CircuitType, Provider
 from nautobot.core.templatetags.buttons import job_export_url, job_import_url
@@ -58,6 +54,7 @@ from nautobot.dcim.filters import (
     PowerConnectionFilterSet,
     SoftwareImageFileFilterSet,
     SoftwareVersionFilterSet,
+    VirtualDeviceContextFilterSet,
 )
 from nautobot.dcim.models import (
     Cable,
@@ -104,6 +101,7 @@ from nautobot.dcim.models import (
     SoftwareImageFile,
     SoftwareVersion,
     VirtualChassis,
+    VirtualDeviceContext,
 )
 from nautobot.dcim.views import (
     ConsoleConnectionsListView,
@@ -118,6 +116,7 @@ from nautobot.extras.models import (
     CustomField,
     CustomFieldChoice,
     ExternalIntegration,
+    JobResult,
     Relationship,
     RelationshipAssociation,
     Role,
@@ -1153,9 +1152,15 @@ module-bays:
         }
 
         response = self.client.post(url, data)
+        job_result = JobResult.objects.filter(name="Bulk Edit Objects").first()
+        # Assert successfull redirect to Job Results; whcih means no form validation error was raised
+        self.assertRedirects(
+            response,
+            reverse("extras:jobresult", args=[job_result.pk]),
+            status_code=302,
+            target_status_code=200,
+        )
         self.assertHttpStatus(response, 302)
-        for instance in self._get_queryset().filter(pk__in=pk_list):
-            self.assertEqual(instance.u_height, data["u_height"])
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_rack_height_bulk_edit_invalid(self):
@@ -1171,7 +1176,12 @@ module-bays:
         }
 
         response = self.client.post(url, data)
-        self.assertBodyContains(response, "failed validation")
+        response_content = response.content.decode(response.charset)
+        self.assertHttpStatus(response, 200)
+        self.assertInHTML(
+            '<strong class="panel-title">U height</strong>: <ul class="errorlist"><li>Ensure this value is greater than or equal to 0.</li></ul>',
+            response_content,
+        )
 
 
 class ModuleTypeTestCase(
@@ -2231,6 +2241,24 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "controller_managed_device_group": ControllerManagedDeviceGroup.objects.first().pk,
         }
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_vdc_panel_includes_add_vdc_btn(self):
+        """Assert Add Virtual device Contexts button is in Device detail view: Issue from #6348"""
+        device = Device.objects.first()
+        url = reverse("dcim:device", kwargs={"pk": device.pk})
+        response = self.client.get(url)
+        response_body = extract_page_body(response.content.decode(response.charset))
+
+        add_vdc_url = reverse("dcim:virtualdevicecontext_add")
+        return_url = device.get_absolute_url()
+        expected_add_vdc_button_html = f"""
+        <a href="{add_vdc_url}?device={device.id}&amp;return_url={return_url}" class="btn btn-primary btn-xs">
+            <span class="mdi mdi-plus-thick" aria-hidden="true"></span> Add virtual device context
+        </a>
+        """
+        self.assertInHTML(expected_add_vdc_button_html, response_body)
+        self.assertIn("Add virtual device context", response_body)
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_device_consoleports(self):
         device = Device.objects.first()
@@ -3086,6 +3114,15 @@ class InterfaceTestCase(ViewTestCases.DeviceComponentViewTestCase):
                 vlan_group=vlan_group,
             ),
         )
+        vdcs = [
+            VirtualDeviceContext.objects.create(
+                name=f"Interface VirtualDeviceContext {i}",
+                device=device,
+                status=Status.objects.get_for_model(VirtualDeviceContext).first(),
+                identifier=100 + i,
+            )
+            for i in range(2)
+        ]
 
         cls.form_data = {
             "device": device.pk,
@@ -3102,6 +3139,7 @@ class InterfaceTestCase(ViewTestCases.DeviceComponentViewTestCase):
             "mode": InterfaceModeChoices.MODE_TAGGED,
             "untagged_vlan": vlans[0].pk,
             "tagged_vlans": [v.pk for v in vlans[1:4]],
+            "virtual_device_contexts": [v.pk for v in vdcs],
             "tags": [t.pk for t in Tag.objects.get_for_model(Interface)],
         }
 
@@ -3124,6 +3162,7 @@ class InterfaceTestCase(ViewTestCases.DeviceComponentViewTestCase):
             "status": status_active.pk,
             "role": role.pk,
             "vrf": vrfs[0].pk,
+            "virtual_device_contexts": [v.pk for v in vdcs],
         }
 
         cls.bulk_add_data = {
@@ -4553,46 +4592,6 @@ class SoftwareImageFileTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "download_url": "https://example.com/software_image_file_test_case.bin",
         }
 
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_correct_handling_for_model_protected_error(self):
-        platform = Platform.objects.first()
-        software_version_status = Status.objects.get_for_model(SoftwareVersion).first()
-        software_image_file_status = Status.objects.get_for_model(SoftwareImageFile).first()
-        software_version = SoftwareVersion.objects.create(
-            platform=platform, version="Test version 1.0.0", status=software_version_status
-        )
-        software_image_file = SoftwareImageFile.objects.create(
-            software_version=software_version,
-            image_file_name="software_image_file_qs_test_1.bin",
-            status=software_image_file_status,
-        )
-        device_type = DeviceType.objects.first()
-        device_role = Role.objects.get_for_model(Device).first()
-        device_status = Status.objects.get_for_model(Device).first()
-        location = Location.objects.filter(location_type__name="Campus").first()
-        Device.objects.create(
-            device_type=device_type,
-            role=device_role,
-            name="Device 1",
-            location=location,
-            status=device_status,
-            software_version=software_version,
-        )
-        device_type_to_software_image_file = DeviceTypeToSoftwareImageFile.objects.create(
-            device_type=device_type, software_image_file=software_image_file
-        )
-
-        self.add_permissions("dcim.delete_softwareimagefile")
-        pk_list = [software_image_file.pk]
-        data = {
-            "pk": pk_list,
-            "confirm": True,
-            "_confirm": True,  # Form button
-        }
-        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
-        # Assert protected error message included in the response body
-        self.assertBodyContains(response, f"<span>{device_type_to_software_image_file}</span>", html=True)
-
 
 class SoftwareVersionTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = SoftwareVersion
@@ -4631,46 +4630,6 @@ class SoftwareVersionTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "pre_release": True,
         }
 
-    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
-    def test_correct_handling_for_model_protected_error(self):
-        platform = Platform.objects.first()
-        software_version_status = Status.objects.get_for_model(SoftwareVersion).first()
-        software_image_file_status = Status.objects.get_for_model(SoftwareImageFile).first()
-        software_version = SoftwareVersion.objects.create(
-            platform=platform, version="Test version 1.0.0", status=software_version_status
-        )
-        software_image_file = SoftwareImageFile.objects.create(
-            software_version=software_version,
-            image_file_name="software_image_file_qs_test_1.bin",
-            status=software_image_file_status,
-        )
-        device_type = DeviceType.objects.first()
-        device_role = Role.objects.get_for_model(Device).first()
-        device_status = Status.objects.get_for_model(Device).first()
-        location = Location.objects.filter(location_type__name="Campus").first()
-        Device.objects.create(
-            device_type=device_type,
-            role=device_role,
-            name="Device 1",
-            location=location,
-            status=device_status,
-            software_version=software_version,
-        )
-        device_type_to_software_image_file = DeviceTypeToSoftwareImageFile.objects.create(
-            device_type=device_type, software_image_file=software_image_file
-        )
-
-        self.add_permissions("dcim.delete_softwareversion")
-        pk_list = [software_version.pk]
-        data = {
-            "pk": pk_list,
-            "confirm": True,
-            "_confirm": True,  # Form button
-        }
-        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
-        # Assert protected error message included in the response body
-        self.assertBodyContains(response, f"<span>{device_type_to_software_image_file}</span>", html=True)
-
 
 class ControllerTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = Controller
@@ -4721,8 +4680,79 @@ class ControllerManagedDeviceGroupTestCase(ViewTestCases.PrimaryObjectViewTestCa
             "controller": controllers[0].pk,
             "weight": 100,
             "devices": [item.pk for item in Device.objects.all()[:2]],
+            # Management form fields required for the dynamic Wireless Network formset
+            "wireless_network_assignments-TOTAL_FORMS": "0",
+            "wireless_network_assignments-INITIAL_FORMS": "1",
+            "wireless_network_assignments-MIN_NUM_FORMS": "0",
+            "wireless_network_assignments-MAX_NUM_FORMS": "1000",
         }
 
         cls.bulk_edit_data = {
             "weight": 300,
         }
+
+
+class VirtualDeviceContextTestCase(ViewTestCases.PrimaryObjectViewTestCase):
+    model = VirtualDeviceContext
+    filterset = VirtualDeviceContextFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        devices = Device.objects.filter(interfaces__isnull=False)
+        vdc_status = Status.objects.get_for_model(VirtualDeviceContext)[0]
+        tenants = Tenant.objects.all()
+
+        cls.form_data = {
+            "name": "Virtual Device Context 1",
+            "device": devices[0].pk,
+            "identifier": 100,
+            "status": vdc_status.pk,
+            "tenant": tenants[0].pk,
+            "interfaces": [interface.pk for interface in devices[0].all_interfaces[:3]],
+            "description": "Sample Description",
+        }
+
+        cls.update_data = {
+            "name": "Virtual Device Context 3",
+            "tenant": tenants[3].pk,
+            "status": vdc_status.pk,
+        }
+
+        cls.bulk_edit_data = {
+            "tenant": tenants[1].pk,
+        }
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_update_vdc_primary_ips(self):
+        """Test assigning a primary IP to a virtual device context."""
+        self.add_permissions("dcim.change_virtualdevicecontext")
+        vdc = VirtualDeviceContext.objects.first()
+        device = vdc.device
+        intf_status = Status.objects.get_for_model(Interface).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,
+        )
+        ip_v4 = IPAddress.objects.filter(ip_version=4).first()
+        ip_v6 = IPAddress.objects.filter(ip_version=6).first()
+        interface.virtual_device_contexts.add(vdc)
+        interface.add_ip_addresses([ip_v4, ip_v6])
+
+        form_data = self.form_data.copy()
+        form_data["device"] = vdc.device
+        form_data["interfaces"] = [interface.pk]
+        form_data["primary_ip4"] = ip_v4.pk
+        form_data["primary_ip6"] = ip_v6.pk
+        # Assert that update succeeds.
+        request = {
+            "path": self._get_url("edit", vdc),
+            "data": post_data(form_data),
+        }
+        self.assertHttpStatus(self.client.post(**request), 302)
+        vdc.refresh_from_db()
+        self.assertEqual(vdc.primary_ip6, ip_v6)
+        self.assertEqual(vdc.primary_ip4, ip_v4)